= mapMinZoom) && (z <= mapMaxZoom)) {\\n return url + path;\\n } else {\\n return emptyTileURL;\\n }\\n }\\n \\\"\\\"\\\" % args # noqa\\n\\n elif self.options.profile == 'geodetic':\\n s += \\\"\\\"\\\"\\n function getURL(bounds) {\\n bounds = this.adjustBounds(bounds);\\n var res = this.getServerResolution();\\n var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));\\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\\n var z = this.getServerZoom()%(tmsoffset)s;\\n var path = this.serviceVersion + \\\"/\\\" + this.layername + \\\"/\\\" + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n var url = this.url;\\n if (OpenLayers.Util.isArray(url)) {\\n url = this.selectUrl(path, url);\\n }\\n if (mapBounds.intersectsBounds(bounds) && (z >= mapMinZoom) && (z <= mapMaxZoom)) {\\n return url + path;\\n } else {\\n return emptyTileURL;\\n }\\n }\\n \\\"\\\"\\\" % args # noqa\\n\\n elif self.options.profile == 'raster':\\n s += \\\"\\\"\\\"\\n function getURL(bounds) {\\n bounds = this.adjustBounds(bounds);\\n var res = this.getServerResolution();\\n var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));\\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\\n var z = this.getServerZoom();\\n var path = this.serviceVersion + \\\"/\\\" + this.layername + \\\"/\\\" + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n var url = this.url;\\n if (OpenLayers.Util.isArray(url)) {\\n url = this.selectUrl(path, url);\\n }\\n if (mapBounds.intersectsBounds(bounds) && (z >= mapMinZoom) && (z <= mapMaxZoom)) {\\n return url + path;\\n } else {\\n return emptyTileURL;\\n }\\n }\\n \\\"\\\"\\\" % args # noqa\\n\\n s += \\\"\\\"\\\"\\n function getWindowHeight() {\\n if (self.innerHeight) return self.innerHeight;\\n if (document.documentElement && document.documentElement.clientHeight)\\n return document.documentElement.clientHeight;\\n if (document.body) return document.body.clientHeight;\\n return 0;\\n }\\n\\n function getWindowWidth() {\\n if (self.innerWidth) return self.innerWidth;\\n if (document.documentElement && document.documentElement.clientWidth)\\n return document.documentElement.clientWidth;\\n if (document.body) return document.body.clientWidth;\\n return 0;\\n }\\n\\n function resize() {\\n var map = document.getElementById(\\\"map\\\");\\n var header = document.getElementById(\\\"header\\\");\\n var subheader = document.getElementById(\\\"subheader\\\");\\n map.style.height = (getWindowHeight()-80) + \\\"px\\\";\\n map.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n header.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n subheader.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n if (map.updateSize) { map.updateSize(); };\\n }\\n\\n onresize=function(){ resize(); };\\n\\n </script>\\n </head>\\n <body onload=\\\"init()\\\">\\n <div id=\\\"header\\\"><h1>%(title)s</h1></div>\\n <div id=\\\"subheader\\\">Generated by <a href=\\\"http://www.klokan.cz/projects/gdal2tiles/\\\">GDAL2Tiles</a>, Copyright © 2008 <a href=\\\"http://www.klokan.cz/\\\">Klokan Petr Pridal</a>, <a href=\\\"http://www.gdal.org/\\\">GDAL</a> & <a href=\\\"http://www.osgeo.org/\\\">OSGeo</a> <a href=\\\"http://code.google.com/soc/\\\">GSoC</a>\\n <!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->\\n </div>\\n <div id=\\\"map\\\"></div>\\n <script type=\\\"text/javascript\\\" >resize()</script>\\n </body>\\n </html>\\\"\\\"\\\" % args # noqa\\n\\n return s\",\n \"def mapviewer(request):\\n\\n precip_layer1 = geeutils.getPrecipMap(accumulation=1)\\n precip_layer3 = geeutils.getPrecipMap(accumulation=3)\\n precip_layer7 = geeutils.getPrecipMap(accumulation=7)\\n #flood_viir = 'None' #geeutils.getfloodMap(snsr='atms')\\n #flood_sentinel = geeutils.getfloodMap(\\\"sentinel1\\\",\\\"2010-01-01\\\")\\n #flood_atms = geeutils.getfloodMap(\\\"atms\\\", \\\"2010-01-01\\\")\\n #print(flood_sentinel)\\n\\n historical_layer = geeutils.getHistoricalMap(region,'2010-01-01','2015-12-31',month=8,algorithm='JRC')\\n\\n image = ee.Image(wc.filter(ee.Filter.eq('sensor','sentinel1')).first())\\n #sentinel1_layer = geeutils.getTileLayerUrl(image.updateMask(image).visualize(palette='#9999ff'))\\n\\n\\n product_selection = SelectInput(\\n # display_text='Select precipitation product:',\\n name='product_selection',\\n multiple=False,\\n options=[('1 Day Accumulation', '1|'+precip_layer1),\\n ('3 Day Accumulation', '2|'+precip_layer3),\\n ('7 Day Accumulation', '3|'+precip_layer7)],\\n initial=['1 Day Accumulation'],\\n select2_options={'placeholder': 'Select a product',\\n 'allowClear': False}\\n )\\n\\n\\n browse_selection = SelectInput(\\n # display_text='Select precipitation product:',\\n name='browse_selection',\\n multiple=False,\\n options=[('VIIRS NRT TRUE COLOR', '1|VIIRS_SNPP_CorrectedReflectance_TrueColor'),\\n ('VIIRS NRT NATURAL COLOR', '2|VIIRS_SNPP_CorrectedReflectance_BandsM11-I2-I1'),\\n ('MODIS AQUA TRUE COLOR', '3|MODIS_Aqua_CorrectedReflectance_TrueColor'),\\n ('MODIS AQUA NATURAL COLOR', '4|MODIS_Aqua_CorrectedReflectance_Bands721'),\\n ('MODIS TERRA TRUE COLOR', '5|MODIS_Terra_CorrectedReflectance_TrueColor'),\\n ('MODIS TERRA NATURAL COLOR', '5|MODIS_Terra_CorrectedReflectance_Bands721')],\\n initial=['VIIRS NRT NATURAL COLOR'],\\n select2_options={'placeholder': 'Select browse imagery:',\\n 'allowClear': False}\\n )\\n\\n sensor_selection = SelectInput(\\n # display_text='Select precipitation product:',\\n name='sensor_selection',\\n multiple=False,\\n options=[ ('select sensor', 'none'),\\n ('Sentinel 1', 'sentinel1'),\\n ('ATMS', 'atms')],\\n initial=['select sensor'],\\n select2_options={'placeholder': 'Select sensor:',\\n 'allowClear': False}\\n )\\n\\n context = {\\n 'precip_layer': precip_layer1,\\n 'historical_layer': historical_layer,\\n 'admin_layer': admin_layer,\\n 'product_selection': product_selection,\\n 'browse_selection': browse_selection,\\n 'sensor_selection':sensor_selection,\\n }\\n\\n return render(request, 'hydraviewer/map.html', context)\",\n \"def map():\\n return render_template('map.html')\",\n \"def map():\\n\\n return render_template(\\\"map.html\\\")\",\n \"def generate_openlayers( self ):\\n\\n args = {}\\n args['title'] = self.options.title\\n args['googlemapskey'] = self.options.googlekey\\n args['yahooappid'] = self.options.yahookey\\n args['south'], args['west'], args['north'], args['east'] = self.swne\\n args['minzoom'] = self.tminz\\n args['maxzoom'] = self.tmaxz\\n args['tilesize'] = self.tilesize\\n args['tileformat'] = format_extension[self.image_output.format]\\n if self.image_output.format == \\\"PNG\\\":\\n args['has_alpha'] = 'true'\\n else:\\n args['has_alpha'] = 'false'\\n args['publishurl'] = \\\"\\\" if self.options.url is None else self.options.url\\n args['copyright'] = self.options.copyright\\n if self.options.profile in ('raster', 'gearth'):\\n args['rasterzoomlevels'] = self.tmaxz+1\\n args['rastermaxresolution'] = 2**(self.nativezoom) * self.out_gt[1]\\n\\n s = \\\"\\\"\\\"<!DOCTYPE html PUBLIC \\\"-//W3C//DTD XHTML 1.0 Strict//EN\\\" \\\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\\\">\\n <html xmlns=\\\"http://www.w3.org/1999/xhtml>\\\"\\n <head>\\n <title>%(title)s</title>\\n <meta http-equiv='imagetoolbar' content='no'/>\\n <style type=\\\"text/css\\\"> v\\\\:* {behavior:url(#default#VML);}\\n html, body { overflow: hidden; padding: 0; height: 100%%; width: 100%%; font-family: 'Lucida Grande',Geneva,Arial,Verdana,sans-serif; }\\n body { margin: 10px; background: #fff; }\\n h1 { margin: 0; padding: 6px; border:0; font-size: 20pt; }\\n #header { height: 43px; padding: 0; background-color: #eee; border: 1px solid #888; }\\n #subheader { height: 12px; text-align: right; font-size: 10px; color: #555;}\\n #map { height: 95%%; border: 1px solid #888; }\\n </style>\\\"\\\"\\\" % args\\n\\n if self.options.profile == 'mercator':\\n s += \\\"\\\"\\\"\\n <script src='http://dev.virtualearth.net/mapcontrol/mapcontrol.ashx?v=6.1'></script>\\n <script src='http://maps.google.com/maps?file=api&v=2&key=%(googlemapskey)s' type='text/javascript'></script>\\n <script src=\\\"http://api.maps.yahoo.com/ajaxymap?v=3.0&appid=%(yahooappid)s\\\"></script>\\\"\\\"\\\" % args\\n\\n s += \\\"\\\"\\\"\\n <script src=\\\"http://www.openlayers.org/api/2.7/OpenLayers.js\\\" type=\\\"text/javascript\\\"></script>\\n <script type=\\\"text/javascript\\\">\\n var map;\\n var mapBounds = new OpenLayers.Bounds( %(west)s, %(south)s, %(east)s, %(north)s);\\n var mapMinZoom = %(minzoom)s;\\n var mapMaxZoom = %(maxzoom)s;\\n\\n // avoid pink tiles\\n OpenLayers.IMAGE_RELOAD_ATTEMPTS = 3;\\n OpenLayers.Util.onImageLoadErrorColor = \\\"transparent\\\";\\n\\n function init(){\\\"\\\"\\\" % args\\n\\n if self.options.profile == 'mercator':\\n s += \\\"\\\"\\\"\\n var options = {\\n controls: [],\\n projection: new OpenLayers.Projection(\\\"EPSG:900913\\\"),\\n displayProjection: new OpenLayers.Projection(\\\"EPSG:4326\\\"),\\n units: \\\"m\\\",\\n maxResolution: 156543.0339,\\n maxExtent: new OpenLayers.Bounds(-20037508, -20037508, 20037508, 20037508.34)\\n };\\n map = new OpenLayers.Map('map', options);\\n\\n // create Google Mercator layers\\n var gmap = new OpenLayers.Layer.Google(\\\"Google Streets\\\",\\n { sphericalMercator: true, numZoomLevels: 20} );\\n var gsat = new OpenLayers.Layer.Google(\\\"Google Satellite\\\",\\n {type: G_SATELLITE_MAP, sphericalMercator: true, numZoomLevels: 20} );\\n var ghyb = new OpenLayers.Layer.Google(\\\"Google Hybrid\\\",\\n {type: G_HYBRID_MAP, sphericalMercator: true, numZoomLevels: 20});\\n var gter = new OpenLayers.Layer.Google(\\\"Google Terrain\\\",\\n {type: G_PHYSICAL_MAP, sphericalMercator: true, numZoomLevels: 20 });\\n\\n // create Virtual Earth layers\\n OpenLayers.Layer.VirtualEarth.prototype.MAX_ZOOM_LEVEL=19;\\n OpenLayers.Layer.VirtualEarth.prototype.RESOLUTIONS=OpenLayers.Layer.Google.prototype.RESOLUTIONS\\n var veroad = new OpenLayers.Layer.VirtualEarth(\\\"Virtual Earth Roads\\\",\\n {'type': VEMapStyle.Road, 'sphericalMercator': true, numZoomLevels: 20});\\n var veaer = new OpenLayers.Layer.VirtualEarth(\\\"Virtual Earth Aerial\\\",\\n {'type': VEMapStyle.Aerial, 'sphericalMercator': true, numZoomLevels: 20 });\\n var vehyb = new OpenLayers.Layer.VirtualEarth(\\\"Virtual Earth Hybrid\\\",\\n {'type': VEMapStyle.Hybrid, 'sphericalMercator': true});\\n\\n // create Yahoo layer\\n var yahoo = new OpenLayers.Layer.Yahoo(\\\"Yahoo Street\\\",\\n {'sphericalMercator': true});\\n var yahoosat = new OpenLayers.Layer.Yahoo(\\\"Yahoo Satellite\\\",\\n {'type': YAHOO_MAP_SAT, 'sphericalMercator': true});\\n var yahoohyb = new OpenLayers.Layer.Yahoo(\\\"Yahoo Hybrid\\\",\\n {'type': YAHOO_MAP_HYB, 'sphericalMercator': true});\\n\\n // create OSM/OAM layer\\n var osm = new OpenLayers.Layer.TMS( \\\"OpenStreetMap\\\",\\n \\\"http://tile.openstreetmap.org/\\\",\\n { type: 'png', getURL: osm_getTileURL, displayOutsideMaxExtent: true,\\n attribution: '<a href=\\\"http://www.openstreetmap.org/\\\">OpenStreetMap</a>'} );\\n var oam = new OpenLayers.Layer.TMS( \\\"OpenAerialMap\\\",\\n \\\"http://tile.openaerialmap.org/tiles/1.0.0/openaerialmap-900913/\\\",\\n { type: 'png', getURL: osm_getTileURL } );\\n\\n // create TMS Overlay layer\\n var tmsoverlay = new OpenLayers.Layer.TMS( \\\"TMS Overlay\\\", \\\"\\\",\\n { // url: '', serviceVersion: '.', layername: '.',\\n type: '%(tileformat)s', getURL: overlay_getTileURL, alpha: %(has_alpha)s,\\n isBaseLayer: false\\n });\\n if (OpenLayers.Util.alphaHack() == false) { tmsoverlay.setOpacity(0.7); }\\n\\n map.addLayers([gmap, gsat, ghyb, gter, veroad, veaer, vehyb,\\n yahoo, yahoosat, yahoohyb, osm, oam,\\n tmsoverlay]);\\n\\n var switcherControl = new OpenLayers.Control.LayerSwitcher();\\n map.addControl(switcherControl);\\n switcherControl.maximizeControl();\\n\\n map.zoomToExtent( mapBounds.transform(map.displayProjection, map.projection ) );\\n \\\"\\\"\\\" % args\\n\\n elif self.options.profile == 'geodetic':\\n s += \\\"\\\"\\\"\\n var options = {\\n controls: [],\\n projection: new OpenLayers.Projection(\\\"EPSG:4326\\\"),\\n maxResolution: 0.703125,\\n maxExtent: new OpenLayers.Bounds(-180, -90, 180, 90)\\n };\\n map = new OpenLayers.Map('map', options);\\n\\n layer = new OpenLayers.Layer.WMS( \\\"Blue Marble\\\",\\n \\\"http://labs.metacarta.com/wms-c/Basic.py?\\\", {layers: 'satellite' } );\\n map.addLayer(layer);\\n wms = new OpenLayers.Layer.WMS( \\\"VMap0\\\",\\n \\\"http://labs.metacarta.com/wms-c/Basic.py?\\\", {layers: 'basic', format: 'image/png' } );\\n map.addLayer(wms);\\n\\n var tmsoverlay = new OpenLayers.Layer.TMS( \\\"TMS Overlay\\\", \\\"\\\",\\n {\\n serviceVersion: '.', layername: '.', alpha: %(has_alpha)s,\\n type: '%(tileformat)s', getURL: overlay_getTileURL,\\n isBaseLayer: false\\n });\\n map.addLayer(tmsoverlay);\\n if (OpenLayers.Util.alphaHack() == false) { tmsoverlay.setOpacity(0.7); }\\n\\n var switcherControl = new OpenLayers.Control.LayerSwitcher();\\n map.addControl(switcherControl);\\n switcherControl.maximizeControl();\\n\\n map.zoomToExtent( mapBounds );\\n \\\"\\\"\\\" % args\\n\\n elif self.options.profile in ('raster', 'gearth'):\\n s += \\\"\\\"\\\"\\n var options = {\\n controls: [],\\n maxExtent: new OpenLayers.Bounds( %(west)s, %(south)s, %(east)s, %(north)s ),\\n maxResolution: %(rastermaxresolution)f,\\n numZoomLevels: %(rasterzoomlevels)d\\n };\\n map = new OpenLayers.Map('map', options);\\n\\n var layer = new OpenLayers.Layer.TMS( \\\"TMS Layer\\\",\\\"\\\",\\n { url: '', serviceVersion: '.', layername: '.', alpha: %(has_alpha)s,\\n type: '%(tileformat)s', getURL: overlay_getTileURL\\n });\\n map.addLayer(layer);\\n map.zoomToExtent( mapBounds );\\n \\\"\\\"\\\" % args\\n\\n\\n s += \\\"\\\"\\\"\\n map.addControl(new OpenLayers.Control.PanZoomBar());\\n map.addControl(new OpenLayers.Control.MousePosition());\\n map.addControl(new OpenLayers.Control.MouseDefaults());\\n map.addControl(new OpenLayers.Control.KeyboardDefaults());\\n }\\n \\\"\\\"\\\" % args\\n\\n if self.options.profile == 'mercator':\\n s += \\\"\\\"\\\"\\n function osm_getTileURL(bounds) {\\n var res = this.map.getResolution();\\n var x = Math.round((bounds.left - this.maxExtent.left) / (res * this.tileSize.w));\\n var y = Math.round((this.maxExtent.top - bounds.top) / (res * this.tileSize.h));\\n var z = this.map.getZoom();\\n var limit = Math.pow(2, z);\\n\\n if (y < 0 || y >= limit) {\\n return \\\"https://github.com/mj10777/mapmbtiles/img/none.png\\\";\\n } else {\\n x = ((x %% limit) + limit) %% limit;\\n return this.url + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n }\\n }\\n\\n function overlay_getTileURL(bounds) {\\n var res = this.map.getResolution();\\n var x = Math.round((bounds.left - this.maxExtent.left) / (res * this.tileSize.w));\\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\\n var z = this.map.getZoom();\\n if (this.map.baseLayer.name == 'Virtual Earth Roads' || this.map.baseLayer.name == 'Virtual Earth Aerial' || this.map.baseLayer.name == 'Virtual Earth Hybrid') {\\n z = z + 1;\\n }\\n if (mapBounds.intersectsBounds( bounds ) && z >= mapMinZoom && z <= mapMaxZoom ) {\\n //console.log( this.url + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type);\\n return this.url + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n } else {\\n return \\\"https://github.com/mj10777/mapmbtiles/img/none.png\\\";\\n }\\n }\\n \\\"\\\"\\\" % args\\n\\n elif self.options.profile == 'geodetic':\\n s += \\\"\\\"\\\"\\n function overlay_getTileURL(bounds) {\\n bounds = this.adjustBounds(bounds);\\n var res = this.map.getResolution();\\n var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));\\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\\n var z = this.map.getZoom();\\n var path = this.serviceVersion + \\\"/\\\" + this.layername + \\\"/\\\" + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n var url = this.url;\\n if (mapBounds.intersectsBounds( bounds ) && z >= mapMinZoom && z <= mapMaxZoom) {\\n // console.log( this.url + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type);\\n return this.url + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n } else {\\n return \\\"https://github.com/mj10777/mapmbtiles/img/none.png\\\";\\n }\\n }\\n \\\"\\\"\\\" % args\\n\\n elif self.options.profile in ('raster','gearth'):\\n s += \\\"\\\"\\\"\\n function overlay_getTileURL(bounds) {\\n var res = this.map.getResolution();\\n var x = Math.round((bounds.left - this.maxExtent.left) / (res * this.tileSize.w));\\n var y = Math.round((bounds.bottom - this.maxExtent.bottom) / (res * this.tileSize.h));\\n var z = this.map.getZoom();\\n if (x >= 0 && y >= 0) {\\n return this.url + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n } else {\\n return \\\"https://github.com/mj10777/mapmbtiles/img/none.png\\\";\\n }\\n }\\n \\\"\\\"\\\" % args\\n\\n s += \\\"\\\"\\\"\\n function getWindowHeight() {\\n if (self.innerHeight) return self.innerHeight;\\n if (document.documentElement && document.documentElement.clientHeight)\\n return document.documentElement.clientHeight;\\n if (document.body) return document.body.clientHeight;\\n return 0;\\n }\\n\\n function getWindowWidth() {\\n if (self.innerWidth) return self.innerWidth;\\n if (document.documentElement && document.documentElement.clientWidth)\\n return document.documentElement.clientWidth;\\n if (document.body) return document.body.clientWidth;\\n return 0;\\n }\\n\\n function resize() {\\n var map = document.getElementById(\\\"map\\\");\\n var header = document.getElementById(\\\"header\\\");\\n var subheader = document.getElementById(\\\"subheader\\\");\\n map.style.height = (getWindowHeight()-80) + \\\"px\\\";\\n map.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n header.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n subheader.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n if (map.updateSize) { map.updateSize(); };\\n }\\n\\n onresize=function(){ resize(); };\\n\\n </script>\\n </head>\\n <body onload=\\\"init()\\\">\\n <div id=\\\"header\\\"><h1>%(title)s</h1></div>\\n <div id=\\\"subheader\\\">Generated by <a href=\\\"https://github.com/mj10777/mapmbtiles\\\">MapMbTiles</a>/<a href=\\\"http://www.klokan.cz/projects/gdal2mbtiles/\\\">GDAL2MbTiles</a>, Copyright © 2008 <a href=\\\"http://www.klokan.cz/\\\">Klokan Petr Pridal</a>, <a href=\\\"http://www.gdal.org/\\\">GDAL</a> & <a href=\\\"http://www.osgeo.org/\\\">OSGeo</a> <a href=\\\"http://code.google.com/soc/\\\">GSoC</a>\\n <!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->\\n </div>\\n <div id=\\\"map\\\"></div>\\n <script type=\\\"text/javascript\\\" >resize()</script>\\n </body>\\n </html>\\\"\\\"\\\" % args\\n\\n return s\",\n \"def build_maps():\\n return render_template(\\\"maps.html\\\")\",\n \"def home(request):\\n # Get list of sensors and create sensors MVLayer:\\n sensors = get_all_sensors()\\n features = []\\n lat_list = []\\n lng_list = []\\n\\n if sensors is not None:\\n for sensor in sensors:\\n lat_list.append(sensor.latitude)\\n lng_list.append(sensor.longitude)\\n\\n sensor_feature = {\\n 'type': 'Feature',\\n 'geometry': {\\n 'type': 'Point',\\n 'coordinates': [sensor.longitude, sensor.latitude]\\n },\\n 'properties': {\\n 'id': sensor.id,\\n 'latitude': sensor.latitude,\\n 'longitude': sensor.longitude\\n }\\n }\\n features.append(sensor_feature)\\n\\n # Define GeoJSON FeatureCollection\\n sensors_feature_collection = {\\n 'type': 'FeatureCollection',\\n 'crs': {\\n 'type': 'name',\\n 'properties': {\\n 'name': 'EPSG:4326'\\n }\\n },\\n 'features': features\\n }\\n\\n # Create a Map View Layer\\n sensors_layer = MVLayer(\\n source='GeoJSON',\\n options=sensors_feature_collection,\\n legend_title='Sensors',\\n layer_options={\\n 'style': {\\n 'image': {\\n 'circle': {\\n 'radius': 8,\\n 'fill': {'color': '#d84e1f'},\\n 'stroke': {'color': '#ffffff', 'width': 1},\\n }\\n }\\n }\\n },\\n feature_selection=True\\n )\\n\\n\\n # Define view centered on sensor locations\\n try:\\n view_center = [sum(lng_list) / float(len(lng_list)), sum(lat_list) / float(len(lat_list))]\\n except ZeroDivisionError:\\n view_center = [-98.6, 39.8]\\n\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=4.5,\\n maxZoom=18,\\n minZoom=2\\n )\\n\\n sensor_map = MapView(\\n height='100%',\\n width='100%',\\n layers=[sensors_layer],\\n basemap='OpenStreetMap',\\n view=view_options\\n )\\n\\n context = {\\n 'sensor_map': sensor_map,\\n }\\n\\n return render(request, 'open_air/home.html', context)\",\n \"def show_map(self):\\n self.m1.display()\",\n \"def drought_veg_index_map(request):\\n \\n view_center = [-105.2, 39.0]\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=7.0,\\n maxZoom=12,\\n minZoom=5\\n )\\n\\n # TIGER state/county mapserver\\n tiger_boundaries = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\\n legend_title='States & Counties',\\n layer_options={'visible':True,'opacity':0.8},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n\\n # NCDC Climate Divisions\\n climo_divs = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/backgrounds/MapServer',\\n 'params': {'LAYERS': 'show:1'}},\\n legend_title='Climate Divisions',\\n layer_options={'visible':False,'opacity':0.8},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n \\n # USGS Rest server for HUC watersheds \\n watersheds = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\\n legend_title='HUC Watersheds',\\n layer_options={'visible':False,'opacity':0.4},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n ##### WMS Layers - Ryan\\n vdri_legend = MVLegendImageClass(value='VegDRI Cat',\\n image_url='https://vegdri.cr.usgs.gov/wms.php?service=WMS&request=GetLegendGraphic&format=image%2Fpng&width=20&height=20&LAYER=DROUGHT_VDRI_EMODIS_1') \\n vegdri = MVLayer(\\n source='ImageWMS',\\n options={'url': 'https://vegdri.cr.usgs.gov/wms.php?',\\n 'params': {'LAYERS': 'DROUGHT_VDRI_EMODIS_1'},\\n 'serverType': 'geoserver'},\\n layer_options={'visible':True,'opacity':0.5},\\n legend_title='VegDRI',\\n legend_classes=[vdri_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n # historical layers https://edcintl.cr.usgs.gov/geoserver/qdrivegdriemodis/wms?', 'params': {'LAYERS': 'qdrivegdriemodis_pd_1-sevenday-53-2017_mm_data'\\n\\n qdri_legend = MVLegendImageClass(value='QuickDRI Cat',\\n image_url='https://vegdri.cr.usgs.gov/wms.php?service=WMS&request=GetLegendGraphic&format=image%2Fpng&width=20&height=20&LAYER=DROUGHT_QDRI_EMODIS_1') \\n quickdri = MVLayer(\\n source='ImageWMS',\\n options={'url': 'https://vegdri.cr.usgs.gov/wms.php?',\\n 'params': {'LAYERS': 'DROUGHT_QDRI_EMODIS_1'},\\n 'serverType': 'geoserver'},\\n layer_options={'visible':False,'opacity':0.5},\\n legend_title='QuickDRI',\\n legend_classes=[qdri_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n # historical layers: https://edcintl.cr.usgs.gov/geoserver/qdriquickdriraster/wms?', 'params': {'LAYERS': 'qdriquickdriraster_pd_1-sevenday-53-2017_mm_data' \\n \\n # Land Cover REST layer\\n #https://www.mrlc.gov/arcgis/rest/services/LandCover/USGS_EROS_LandCover_NLCD/MapServer\\n NLCD = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://www.mrlc.gov/arcgis/rest/services/LandCover/USGS_EROS_LandCover_NLCD/MapServer',\\n 'params': {'LAYERS': 'show6'}},\\n layer_options={'visible':False,'opacity':0.5},\\n legend_title='NLCD',\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # Define map view options\\n drought_veg_index_map_view_options = MapView(\\n height='100%',\\n width='100%',\\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\\n {'MousePosition': {'projection': 'EPSG:4326'}},\\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-112, 36.3, -98.5, 41.66]}}],\\n layers=[tiger_boundaries,climo_divs,vegdri,quickdri,NLCD,watersheds],\\n view=view_options,\\n basemap='OpenStreetMap',\\n legend=True\\n )\\n\\n context = {\\n 'drought_veg_index_map_view_options':drought_veg_index_map_view_options,\\n }\\n\\n return render(request, 'co_drought/drought_veg_index.html', context)\",\n \"def test_map_settings_custom():\\n m = view(nybb, zoom_control=False, width=200, height=200, tiles=\\\"CartoDB positron\\\")\\n assert m.location == [\\n pytest.approx(40.70582377450201, rel=1e-6),\\n pytest.approx(-73.9778006856748, rel=1e-6),\\n ]\\n assert m.options[\\\"zoom\\\"] == 10\\n assert m.options[\\\"zoomControl\\\"] == False\\n assert m.height == (200.0, \\\"px\\\")\\n assert m.width == (200.0, \\\"px\\\")\\n assert \\\"cartodbpositron\\\" in m.to_dict()[\\\"children\\\"].keys()\\n\\n # custom XYZ tiles\\n m = view(\\n nybb,\\n zoom_control=False,\\n width=200,\\n height=200,\\n tiles=\\\"https://mt1.google.com/vt/lyrs=m&x={x}&y={y}&z={z}\\\",\\n attr=\\\"Google\\\",\\n )\\n\\n out_str = _fetch_map_string(m)\\n assert (\\n 'tileLayer(\\\"https://mt1.google.com/vt/lyrs=m\\\\\\\\u0026x={x}\\\\\\\\u0026y={y}\\\\\\\\u0026z={z}\\\",{\\\"attribution\\\":\\\"Google\\\"'\\n in out_str\\n )\\n\\n m = view(nybb, location=(40, 5))\\n assert m.location == [40, 5]\\n assert m.options[\\\"zoom\\\"] == 10\\n\\n m = view(nybb, zoom_start=8)\\n assert m.location == [\\n pytest.approx(40.70582377450201, rel=1e-6),\\n pytest.approx(-73.9778006856748, rel=1e-6),\\n ]\\n assert m.options[\\\"zoom\\\"] == 8\\n\\n m = view(nybb, location=(40, 5), zoom_start=8)\\n assert m.location == [40, 5]\\n assert m.options[\\\"zoom\\\"] == 8\",\n \"def draw_on(self, folium_map):\",\n \"def on_open_uv_editor():\\n cmds.TextureViewWindow()\",\n \"def home(request):\\n # view_options = MVView(\\n # projection='EPSG:4326',\\n # center=[-70.6,18.75],\\n # zoom=8,\\n # maxZoom=18,\\n # minZoom=2\\n # )\\n #\\n # # Define GeoServer Layer\\n # ozama_layer = MVLayer(source='ImageWMS',\\n # options={'url': 'http://tethys.byu.edu:8181/geoserver/wms',\\n # 'params': {'LAYERS': 'spt-30935191ace55f90bd1e61456f1ef016:dominican_republic-ozama-drainage_line'},\\n # 'serverType': 'geoserver'},\\n # legend_title='Ozama'\\n # )\\n # haina_layer = MVLayer(source='ImageWMS',\\n # options={'url': 'http://tethys.byu.edu:8181/geoserver/wms',\\n # 'params': {\\n # 'LAYERS': 'spt-d7a8ccd9e71e5d7f9e8ecc2985206c8b:dominican_republic-haina-drainage_line'},\\n # 'serverType': 'geoserver'},\\n # legend_title='Haina'\\n # )\\n # dr_layer = MVLayer(source='ImageWMS',\\n # options={'url': 'http://tethys.byu.edu:8181/geoserver/wms',\\n # 'params': {\\n # 'LAYERS': 'catalog:DominicanRepublic'},\\n # 'serverType': 'geoserver'},\\n # legend_title='DR'\\n # )\\n # # Define map view options\\n # map_view_options = MapView(\\n # height='600px',\\n # width='100%',\\n # controls=['ZoomSlider'],\\n # layers=[ozama_layer,haina_layer,dr_layer],\\n # view=view_options,\\n # basemap='Bing'\\n # )\\n\\n context = {}\\n\\n return render(request, 'glass/home.html', context)\",\n \"def map_viewing_client():\\n\\n # Read configuration settings\\n config = gis.get_config()\\n if config.opt_gis_layout == 1:\\n window = True\\n else:\\n window = False\\n\\n # @ToDo Make Configurable\\n toolbar = True\\n\\n map = define_map(window=window, toolbar=toolbar, config=config)\\n\\n response.title = T(\\\"Map Viewing Client\\\")\\n return dict(map=map)\",\n \"def view(self):\",\n \"def ctakeout_viewer():\\r\\n name = request.args[\\\"address\\\"]\\r\\n takeouts = get_zipcode_takeouts(name)\\r\\n\\r\\n if len(takeouts) > 0:\\r\\n takeouts['coordinate'] = 'end_point='+takeouts['name'].astype(str)+'&'+'end_lng=' + takeouts['lon'].astype(str)+'&'+'end_lat='+takeouts['lat'].astype(str)\\r\\n\\r\\n #genetrate folium map\\r\\n takeout_coordinates = takeouts[[\\\"lat\\\", \\\"lon\\\"]].values.tolist()\\r\\n\\r\\n map=make_folium_map(takeout_coordinates)\\r\\n\\r\\n\\r\\n # generate interactive map\\r\\n\\r\\n return render_template(\\r\\n \\\"page3_4t.html\\\",\\r\\n num_takeouts=get_num_takeouts(name),\\r\\n address=name,\\r\\n takeouts=takeouts[[\\\"name\\\", \\\"address\\\", 'coordinate']].values,\\r\\n map=map._repr_html_()\\r\\n )\\r\\n\\r\\n else:\\r\\n lng=get_address(name)[1]\\r\\n lat=get_address(name)[0]\\r\\n near_takeouts = find_5near_takeouts(lng, lat)\\r\\n near_takeouts['coordinate'] = 'end_point='+near_takeouts['name'].astype(str)+'&'+'end_lng=' + near_takeouts['lon'].astype(str)+'&'+'end_lat='+near_takeouts['lat'].astype(str)\\r\\n\\r\\n return render_template(\\r\\n \\\"page3_4t_notakeout.html\\\",\\r\\n address=name,\\r\\n near_takeout_table=near_takeouts[[\\\"name\\\", \\\"address\\\", \\\"coordinate\\\", \\\"distance\\\"]].values)\",\n \"def view(self):\\n raise NotImplementedError\",\n \"def tourmap(request):\\n\\n context = {}\\n\\n return render(request, 'tourMap.html', context=context)\",\n \"def historical(request):\\n mekongBuffer = ee.FeatureCollection('ft:1LEGeqwlBCAlN61ie5ol24NdUDqB1MgpFR_sJNWQJ');\\n mekongRegion = mekongBuffer.geometry();\\n\\n region = ee.Geometry.Rectangle([-180,-90,180,90])\\n\\n algorithm_selection = SelectInput(\\n # display_text='Select Surface Water Algorithm:',\\n name='algorithm_selection',\\n multiple=False,\\n options=[('Surface Water Tool', 'SWT'), ('JRC Tool', 'JRC')],\\n initial=['JRC Tool'],\\n )\\n\\n # Date Picker Options\\n date_picker1 = DatePicker(name='date_picker1',\\n # display_text='Start Date',\\n autoclose=True,\\n format='yyyy-mm-dd',\\n start_date='1/1/1990',\\n start_view='decade',\\n today_button=True,\\n initial='2000-01-01')\\n\\n # Date Picker Options\\n date_picker2 = DatePicker(name='date_picker2',\\n # display_text='End Date',\\n autoclose=True,\\n format='yyyy-mm-dd',\\n start_date='1/1/1990',\\n start_view='decade',\\n today_button=True,\\n initial='2015-12-31')\\n\\n month_slider = RangeSlider(display_text='Month',\\n name='month_slider',\\n min=1,\\n max=12,\\n initial=7,\\n step=1)\\n\\n\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=[101.75, 16.50],\\n zoom=5,\\n maxZoom=18,\\n minZoom=2\\n )\\n\\n water_map = MapView(\\n height='100%',\\n width='100%',\\n controls=['FullScreen',\\n {'MousePosition': {'projection': 'EPSG:4326'}}],\\n basemap='OpenSteetMap',\\n view=view_options\\n )\\n\\n update_button = Button(\\n display_text='Update Map',\\n name='update-button',\\n icon='glyphicon glyphicon-refresh',\\n style='success',\\n attributes={\\n 'title':'Update Map'\\n }\\n )\\n\\n context = {\\n 'update_button': update_button,\\n 'date_picker1': date_picker1,\\n 'date_picker2': date_picker2,\\n 'month_slider': month_slider,\\n 'algorithm_selection': algorithm_selection,\\n 'water_layer': water_layer,\\n 'water_map': water_map,\\n }\\n\\n return render(request, 'hydraviewer/historical.html', context)\",\n \"def __handle_view_tile(self, gamestate_component):\",\n \"def load():\\n\\n # To run this command type: 'python manage.py shell'\\n # 'from map.views import load; load()'\\n\\n mapping = {\\\"productivi\\\": \\\"productivi\\\", \\\"mpoly\\\": \\\"MULTIPOLYGON\\\"}\\n map_path = os.path.abspath('gis_django/fields_test/test_fields.shp')\\n lm = LayerMapping(Map, map_path, mapping, transform=False, encoding=\\\"iso-8859-1\\\")\\n lm.save(verbose=True)\",\n \"def drought_index_map(request):\\n \\n view_center = [-105.2, 39.0]\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=7.0,\\n maxZoom=12,\\n minZoom=5\\n )\\n\\n # TIGER state/county mapserver\\n tiger_boundaries = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\\n legend_title='States & Counties',\\n layer_options={'visible':True,'opacity':0.8},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n\\n # NCDC Climate Divisions\\n climo_divs = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/backgrounds/MapServer',\\n 'params': {'LAYERS': 'show:1'}},\\n legend_title='Climate Divisions',\\n layer_options={'visible':False,'opacity':0.8},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n \\n # USGS Rest server for HUC watersheds \\n watersheds = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\\n legend_title='HUC Watersheds',\\n layer_options={'visible':False,'opacity':0.4},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n ##### WMS Layers - Ryan\\n usdm_legend = MVLegendImageClass(value='Drought Category',\\n image_url='http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?map=/ms4w/apps/usdm/service/usdm_current_wms.map&version=1.3.0&service=WMS&request=GetLegendGraphic&sld_version=1.1.0&layer=usdm_current&format=image/png&STYLE=default')\\n usdm_current = MVLayer(\\n source='ImageWMS',\\n options={'url': 'http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?',\\n 'params': {'LAYERS':'usdm_current','FORMAT':'image/png','VERSION':'1.1.1','STYLES':'default','MAP':'/ms4w/apps/usdm/service/usdm_current_wms.map'}},\\n layer_options={'visible':False,'opacity':0.3},\\n legend_title='USDM',\\n legend_classes=[usdm_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n usdm_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/usdm_current.kml'},\\n layer_options={'visible':True,'opacity':0.5},\\n legend_title='USDM',\\n feature_selection=False,\\n legend_classes=[usdm_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # ESI Data from USDA\\n esi_1 = MVLayer(\\n source='ImageWMS',\\n options={'url': 'https://hrsl.ba.ars.usda.gov/wms.esi.2012?',\\n 'params': {'LAYERS': 'ESI_current_1month', 'VERSION':'1.1.3', 'CRS':'EPSG:4326'}},\\n layer_options={'visible':False,'opacity':0.5},\\n legend_title='ESI - 1 month',\\n legend_extent=[-126, 24.5, -66.2, 49])\\n\\n # Define SWSI KML Layer\\n swsi_legend = MVLegendImageClass(value='',\\n image_url='/static/tethys_gizmos/data/swsi_legend.PNG')\\n SWSI_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/SWSI_2018Current.kml'},\\n legend_title='SWSI',\\n layer_options={'visible':True,'opacity':0.7},\\n feature_selection=True,\\n legend_classes=[swsi_legend],\\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\\n \\n # NCDC/NIDIS precip index\\n ncdc_pindex = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/cdo/indices/MapServer',\\n 'params': {'LAYERS': 'show:1'}},\\n legend_title='Precipitation Index',\\n layer_options={'visible':False,'opacity':0.7},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # NCDC/NIDIS palmer drought severity index\\n # NOTE: MONTH LOOKUP IS HARDCODED RIGHT NOW\\n ncdc_pdsi = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/cdo/indices/MapServer',\\n 'params': {'LAYERS': 'show:2','layerDefs':'{\\\"2\\\":\\\"YEARMONTH='+str(yearnow)+str(prevmonth)+'\\\"}'}},\\n legend_title='PDSI',\\n layer_options={'visible':False,'opacity':0.7},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # NCDC/NIDIS palmer drought severity index\\n # NOTE: MONTH LOOKUP IS HARDCODED RIGHT NOW\\n ncdc_palmz = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/cdo/indices/MapServer',\\n 'params': {'LAYERS': 'show:8','layerDefs':'{\\\"8\\\":\\\"YEARMONTH='+str(yearnow)+str(prevmonth)+'\\\"}'}},\\n legend_title='Palmer Z',\\n layer_options={'visible':False,'opacity':0.7},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # NCDC/NIDIS standardized precip index\\n ncdc_spi_1 = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/cdo/indices/MapServer',\\n 'params': {'LAYERS': 'show:11','layerDefs':'{\\\"11\\\":\\\"YEARMONTH='+str(yearnow)+str(prevmonth)+'\\\"}'}},\\n legend_title='SPI (1-month)',\\n layer_options={'visible':False,'opacity':0.6},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # NCDC/NIDIS standardized precip index\\n ncdc_spi_3 = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/cdo/indices/MapServer',\\n 'params': {'LAYERS': 'show:13','layerDefs':'{\\\"13\\\":\\\"YEARMONTH='+str(yearnow)+str(prevmonth)+'\\\"}'}},\\n legend_title='SPI (3-month)',\\n layer_options={'visible':False,'opacity':0.6},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # NCDC/NIDIS standardized precip index\\n ncdc_spi_6 = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/cdo/indices/MapServer',\\n 'params': {'LAYERS': 'show:14','layerDefs':'{\\\"14\\\":\\\"YEARMONTH='+str(yearnow)+str(prevmonth)+'\\\"}'}},\\n legend_title='SPI (6-month)',\\n layer_options={'visible':False,'opacity':0.6},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n \\n # Define map view options\\n drought_index_map_view_options = MapView(\\n height='100%',\\n width='100%',\\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\\n {'MousePosition': {'projection': 'EPSG:4326'}},\\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-112, 36.3, -98.5, 41.66]}}],\\n layers=[tiger_boundaries,climo_divs,ncdc_pdsi,ncdc_palmz,ncdc_spi_1,ncdc_spi_3,ncdc_spi_6,SWSI_kml,watersheds],\\n view=view_options,\\n basemap='OpenStreetMap',\\n legend=True\\n )\\n\\n context = {\\n 'drought_index_map_view_options':drought_index_map_view_options,\\n }\\n\\n return render(request, 'co_drought/drought_index.html', context)\",\n \"def init_view(self):\\n self.view_map = self.ctx.clientmap\",\n \"def create_osm_tree():\\n osm = etree.Element(\\\"osm\\\", {'version': '0.6', 'generator': 'create-legend'})\\n osm.append(etree.Element(\\\"bounds\\\", {'minlat': '-85', 'maxlat': '85', 'minlon': '-180', 'maxlon': '180'}))\\n return etree.ElementTree(osm)\",\n \"def _set_folium_map(self):\",\n \"def preview_ways(geodataframe):\\n\\n # Map tiles from contextily are provided in the Web Mercator coordinate reference system (EPSG:3857).\\n gdf_wm = geodataframe.to_crs(epsg='3857')\\n # Add a column for the centre of each geometry\\n gdf_wm['centroid'] = gdf_wm.geometry.centroid\\n # Create plot using matplotlib functionality\\n ax = gdf_wm.plot(figsize=(10, 6), color='blue', linewidth=2)\\n gdf_wm.centroid.plot(ax=ax, marker='o', color='red', alpha=0.5, markersize=40)\\n # Add a basemap from contextily. This map should look a lot like Overpass Turbo!\\n ctx.add_basemap(ax, source=ctx.providers.OpenStreetMap.Mapnik)\",\n \"def __handle_view_door(self, gamestate_component):\",\n \"def generate_leaflet(self):\\n\\n args = {}\\n args['title'] = self.options.title.replace('\\\"', '\\\\\\\\\\\"')\\n args['htmltitle'] = self.options.title\\n args['south'], args['west'], args['north'], args['east'] = self.swne\\n args['centerlon'] = (args['north'] + args['south']) / 2.\\n args['centerlat'] = (args['west'] + args['east']) / 2.\\n args['minzoom'] = self.tminz\\n args['maxzoom'] = self.tmaxz\\n args['beginzoom'] = self.tmaxz\\n args['tilesize'] = self.tilesize # not used\\n args['tileformat'] = self.tileext\\n args['publishurl'] = self.options.url # not used\\n args['copyright'] = self.options.copyright.replace('\\\"', '\\\\\\\\\\\"')\\n\\n s = \\\"\\\"\\\"<!DOCTYPE html>\\n <html lang=\\\"en\\\">\\n <head>\\n <meta charset=\\\"utf-8\\\">\\n <meta name='viewport' content='width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no' />\\n <title>%(htmltitle)s</title>\\n\\n <!-- Leaflet -->\\n <link rel=\\\"stylesheet\\\" href=\\\"http://cdn.leafletjs.com/leaflet-0.7.5/leaflet.css\\\" />\\n <script src=\\\"http://cdn.leafletjs.com/leaflet-0.7.5/leaflet.js\\\"></script>\\n\\n <style>\\n body { margin:0; padding:0; }\\n body, table, tr, td, th, div, h1, h2, input { font-family: \\\"Calibri\\\", \\\"Trebuchet MS\\\", \\\"Ubuntu\\\", Serif; font-size: 11pt; }\\n #map { position:absolute; top:0; bottom:0; width:100%%; } /* full size */\\n .ctl {\\n padding: 2px 10px 2px 10px;\\n background: white;\\n background: rgba(255,255,255,0.9);\\n box-shadow: 0 0 15px rgba(0,0,0,0.2);\\n border-radius: 5px;\\n text-align: right;\\n }\\n .title {\\n font-size: 18pt;\\n font-weight: bold;\\n }\\n .src {\\n font-size: 10pt;\\n }\\n\\n </style>\\n\\n </head>\\n <body>\\n\\n <div id=\\\"map\\\"></div>\\n\\n <script>\\n /* **** Leaflet **** */\\n\\n // Base layers\\n // .. OpenStreetMap\\n var osm = L.tileLayer('http://{s}.tile.osm.org/{z}/{x}/{y}.png', {attribution: '© <a href=\\\"http://osm.org/copyright\\\">OpenStreetMap</a> contributors'});\\n\\n // .. CartoDB Positron\\n var cartodb = L.tileLayer('http://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png', {attribution: '© <a href=\\\"http://www.openstreetmap.org/copyright\\\">OpenStreetMap</a> contributors, © <a href=\\\"http://cartodb.com/attributions\\\">CartoDB</a>'});\\n\\n // .. OSM Toner\\n var toner = L.tileLayer('http://{s}.tile.stamen.com/toner/{z}/{x}/{y}.png', {attribution: 'Map tiles by <a href=\\\"http://stamen.com\\\">Stamen Design</a>, under <a href=\\\"http://creativecommons.org/licenses/by/3.0\\\">CC BY 3.0</a>. Data by <a href=\\\"http://openstreetmap.org\\\">OpenStreetMap</a>, under <a href=\\\"http://www.openstreetmap.org/copyright\\\">ODbL</a>.'});\\n\\n // .. White background\\n var white = L.tileLayer(\\\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQAAAAEAAQMAAABmvDolAAAAA1BMVEX///+nxBvIAAAAH0lEQVQYGe3BAQ0AAADCIPunfg43YAAAAAAAAAAA5wIhAAAB9aK9BAAAAABJRU5ErkJggg==\\\");\\n\\n // Overlay layers (TMS)\\n var lyr = L.tileLayer('./{z}/{x}/{y}.%(tileformat)s', {tms: true, opacity: 0.7, attribution: \\\"%(copyright)s\\\"});\\n\\n // Map\\n var map = L.map('map', {\\n center: [%(centerlon)s, %(centerlat)s],\\n zoom: %(beginzoom)s,\\n minZoom: %(minzoom)s,\\n maxZoom: %(maxzoom)s,\\n layers: [osm]\\n });\\n\\n var basemaps = {\\\"OpenStreetMap\\\": osm, \\\"CartoDB Positron\\\": cartodb, \\\"Stamen Toner\\\": toner, \\\"Without background\\\": white}\\n var overlaymaps = {\\\"Layer\\\": lyr}\\n\\n // Title\\n var title = L.control();\\n title.onAdd = function(map) {\\n this._div = L.DomUtil.create('div', 'ctl title');\\n this.update();\\n return this._div;\\n };\\n title.update = function(props) {\\n this._div.innerHTML = \\\"%(title)s\\\";\\n };\\n title.addTo(map);\\n\\n // Note\\n var src = 'Generated by <a href=\\\"http://www.klokan.cz/projects/gdal2tiles/\\\">GDAL2Tiles</a>, Copyright © 2008 <a href=\\\"http://www.klokan.cz/\\\">Klokan Petr Pridal</a>, <a href=\\\"http://www.gdal.org/\\\">GDAL</a> & <a href=\\\"http://www.osgeo.org/\\\">OSGeo</a> <a href=\\\"http://code.google.com/soc/\\\">GSoC</a>';\\n var title = L.control({position: 'bottomleft'});\\n title.onAdd = function(map) {\\n this._div = L.DomUtil.create('div', 'ctl src');\\n this.update();\\n return this._div;\\n };\\n title.update = function(props) {\\n this._div.innerHTML = src;\\n };\\n title.addTo(map);\\n\\n\\n // Add base layers\\n L.control.layers(basemaps, overlaymaps, {collapsed: false}).addTo(map);\\n\\n // Fit to overlay bounds (SW and NE points with (lat, lon))\\n map.fitBounds([[%(south)s, %(east)s], [%(north)s, %(west)s]]);\\n\\n </script>\\n\\n </body>\\n </html>\\n\\n \\\"\\\"\\\" % args # noqa\\n\\n return s\",\n \"def visualize(self):\\n self.octree.updateInnerOccupancy()\\n print(\\\"Start Octomap Visualization\\\")\\n\\n # define parameters\\n data = imgviz.data.arc2017()\\n camera_info = data['camera_info']\\n K = np.array(camera_info['K']).reshape(3, 3)\\n width=camera_info['width']\\n height=camera_info['height']\\n\\n # get free and occupied grid\\n occupied, _ = self.octree.extractPointCloud()\\n #frontier = self.gen_frontier()\\n \\n print(\\\"load point cloud\\\")\\n window = pyglet.window.Window(\\n width=int(1280), height=int(960)\\n )\\n\\n @window.event\\n def on_key_press(symbol, modifiers):\\n if modifiers == 0:\\n if symbol == pyglet.window.key.Q:\\n window.on_close()\\n\\n gui = glooey.Gui(window)\\n hbox = glooey.HBox()\\n hbox.set_padding(5)\\n\\n camera = trimesh.scene.Camera(\\n resolution=(width, height), focal=(K[0, 0], K[1, 1])\\n )\\n\\n # initial camera pose\\n camera_transform = np.array(\\n [\\n [1, 0, 0, 0],\\n [0, -1, 0, 0],\\n [0, 0, -1, -5],\\n [0.0, 0.0, 0.0, 1.0],\\n ],\\n )\\n\\n \\n\\n occupied_geom = trimesh.voxel.ops.multibox(\\n occupied, pitch=self.resolution, colors=[0.0, 0.0, 0.0, 0.5]\\n )\\n\\n # frontier_geom = trimesh.voxel.ops.multibox(\\n # frontier, pitch=self.resolution, colors=[1.0, 0, 0, 0.5]\\n # )\\n scene = trimesh.Scene(camera=camera, geometry=[occupied_geom])#, frontier_geom])\\n scene.camera_transform = camera_transform\\n hbox.add(self.labeled_scene_widget(scene, label='octomap'))\\n\\n\\n gui.add(hbox)\\n pyglet.app.run()\",\n \"def drought_map_outlook(request):\\n \\n view_center = [-105.2, 39.0]\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=7.0,\\n maxZoom=12,\\n minZoom=5\\n )\\n\\n # TIGER state/county mapserver\\n tiger_boundaries = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\\n legend_title='States & Counties',\\n layer_options={'visible':True,'opacity':0.8},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n \\n # USGS Rest server for HUC watersheds \\n watersheds = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\\n legend_title='HUC Watersheds',\\n layer_options={'visible':False,'opacity':0.4},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n ww_legend = MVLegendImageClass(value='Current Streamflow',\\n image_url='https://edcintl.cr.usgs.gov/geoserver/qdriwaterwatchshapefile/ows?service=WMS&request=GetLegendGraphic&format=image%2Fpng&width=20&height=20&layer=water_watch_today') \\n water_watch = MVLayer(\\n source='ImageWMS',\\n options={'url': 'https://edcintl.cr.usgs.gov/geoserver/qdriwaterwatchshapefile/wms?',\\n 'params': {'LAYERS': 'water_watch_today'},\\n 'serverType': 'geoserver'},\\n layer_options={'visible':False,'opacity':0.5},\\n legend_title='USGS Water Watch',\\n legend_classes=[ww_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # NCEP Climate Outlook MapServer\\n ncep_month_outlook = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://idpgis.ncep.noaa.gov/arcgis/rest/services/NWS_Climate_Outlooks/cpc_drought_outlk/MapServer',\\n 'params': {'LAYERS': 'show:0'}},\\n legend_title='NCEP Monthly Drought Outlook',\\n layer_options={'visible':True,'opacity':0.7},\\n legend_classes=[\\n MVLegendClass('polygon', 'Persistence', fill='rgba(155,113,73,0.7)'),\\n MVLegendClass('polygon', 'Improvement', fill='rgba(226,213,192,0.7)'),\\n MVLegendClass('polygon', 'Removal', fill='rgba(178,173,105,0.7)'),\\n MVLegendClass('polygon', 'Development', fill='rgba(255,222,100,0.7)')],\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n ncep_seas_outlook = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://idpgis.ncep.noaa.gov/arcgis/rest/services/NWS_Climate_Outlooks/cpc_drought_outlk/MapServer',\\n 'params': {'LAYERS': 'show:1'}},\\n legend_title='NCEP Seasonal Drought Outlook',\\n layer_options={'visible':False,'opacity':0.7},\\n legend_classes=[\\n MVLegendClass('polygon', 'Persistence', fill='rgba(155,113,73,0.7)'),\\n MVLegendClass('polygon', 'Improvement', fill='rgba(226,213,192,0.7)'),\\n MVLegendClass('polygon', 'Removal', fill='rgba(178,173,105,0.7)'),\\n MVLegendClass('polygon', 'Development', fill='rgba(255,222,100,0.7)')],\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # CPC Wildfire/Drought forecast\\n cpc_37_outlook = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://idpgis.ncep.noaa.gov/arcgis/rest/services/NWS_Climate_Outlooks/cpc_weather_hazards/MapServer',\\n 'params': {'LAYERS': 'show:7'}},\\n legend_title='CPC 3-7 Day WildFire/Drought',\\n layer_options={'visible':False,'opacity':0.7},\\n legend_classes=[\\n MVLegendClass('polygon', 'Wildfire Risk', fill='rgba(130,130,130,0.7)'),\\n MVLegendClass('polygon', 'Severe Drought', fill='rgba(207,181,151,0.7)')],\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n\\n # NOAA WPC QPF forecast\\n WPC_5day_QPF = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://idpgis.ncep.noaa.gov/arcgis/rest/services/NWS_Forecasts_Guidance_Warnings/wpc_qpf/MapServer',\\n 'params': {'LAYERS': 'show:10'}},\\n legend_title='WPC 5-day QPF',\\n layer_options={'visible':True,'opacity':0.3},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n\\n # Define map view options\\n drought_outlook_map_view_options = MapView(\\n height='100%',\\n width='100%',\\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\\n {'MousePosition': {'projection': 'EPSG:4326'}},\\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-112, 36.3, -98.5, 41.66]}}],\\n layers=[tiger_boundaries,water_watch,ncep_month_outlook,ncep_seas_outlook,WPC_5day_QPF,cpc_37_outlook,watersheds],\\n view=view_options,\\n basemap='OpenStreetMap',\\n legend=True\\n )\\n\\n context = {\\n 'drought_outlook_map_view_options':drought_outlook_map_view_options,\\n }\\n\\n return render(request, 'co_drought/drought_outlook.html', context)\",\n \"def map(self, color='#64D1B8', weight=6):\\n centroid = [self.ring.centroid.xy[1][0], self.ring.centroid.xy[0][0]]\\n result_map = folium.Map(location=centroid, tiles='OpenStreetMap')\\n geojson_str = get_geojson_string(self.bbox['geometry'])\\n folium.GeoJson(\\n data=geojson_str,\\n style_function=lambda x: {\\n 'fillOpacity': 0,\\n 'weight': weight,\\n 'color': color\\n }\\n ).add_to(result_map)\\n w,s,e,n = list(self.ring.bounds)\\n result_map.fit_bounds([[s, w], [n, e]])\\n if self.np_array is not None:\\n blist = [[self.np_array_bounds[1], self.np_array_bounds[0]],[self.np_array_bounds[3], self.np_array_bounds[2]]]\\n image_overlay = folium.raster_layers.ImageOverlay(self.np_array, blist)\\n result_map.add_child(image_overlay)\\n return result_map\\n elif not self.tile_url:\\n self.tile_url = self.get_image_url()\\n if self.tile_url:\\n result_map.add_tile_layer(tiles=self.tile_url, attr=f\\\"{self.instrument} image\\\")\\n return result_map\",\n \"def d3_world_map():\\n\\n return render_template(\\\"world.html\\\")\",\n \"def __init__(\\n self,\\n title: str = \\\"OpenStreetMap\\\",\\n zoom_start: float = 2.5,\\n tiles=None,\\n width: str = \\\"100%\\\",\\n height: str = \\\"100%\\\",\\n location: list = None,\\n ):\\n if not location:\\n location = [47.67, -122.13]\\n\\n self.folium_map = folium.Map(\\n zoom_start=zoom_start,\\n tiles=tiles,\\n width=width,\\n height=height,\\n location=location,\\n control_scale=True,\\n )\\n folium.TileLayer(name=title).add_to(self.folium_map)\\n self.locations: List[Tuple[float, float]] = []\",\n \"def drought_map(request):\\n \\n view_center = [-105.2, 39.0]\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=7.0,\\n maxZoom=12,\\n minZoom=5\\n )\\n\\n # TIGER state/county mapserver\\n tiger_boundaries = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\\n legend_title='States & Counties',\\n layer_options={'visible':True,'opacity':0.8},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n \\n ##### WMS Layers - Ryan\\n usdm_legend = MVLegendImageClass(value='Drought Category',\\n image_url='http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?map=/ms4w/apps/usdm/service/usdm_current_wms.map&version=1.3.0&service=WMS&request=GetLegendGraphic&sld_version=1.1.0&layer=usdm_current&format=image/png&STYLE=default')\\n usdm_current = MVLayer(\\n source='ImageWMS',\\n options={'url': 'http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?',\\n 'params': {'LAYERS':'usdm_current','FORMAT':'image/png','VERSION':'1.1.1','STYLES':'default','MAP':'/ms4w/apps/usdm/service/usdm_current_wms.map'}},\\n layer_options={'visible':True,'opacity':0.25},\\n legend_title='USDM',\\n legend_classes=[usdm_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n usdm_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/usdm_current.kml'},\\n layer_options={'visible':True,'opacity':0.5},\\n legend_title='USDM',\\n legend_classes=[usdm_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n ww_legend = MVLegendImageClass(value='Current Streamflow',\\n image_url='https://edcintl.cr.usgs.gov/geoserver/qdriwaterwatchshapefile/ows?service=WMS&request=GetLegendGraphic&format=image%2Fpng&width=20&height=20&layer=water_watch_today') \\n water_watch = MVLayer(\\n source='ImageWMS',\\n options={'url': 'https://edcintl.cr.usgs.gov/geoserver/qdriwaterwatchshapefile/wms?',\\n 'params': {'LAYERS': 'water_watch_today'},\\n 'serverType': 'geoserver'},\\n layer_options={'visible':False,'opacity':0.5},\\n legend_title='USGS Water Watch',\\n legend_classes=[ww_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # USGS Rest server for HUC watersheds \\n watersheds = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\\n legend_title='HUC Watersheds',\\n layer_options={'visible':False,'opacity':0.4},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n\\n # Define SWSI KML Layer\\n swsi_legend = MVLegendImageClass(value='SWSI',\\n image_url='/static/tethys_gizmos/data/swsi_legend.PNG')\\n SWSI_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/SWSI_2018Current.kml'},\\n legend_title='SWSI',\\n layer_options={'visible':False,'opacity':0.7},\\n feature_selection=True,\\n legend_classes=[swsi_legend],\\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\\n \\n # NOAA Rest server for NWM streamflow \\n nwm_stream = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://mapservice.nohrsc.noaa.gov/arcgis/rest/services/national_water_model/NWM_Stream_Analysis/MapServer',\\n 'params': {'LAYERS': 'show:1,2,3,4,5,12'}},\\n legend_title='NWM Streamflow',\\n layer_options={'visible':False,'opacity':1.0},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n nwm_stream_anom = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://mapservice.nohrsc.noaa.gov/arcgis/rest/services/national_water_model/NWM_Stream_Analysis/MapServer',\\n 'params': {'LAYERS': 'show:7,8,9,10,11,12'}},\\n legend_title='NWM Flow Anamaly',\\n layer_options={'visible':False,'opacity':1.0},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # NOAA NOHRSC snow products\\n snodas_swe = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://idpgis.ncep.noaa.gov/arcgis/rest/services/NWS_Observations/NOHRSC_Snow_Analysis/MapServer',\\n 'params': {'LAYERS': 'show:7'}},\\n legend_title='SNODAS Model SWE (in)',\\n layer_options={'visible':False,'opacity':0.7},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n\\n # NOAA Rest server for NWM soil moisture\\n nwm_soil_legend = MVLegendGeoServerImageClass(value='test', style='green', layer='rivers',\\n geoserver_url='https://mapservice.nohrsc.noaa.gov/arcgis/rest/services/national_water_model/NWM_Land_Analysis/MapServer/legend?f=pjson') \\n nwm_soil = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://mapservice.nohrsc.noaa.gov/arcgis/rest/services/national_water_model/NWM_Land_Analysis/MapServer'},\\n legend_title='NWM Soil Moisture',\\n layer_options={'visible':False,'opacity':0.5},\\n legend_classes=[nwm_soil_legend],\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # Define GeoJSON layer\\n with open(como_cocorahs) as f:\\n data = json.load(f)\\n \\n coco_geojson = MVLayer(\\n source='GeoJSON',\\n options=data,\\n legend_title='CoCoRaHS Condition Monitor',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=True,\\n legend_classes=[MVLegendClass('point', 'point', fill='#696969')],\\n layer_options={'style': {'image': {'circle': {'radius': 5,'points':3,'fill': {'color': '#696969'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n #layer_options={'style': 'flickrStyle'})\\n \\n# SWSI_json = MVLayer(\\n# source='GeoJSON',\\n# options={'url': '/static/tethys_gizmos/data/SWSI_2017Dec.geojson', 'featureProjection': 'EPSG:3857'},\\n# legend_title='SWSI',\\n# layer_options={'visible':True,'opacity':0.4},\\n# feature_selection=True,\\n# legend_extent=[-109.5, 36.5, -101.5, 41.6]) \\n \\n # Define map view options\\n drought_map_view_options = MapView(\\n height='100%',\\n width='100%',\\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\\n {'MousePosition': {'projection': 'EPSG:4326'}},\\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-130, 22, -65, 54]}}],\\n layers=[tiger_boundaries,nwm_stream,nwm_stream_anom,nwm_soil,snodas_swe,water_watch,SWSI_kml,coco_geojson,usdm_current,watersheds],\\n view=view_options,\\n basemap='OpenStreetMap',\\n legend=True\\n )\\n\\n context = {\\n 'drought_map_view_options':drought_map_view_options,\\n }\\n\\n return render(request, 'co_drought/drought.html', context)\",\n \"def skinProxyGeo(self):\\n\\n pass\",\n \"def maps(request):\\n #convert image locations to google maps parsable points\\n now = datetime.utcnow().replace(tzinfo=utc)\\n latlngs = search_utils.filter_date(search_utils.min_date, now)\\n points = [search_utils.to_map_point(image) for image in latlngs]\\n #load the search form sidebar\\n t = loader.get_template(\\\"wainz/search_form.html\\\")\\n ctx = Context({})\\n search_form = t.render(ctx)\\n\\n return render_to_response('wainz/maps.html', {\\\"latLngs\\\":points, \\\"search_form\\\":search_form, \\\"typeAheadTags\\\":Tag.objects.all()}, context_instance = RequestContext(request))\",\n \"def setupMap(self) :\\n\\t\\tself.Dmap = OnscreenImage(image = 'models/mapTopView.png', \\\\\\n\\t\\t\\t\\t\\t #pos = (.8,0,.6), scale = .4)\\n\\t\\t\\t\\t\\t pos = (0.8,0,0.6), scale = .4)\\n\\t\\tself.Dmap.setTransparency(TransparencyAttrib.MAlpha)\\n\\t\\tself.dot = OnscreenImage(image = 'models/dot.png', \\\\\\n\\t\\t\\t\\t\\t pos = (1,0,1), scale = .01)\\n\\n\\t\\t# Set the dot's position in the 2d map\\n\\t\\t#self.dot.setPos(0,0,0)\\n#\\t\\t 0.0+self.Dmap.getX(),0, \\\\\\n#\\t\\t 0.0+self.Dmap.getY())\\n\\t#\\t self.avatarNP.getX()/(self.modelSizeX+0.0+self.Dmap.getX()),0, \\\\\\n\\t#\\t self.avatarNP.getY()/(self.modelSizeY+0.0+self.Dmap.getY()))\\n\\t\\tself.dot.setPos( \\\\\\n\\t\\t (self.avatarNP.getX()/(self.modelSizeX))*0.79+0.4, 0, \\\\\\n\\t\\t (self.avatarNP.getY()/(self.modelSizeY))*0.79+0.21)\\n\\t\\tself.dotOrigin = self.dot.getPos()\",\n \"def drought_monitor_map(request):\\n \\n view_center = [-105.2, 39.0]\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=7.0,\\n maxZoom=12,\\n minZoom=5\\n )\\n\\n # TIGER state/county mapserver\\n tiger_boundaries = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\\n legend_title='States & Counties',\\n layer_options={'visible':False,'opacity':0.8},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n \\n ##### WMS Layers - Ryan\\n usdm_legend = MVLegendImageClass(value='Drought Category',\\n image_url='http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?map=/ms4w/apps/usdm/service/usdm_current_wms.map&version=1.3.0&service=WMS&request=GetLegendGraphic&sld_version=1.1.0&layer=usdm_current&format=image/png&STYLE=default')\\n usdm_current = MVLayer(\\n source='ImageWMS',\\n options={'url': 'http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?',\\n 'params': {'LAYERS':'usdm_current','FORMAT':'image/png','VERSION':'1.1.1','STYLES':'default','MAP':'/ms4w/apps/usdm/service/usdm_current_wms.map'}},\\n layer_options={'visible':True,'opacity':0.2},\\n legend_title='USDM',\\n legend_classes=[usdm_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # USGS Rest server for HUC watersheds \\n watersheds = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\\n legend_title='HUC Watersheds',\\n layer_options={'visible':False,'opacity':0.4},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # USDM 8-week Drought category counts by county (D2-D4)\\n usdm_county_wk_legend = MVLegendImageClass(value='',\\n image_url='/static/tethys_gizmos/data/county_drought_8wk.jpg')\\n usdm_D4_8wk_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/D4_8wk_counties.kml'},\\n layer_options={'visible':True,'opacity':0.5},\\n legend_title='USDM D4 Counties',\\n feature_selection=False,\\n legend_classes=[usdm_county_wk_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n usdm_D3_8wk_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/D3_8wk_counties.kml'},\\n layer_options={'visible':False,'opacity':0.5},\\n legend_title='USDM D3+ Counties',\\n feature_selection=False,\\n legend_classes=[usdm_county_wk_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n usdm_D2_8wk_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/D2_8wk_counties.kml'},\\n layer_options={'visible':False,'opacity':0.5},\\n legend_title='USDM D2+ Counties',\\n feature_selection=False,\\n legend_classes=[usdm_county_wk_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # Define GeoJSON layer\\n # Data from CoCoRaHS Condition Monitoring: https://www.cocorahs.org/maps/conditionmonitoring/\\n with open(como_cocorahs) as f:\\n data = json.load(f)\\n \\n # the section below is grouping data by 'scalebar' drought condition\\n # this is a work around for displaying each drought report classification with a unique colored icon\\n data_sd = {}; data_md ={}; data_ml={}\\n data_sd[u'type'] = data['type']; data_md[u'type'] = data['type']; data_ml[u'type'] = data['type']\\n data_sd[u'features'] = [];data_md[u'features'] = [];data_ml[u'features'] = []\\n for element in data['features']:\\n if 'Severely Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_sd[u'features'].append(element)\\n if 'Moderately Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_md[u'features'].append(element)\\n if 'Mildly Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_ml[u'features'].append(element)\\n \\n cocojson_sevdry = MVLayer(\\n source='GeoJSON',\\n options=data_sd,\\n legend_title='CoCoRaHS Condition Monitor',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=True,\\n legend_classes=[MVLegendClass('point', 'Severely Dry', fill='#67000d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#67000d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_moddry = MVLayer(\\n source='GeoJSON',\\n options=data_md,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=True,\\n legend_classes=[MVLegendClass('point', 'Moderately Dry', fill='#a8190d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#a8190d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_mildry = MVLayer(\\n source='GeoJSON',\\n options=data_ml,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=True,\\n legend_classes=[MVLegendClass('point', 'Mildly Dry', fill='#f17d44')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#f17d44'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n \\n # Define map view options\\n drought_monitor_map_view_options = MapView(\\n height='100%',\\n width='100%',\\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\\n {'MousePosition': {'projection': 'EPSG:4326'}},\\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-130, 22, -65, 54]}}],\\n layers=[tiger_boundaries,cocojson_sevdry,cocojson_moddry,cocojson_mildry,usdm_D2_8wk_kml,usdm_D3_8wk_kml,usdm_D4_8wk_kml,usdm_current,watersheds],\\n view=view_options,\\n basemap='OpenStreetMap',\\n legend=True\\n )\\n\\n context = {\\n 'drought_monitor_map_view_options':drought_monitor_map_view_options,\\n }\\n\\n return render(request, 'co_drought/drought_monitor.html', context)\",\n \"def get_view(self, view_width=None, view_height=None, origin=(None, None), center_on_player=False):\\n #Set defaults\\n if view_width is None:\\n view_width = self.width\\n if view_height is None:\\n view_height = self.height\\n o_x, o_y = origin\\n if o_x is None:\\n o_x = 0\\n if o_y is None:\\n o_y = 0\\n\\n #Constrain view to map size\\n view_width = min(view_width, self.width)\\n view_height = min(view_height, self.height)\\n o_x = min(o_x, self.width-1)\\n o_y = min(o_y, self.height-1)\\n\\n #center on player\\n if center_on_player:\\n o_x = min(max(self._player.x - view_width//2, 0), self.width - view_width)\\n o_y = min(max(self._player.y - view_height//2, 0), self.height - view_height)\\n\\n #Flatten map\\n max_x = o_x + view_width\\n max_y = o_y + view_height\\n flattened = [['' for x in range(view_width)] for y in range(view_height)]\\n #Add map feature tiles\\n for y, row in enumerate(self._mapfeatures[o_y:max_y]):\\n for x, cell in enumerate(row[o_x:max_x]):\\n flattened[y][x] = cell.tile if cell is not None else mapfeatures.Void().tile\\n #add entity tiles\\n for entity in self._entities:\\n if o_x <= entity.x < max_x and o_y <= entity.y < max_y:\\n e_x = entity.x - o_x\\n e_y = entity.y - o_y\\n flattened[e_y][e_x] = entity.tile\\n return flattened\",\n \"def station_viewer():\\r\\n name = request.args[\\\"address\\\"]\\r\\n stations = get_zipcode_stations(name)\\r\\n\\r\\n if len(stations) > 0:\\r\\n stations['coordinate'] = 'end_point='+stations['name'].astype(str)+'&'+'end_lng=' + stations['lon'].astype(str)+'&'+'end_lat='+stations['lat'].astype(str)\\r\\n\\r\\n #genetrate folium map\\r\\n station_coordinates = stations[[\\\"lat\\\", \\\"lon\\\"]].values.tolist()\\r\\n\\r\\n map=make_folium_map(station_coordinates)\\r\\n\\r\\n\\r\\n # generate interactive map\\r\\n\\r\\n return render_template(\\r\\n \\\"page3.html\\\",\\r\\n num_stations=get_num_stations(name),\\r\\n address=name,\\r\\n stations=stations[[\\\"name\\\", \\\"address\\\", \\\"available_bikes\\\", 'coordinate']].values,\\r\\n map=map._repr_html_()\\r\\n )\\r\\n\\r\\n else:\\r\\n lng=get_address(name)[1]\\r\\n lat=get_address(name)[0]\\r\\n near_bike = find_5near_stations(lng, lat)\\r\\n near_bike['coordinate'] = 'end_point='+near_bike['name'].astype(str)+'&'+'end_lng=' + near_bike['lon'].astype(str)+'&'+'end_lat='+near_bike['lat'].astype(str)\\r\\n\\r\\n return render_template(\\r\\n \\\"page3_1b_nobike.html\\\",\\r\\n address=name,\\r\\n near_bike_table=near_bike[[\\\"name\\\", \\\"address\\\", \\\"available_bikes\\\", \\\"coordinate\\\", \\\"distance\\\"]].values)\",\n \"def modifiers_coding_map_creator(self):\\n self.mapCreatorWindow = map_creator.ModifiersMapCreatorWindow()\\n self.mapCreatorWindow.move(self.pos())\\n self.mapCreatorWindow.resize(CODING_MAP_RESIZE_W, CODING_MAP_RESIZE_H)\\n self.mapCreatorWindow.show()\",\n \"def as_html(self):\\n if not self._folium_map:\\n self.draw()\\n return self._inline_map(self._folium_map, self._width, self._height)\",\n \"def __init__(self,\\n access_token=None,\\n center=(0, 0),\\n opacity=1,\\n div_id='map',\\n height='500px',\\n style='mapbox://styles/mapbox/light-v9?optimize=true',\\n width='100%',\\n zoom=0,\\n min_zoom=0,\\n max_zoom=24,\\n pitch=0,\\n bearing=0,\\n box_zoom_on=True,\\n double_click_zoom_on=True,\\n scroll_zoom_on=True,\\n touch_zoom_on=True,\\n legend_fill='white',\\n legend_header_fill='white',\\n legend_text_color='#6e6e6e',\\n legend_title_halo_color='white',\\n legend_key_borders_on=True\\n ):\\n if access_token is None:\\n access_token = os.environ.get('MAPBOX_ACCESS_TOKEN', '')\\n if access_token.startswith('sk'):\\n raise TokenError('Mapbox access token must be public (pk), not secret (sk). ' \\\\\\n 'Please sign up at https://www.mapbox.com/signup/ to get a public token. ' \\\\\\n 'If you already have an account, you can retreive your token at https://www.mapbox.com/account/.')\\n self.access_token = access_token\\n self.template = 'map'\\n self.div_id = div_id\\n self.width = width\\n self.height = height\\n self.style = style\\n self.center = center\\n self.zoom = zoom\\n self.opacity = opacity\\n self.label_property = None\\n self.min_zoom = min_zoom\\n self.max_zoom = max_zoom\\n self.pitch = pitch\\n self.bearing = bearing\\n self.box_zoom_on = box_zoom_on\\n self.double_click_zoom_on = double_click_zoom_on\\n self.scroll_zoom_on = scroll_zoom_on\\n self.touch_zoom_on = touch_zoom_on\\n self.legend_fill = legend_fill\\n self.legend_header_fill = legend_header_fill\\n self.legend_text_color = legend_text_color,\\n self.legend_title_halo_color = legend_title_halo_color\\n self.legend_key_borders_on = legend_key_borders_on\\n self.layer_id_counter = 0\\n self.layers = []\",\n \"def view_map_dataverse_org(request):\\n if not request.GET.get('iframe', None):\\n return HttpResponseRedirect('http://dataverse.org')\\n\\n return view_map(request)\",\n \"def show_map(self):\\n print(self.__str__())\",\n \"def drought_fire_map(request):\\n \\n view_center = [-105.2, 39.0]\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=7.0,\\n maxZoom=12,\\n minZoom=5\\n )\\n\\n # TIGER state/county mapserver\\n tiger_boundaries = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\\n legend_title='States & Counties',\\n layer_options={'visible':True,'opacity':0.8},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n \\n # USGS Rest server for HUC watersheds \\n watersheds = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\\n legend_title='HUC Watersheds',\\n layer_options={'visible':False,'opacity':0.4},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n\\n ## Colorado Wildfire Risk Assessment Portal - Fire Intensity Scale\\n # https://www.coloradowildfirerisk.com/map/Public\\n fire_intensity = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://www.coloradowildfirerisk.com/arcgis/rest/services/WUI_fieldwork/FireIntensityScale/MapServer',\\n 'params': {'LAYERS': 'show:0'}},\\n legend_title='Fire Intensity Scale',\\n legend_classes=[\\n MVLegendClass('polygon', 'Lowest Intensity', fill='rgba(199,215,158,0.5)'),\\n MVLegendClass('polygon', '', fill='rgba(255,255,190,0.5)'),\\n MVLegendClass('polygon', 'Moderate Intensity', fill='rgba(255,214,79,0.5)'),\\n MVLegendClass('polygon', '', fill='rgba(255,153,0,0.5)'),\\n MVLegendClass('polygon', 'Highest Intensity', fill='rgba(230,0,0,0.5)')],\\n layer_options={'visible':False,'opacity':0.6},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n fire_occur = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://www.coloradowildfirerisk.com/arcgis/rest/services/WUI_fieldwork/FireOccurrenceAreas/MapServer',\\n 'params': {'LAYERS': 'show:0'}},\\n legend_title='Fire Occurance Areas',\\n legend_classes=[\\n MVLegendClass('polygon', '1 Lowest Occurrence', fill='rgba(204,204,204,0.5)'),\\n MVLegendClass('polygon', '2', fill='rgba(199,215,158,0.5)'),\\n MVLegendClass('polygon', '3', fill='rgba(242,242,183,0.5)'),\\n MVLegendClass('polygon', '4', fill='rgba(255,211,127,0.5)'),\\n MVLegendClass('polygon', '5', fill='rgba(255,170,0,0.5)'),\\n MVLegendClass('polygon', '6', fill='rgba(168,0,0,0.5)'),\\n MVLegendClass('polygon', '7 Highest Intensity', fill='rgba(230,0,0,0.5)')],\\n layer_options={'visible':False,'opacity':0.6},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n ## WFAS - Severe Fire Weather Potential Forecast \\n ## https://m.wfas.net/wfas_sfwp_map.html\\n wfas_legend = MVLegendImageClass(value='SFWF',\\n image_url='https://www.wfas.net/cgi-bin/mapserv?map=/var/www/html/nfdr/mapfiles/ndfd_geog5.map&SERVICE=WMS&VERSION=1.3.0&SLD_VERSION=1.1.0&REQUEST=GetLegendGraphic&FORMAT=image/jpeg&LAYER=fbxday0&STYLE=')\\n wfas_sfw = MVLayer(\\n source='ImageWMS',\\n options={'url': 'https://www.wfas.net/cgi-bin/mapserv?map=/var/www/html/nfdr/mapfiles/wfas_wms_new.map',\\n 'params': {'LAYERS': 'fbxday0'}},\\n layer_options={'visible':True,'opacity':0.7},\\n legend_title='Fire Weather Forecast',\\n legend_classes=[wfas_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n ## NOAA - nowcoast fire weather\\n nws_fire_hazards = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://nowcoast.noaa.gov/arcgis/rest/services/nowcoast/wwa_meteoceanhydro_longduration_hazards_time/MapServer',\\n 'params': {'LAYERS': 'show:38'}},\\n legend_title='NWS Fire Hazards',\\n legend_classes=[\\n MVLegendClass('polygon', 'Red Flag Warning', fill='rgba(255,20,147,0.6)'),\\n MVLegendClass('polygon', 'Fire Weather Watch', fill='rgba(255,222,173,0.6)')],\\n layer_options={'visible':False,'opacity':0.6},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # Define map view options\\n drought_fire_map_view_options = MapView(\\n height='100%',\\n width='100%',\\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\\n {'MousePosition': {'projection': 'EPSG:4326'}},\\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-130, 22, -65, 54]}}],\\n layers=[tiger_boundaries,wfas_sfw,fire_intensity,fire_occur,nws_fire_hazards,watersheds],\\n view=view_options,\\n basemap='OpenStreetMap',\\n legend=True\\n )\\n\\n context = {\\n 'drought_fire_map_view_options':drought_fire_map_view_options,\\n }\\n\\n return render(request, 'co_drought/drought_fire.html', context)\",\n \"def __init__(self, mapfile, camera=None, light=None,\\r\\n width=100.0, depth=100.0, height=10.0,\\r\\n divx=0, divy=0, ntiles=1.0, name=\\\"\\\",\\r\\n x=0.0, y=0.0, z=0.0, rx=0.0, ry=0.0, rz=0.0,\\r\\n sx=1.0, sy=1.0, sz=1.0, cx=0.0, cy=0.0, cz=0.0, smooth=True, cubic=False):\\r\\n super(ElevationMap, self).__init__(camera, light, name, x, y, z, rx, ry, rz,\\r\\n sx, sy, sz, cx, cy, cz)\\r\\n if divx > 200 or divy > 200:\\r\\n print(\\\"... Map size can't be bigger than 200x200 divisions\\\")\\r\\n divx = 200\\r\\n divy = 200\\r\\n if issubclass(type(mapfile), type(\\\"\\\")): #HORRIBLE. Only way to cope with python2v3\\r\\n if mapfile[0] != '/':\\r\\n mapfile = sys.path[0] + '/' + mapfile\\r\\n if VERBOSE:\\r\\n print(\\\"Loading height map ...\\\", mapfile)\\r\\n\\r\\n im = Image.open(mapfile)\\r\\n im = ImageOps.invert(im)\\r\\n else:\\r\\n im = mapfile #allow image files to be passed as mapfile\\r\\n ix, iy = im.size\\r\\n if (ix > 200 and divx == 0) or (divx > 0):\\r\\n if divx == 0:\\r\\n divx = 200\\r\\n divy = 200\\r\\n im = im.resize((divx, divy), Image.ANTIALIAS)\\r\\n ix, iy = im.size\\r\\n if not im.mode == \\\"P\\\":\\r\\n im = im.convert('P', palette=Image.ADAPTIVE)\\r\\n\\r\\n im = im.transpose(Image.FLIP_TOP_BOTTOM)\\r\\n im = im.transpose(Image.FLIP_LEFT_RIGHT)\\r\\n self.pixels = im.load()\\r\\n self.width = width\\r\\n self.depth = depth\\r\\n self.height = height\\r\\n self.ix = ix\\r\\n self.iy = iy\\r\\n self.ttype = GL_TRIANGLE_STRIP\\r\\n\\r\\n if VERBOSE:\\r\\n print(\\\"Creating Elevation Map ...\\\", ix, iy)\\r\\n\\r\\n wh = width * 0.5\\r\\n hh = depth * 0.5\\r\\n ws = width / ix\\r\\n hs = depth / iy\\r\\n ht = height / 255.0\\r\\n tx = 1.0*ntiles / ix\\r\\n ty = 1.0*ntiles / iy\\r\\n\\r\\n verts = []\\r\\n norms = []\\r\\n tex_coords = []\\r\\n idx = []\\r\\n\\r\\n for y in xrange(0, iy):\\r\\n for x in xrange(0, ix):\\r\\n hgt = (self.pixels[x, y])*ht\\r\\n this_x = -wh + x*ws\\r\\n this_z = -hh + y*hs\\r\\n if cubic:\\r\\n \\\"\\\"\\\" this is a bit experimental. It tries to make the map either zero\\r\\n or height high. Vertices are moved 'under' adjacent ones if there is\\r\\n a step to make vertical walls. Goes wrong in places - mainly because\\r\\n it doesn't check diagonals\\r\\n \\\"\\\"\\\"\\r\\n if hgt > height / 2:\\r\\n hgt = height\\r\\n else:\\r\\n hgt = 0.0\\r\\n if hgt == 0 and y > 0 and y < iy-1 and x > 0 and x < ix-1:\\r\\n if self.pixels[x-1, y] > 127:\\r\\n this_x = -wh + (x-1)*ws\\r\\n elif self.pixels[x+1, y] > 127:\\r\\n this_x = -wh + (x+1)*ws\\r\\n elif self.pixels[x, y-1] > 127:\\r\\n this_z = -hh + (y-1)*hs\\r\\n elif self.pixels[x, y+1] > 127:\\r\\n this_z = -hh + (y+1)*hs\\r\\n elif self.pixels[x-1, y-1] > 127:\\r\\n this_x = -wh + (x-1)*ws\\r\\n this_z = -hh + (y-1)*hs\\r\\n elif self.pixels[x-1, y+1] > 127:\\r\\n this_x = -wh + (x-1)*ws\\r\\n this_z = -hh + (y+1)*hs\\r\\n elif self.pixels[x+1, y-1] > 127:\\r\\n this_x = -wh + (x+1)*ws\\r\\n this_z = -hh + (y-1)*hs\\r\\n elif self.pixels[x+1, y+1] > 127:\\r\\n this_x = -wh + (x+1)*ws\\r\\n this_z = -hh + (y+1)*hs\\r\\n verts.append((this_x, hgt, this_z))\\r\\n tex_coords.append(((ix-x) * tx,(iy-y) * ty))\\r\\n\\r\\n s = 0\\r\\n #create one long triangle_strip by alternating X directions\\r\\n for y in range(0, iy-1):\\r\\n for x in range(0, ix-1):\\r\\n i = (y * ix)+x\\r\\n idx.append((i, i+ix, i+ix+1))\\r\\n idx.append((i+ix+1, i+1, i))\\r\\n s += 2\\r\\n\\r\\n self.buf = []\\r\\n self.buf.append(Buffer(self, verts, tex_coords, idx, None, smooth))\",\n \"def drought_vuln_map(request):\\n \\n view_center = [-105.2, 39.0]\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=7.0,\\n maxZoom=12,\\n minZoom=5\\n )\\n\\n # TIGER state/county mapserver\\n tiger_boundaries = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\\n legend_title='States & Counties',\\n layer_options={'visible':True,'opacity':0.2},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n \\n ##### WMS Layers - Ryan\\n usdm_legend = MVLegendImageClass(value='Drought Category',\\n image_url='http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?map=/ms4w/apps/usdm/service/usdm_current_wms.map&version=1.3.0&service=WMS&request=GetLegendGraphic&sld_version=1.1.0&layer=usdm_current&format=image/png&STYLE=default')\\n usdm_current = MVLayer(\\n source='ImageWMS',\\n options={'url': 'http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?',\\n 'params': {'LAYERS':'usdm_current','FORMAT':'image/png','VERSION':'1.1.1','STYLES':'default','MAP':'/ms4w/apps/usdm/service/usdm_current_wms.map'}},\\n layer_options={'visible':False,'opacity':0.25},\\n legend_title='USDM',\\n legend_classes=[usdm_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # USGS Rest server for HUC watersheds \\n watersheds = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\\n legend_title='HUC Watersheds',\\n layer_options={'visible':False,'opacity':0.4},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # Sector drought vulnerability county risk score maps -> from 2018 CO Drought Plan update\\n vuln_legend = MVLegendImageClass(value='Risk Score',\\n image_url='/static/tethys_gizmos/data/ag_vuln_legend.jpg')\\n energy_vuln_legend = MVLegendImageClass(value='Risk Score',\\n image_url='/static/tethys_gizmos/data/energy_vuln_legend.jpg')\\n ag_vuln_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/CO_Ag_vuln_score_2018.kml'},\\n layer_options={'visible':True,'opacity':0.75},\\n legend_title='Ag Risk Score',\\n feature_selection=True,\\n legend_classes=[vuln_legend],\\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\\n energy_vuln_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/CO_Energy_vuln_score_2018.kml'},\\n layer_options={'visible':False,'opacity':0.75},\\n legend_title='Energy Risk Score',\\n feature_selection=False,\\n legend_classes=[energy_vuln_legend],\\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\\n environ_vuln_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/CO_Environ_vuln_score_2018.kml'},\\n layer_options={'visible':False,'opacity':0.75},\\n legend_title='Environ Risk Score',\\n feature_selection=True,\\n legend_classes=[vuln_legend],\\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\\n rec_vuln_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/CO_Rec_vuln_score_2018.kml'},\\n layer_options={'visible':False,'opacity':0.75},\\n legend_title='Recreation Risk Score',\\n feature_selection=True,\\n legend_classes=[vuln_legend],\\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\\n socecon_vuln_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/CO_SocEcon_vuln_score_2018.kml'},\\n layer_options={'visible':False,'opacity':0.75},\\n legend_title='Socioecon Risk Score',\\n feature_selection=True,\\n legend_classes=[vuln_legend],\\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\\n state_vuln_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/CO_StateAssets_vuln_score_2018.kml'},\\n layer_options={'visible':False,'opacity':0.75},\\n legend_title='State Assets Risk Score',\\n feature_selection=True,\\n legend_classes=[vuln_legend],\\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\\n \\n # Define GeoJSON layer\\n # Data from CoCoRaHS Condition Monitoring: https://www.cocorahs.org/maps/conditionmonitoring/\\n with open(como_cocorahs) as f:\\n data = json.load(f)\\n \\n # the section below is grouping data by 'scalebar' drought condition\\n # this is a work around for displaying each drought report classification with a unique colored icon\\n data_sd = {}; data_md ={}; data_ml={}\\n data_sd[u'type'] = data['type']; data_md[u'type'] = data['type']; data_ml[u'type'] = data['type']\\n data_sd[u'features'] = [];data_md[u'features'] = [];data_ml[u'features'] = []\\n for element in data['features']:\\n if 'Severely Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_sd[u'features'].append(element)\\n if 'Moderately Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_md[u'features'].append(element)\\n if 'Mildly Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_ml[u'features'].append(element)\\n \\n cocojson_sevdry = MVLayer(\\n source='GeoJSON',\\n options=data_sd,\\n legend_title='CoCoRaHS Condition Monitor',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Severely Dry', fill='#67000d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#67000d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_moddry = MVLayer(\\n source='GeoJSON',\\n options=data_md,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Moderately Dry', fill='#a8190d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#a8190d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_mildry = MVLayer(\\n source='GeoJSON',\\n options=data_ml,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Mildly Dry', fill='#f17d44')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#f17d44'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n \\n # Define map view options\\n drought_vuln_map_view_options = MapView(\\n height='100%',\\n width='100%',\\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\\n {'MousePosition': {'projection': 'EPSG:4326'}},\\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-130, 22, -65, 54]}}],\\n layers=[tiger_boundaries,cocojson_sevdry,cocojson_moddry,cocojson_mildry,ag_vuln_kml,energy_vuln_kml,environ_vuln_kml,rec_vuln_kml,socecon_vuln_kml,state_vuln_kml,usdm_current,watersheds],\\n view=view_options,\\n basemap='OpenStreetMap',\\n legend=True\\n )\\n\\n context = {\\n 'drought_vuln_map_view_options':drought_vuln_map_view_options,\\n }\\n\\n return render(request, 'co_drought/drought_vuln.html', context)\",\n \"def get_context_data(self,**kwargs):\\n context = super().get_context_data(**kwargs)\\n # reproject map markers\\n for issue in context['object_list']:\\n positionWidget = issue.position\\n positionWidget.transform(settings.EPSG_WIDGET)\\n issue.position_webmap = positionWidget.geojson\\n return context\",\n \"def editor():\\n return render_template('ghostdown.html')\",\n \"def onMapToolActivated(self, e):\\n pass\",\n \"def isometric_view(self):\\n self.view_isometric()\",\n \"def drought_ag_risk_map(request):\\n \\n view_center = [-105.2, 39.0]\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=7.0,\\n maxZoom=12,\\n minZoom=5\\n )\\n\\n # TIGER state/county mapserver\\n tiger_boundaries = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\\n legend_title='States & Counties',\\n layer_options={'visible':True,'opacity':0.2},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n \\n ##### WMS Layers - Ryan\\n usdm_legend = MVLegendImageClass(value='Drought Category',\\n image_url='http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?map=/ms4w/apps/usdm/service/usdm_current_wms.map&version=1.3.0&service=WMS&request=GetLegendGraphic&sld_version=1.1.0&layer=usdm_current&format=image/png&STYLE=default')\\n usdm_current = MVLayer(\\n source='ImageWMS',\\n options={'url': 'http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?',\\n 'params': {'LAYERS':'usdm_current','FORMAT':'image/png','VERSION':'1.1.1','STYLES':'default','MAP':'/ms4w/apps/usdm/service/usdm_current_wms.map'}},\\n layer_options={'visible':False,'opacity':0.25},\\n legend_title='USDM',\\n legend_classes=[usdm_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # USGS Rest server for HUC watersheds \\n watersheds = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\\n legend_title='HUC Watersheds',\\n layer_options={'visible':False,'opacity':0.4},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # Sector drought vulnerability county risk score maps -> from 2018 CO Drought Plan update\\n vuln_legend = MVLegendImageClass(value='Risk Score',\\n image_url='/static/tethys_gizmos/data/ag_vuln_legend.jpg')\\n ag_vuln_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/CO_Ag_vuln_score_2018.kml'},\\n layer_options={'visible':True,'opacity':0.75},\\n legend_title='Ag Risk Score',\\n feature_selection=True,\\n legend_classes=[vuln_legend],\\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\\n \\n # Define GeoJSON layer\\n # Data from CoCoRaHS Condition Monitoring: https://www.cocorahs.org/maps/conditionmonitoring/\\n with open(como_cocorahs) as f:\\n data = json.load(f)\\n \\n # the section below is grouping data by 'scalebar' drought condition\\n # this is a work around for displaying each drought report classification with a unique colored icon\\n data_sd = {}; data_md ={}; data_ml={}\\n data_sd[u'type'] = data['type']; data_md[u'type'] = data['type']; data_ml[u'type'] = data['type']\\n data_sd[u'features'] = [];data_md[u'features'] = [];data_ml[u'features'] = []\\n for element in data['features']:\\n if 'Severely Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_sd[u'features'].append(element)\\n if 'Moderately Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_md[u'features'].append(element)\\n if 'Mildly Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_ml[u'features'].append(element)\\n \\n cocojson_sevdry = MVLayer(\\n source='GeoJSON',\\n options=data_sd,\\n legend_title='CoCoRaHS Condition Monitor',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Severely Dry', fill='#67000d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#67000d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_moddry = MVLayer(\\n source='GeoJSON',\\n options=data_md,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Moderately Dry', fill='#a8190d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#a8190d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_mildry = MVLayer(\\n source='GeoJSON',\\n options=data_ml,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Mildly Dry', fill='#f17d44')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#f17d44'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n \\n # Define map view options\\n drought_ag_risk_map_view_options = MapView(\\n height='100%',\\n width='100%',\\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\\n {'MousePosition': {'projection': 'EPSG:4326'}},\\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-130, 22, -65, 54]}}],\\n layers=[tiger_boundaries,cocojson_sevdry,cocojson_moddry,cocojson_mildry,ag_vuln_kml,usdm_current,watersheds],\\n view=view_options,\\n basemap='OpenStreetMap',\\n legend=True\\n )\\n\\n context = {\\n 'drought_ag_risk_map_view_options':drought_ag_risk_map_view_options,\\n }\\n\\n return render(request, 'co_drought/drought_ag_risk.html', context)\",\n \"def map_page():\\n m = Map() # Create map html\\n return render_template('index.html') # pulls map html using jinja2\",\n \"def drought_eng_risk_map(request):\\n \\n view_center = [-105.2, 39.0]\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=7.0,\\n maxZoom=12,\\n minZoom=5\\n )\\n\\n # TIGER state/county mapserver\\n tiger_boundaries = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\\n legend_title='States & Counties',\\n layer_options={'visible':True,'opacity':0.2},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n \\n ##### WMS Layers - Ryan\\n usdm_legend = MVLegendImageClass(value='Drought Category',\\n image_url='http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?map=/ms4w/apps/usdm/service/usdm_current_wms.map&version=1.3.0&service=WMS&request=GetLegendGraphic&sld_version=1.1.0&layer=usdm_current&format=image/png&STYLE=default')\\n usdm_current = MVLayer(\\n source='ImageWMS',\\n options={'url': 'http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?',\\n 'params': {'LAYERS':'usdm_current','FORMAT':'image/png','VERSION':'1.1.1','STYLES':'default','MAP':'/ms4w/apps/usdm/service/usdm_current_wms.map'}},\\n layer_options={'visible':False,'opacity':0.25},\\n legend_title='USDM',\\n legend_classes=[usdm_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # USGS Rest server for HUC watersheds \\n watersheds = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\\n legend_title='HUC Watersheds',\\n layer_options={'visible':False,'opacity':0.4},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # Sector drought vulnerability county risk score maps -> from 2018 CO Drought Plan update\\n energy_vuln_legend = MVLegendImageClass(value='Risk Score',\\n image_url='/static/tethys_gizmos/data/energy_vuln_legend.jpg')\\n energy_vuln_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/CO_Energy_vuln_score_2018.kml'},\\n layer_options={'visible':True,'opacity':0.75},\\n legend_title='Energy Risk Score',\\n feature_selection=True,\\n legend_classes=[energy_vuln_legend],\\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\\n \\n # Define GeoJSON layer\\n # Data from CoCoRaHS Condition Monitoring: https://www.cocorahs.org/maps/conditionmonitoring/\\n with open(como_cocorahs) as f:\\n data = json.load(f)\\n \\n # the section below is grouping data by 'scalebar' drought condition\\n # this is a work around for displaying each drought report classification with a unique colored icon\\n data_sd = {}; data_md ={}; data_ml={}\\n data_sd[u'type'] = data['type']; data_md[u'type'] = data['type']; data_ml[u'type'] = data['type']\\n data_sd[u'features'] = [];data_md[u'features'] = [];data_ml[u'features'] = []\\n for element in data['features']:\\n if 'Severely Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_sd[u'features'].append(element)\\n if 'Moderately Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_md[u'features'].append(element)\\n if 'Mildly Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_ml[u'features'].append(element)\\n \\n cocojson_sevdry = MVLayer(\\n source='GeoJSON',\\n options=data_sd,\\n legend_title='CoCoRaHS Condition Monitor',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Severely Dry', fill='#67000d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#67000d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_moddry = MVLayer(\\n source='GeoJSON',\\n options=data_md,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Moderately Dry', fill='#a8190d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#a8190d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_mildry = MVLayer(\\n source='GeoJSON',\\n options=data_ml,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Mildly Dry', fill='#f17d44')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#f17d44'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n \\n # Define map view options\\n drought_eng_risk_map_view_options = MapView(\\n height='100%',\\n width='100%',\\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\\n {'MousePosition': {'projection': 'EPSG:4326'}},\\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-130, 22, -65, 54]}}],\\n layers=[tiger_boundaries,cocojson_sevdry,cocojson_moddry,cocojson_mildry,energy_vuln_kml,usdm_current,watersheds],\\n view=view_options,\\n basemap='OpenStreetMap',\\n legend=True\\n )\\n\\n context = {\\n 'drought_eng_risk_map_view_options':drought_eng_risk_map_view_options,\\n }\\n\\n return render(request, 'co_drought/drought_eng_risk.html', context)\",\n \"def drought_prec_map(request):\\n \\n view_center = [-105.2, 39.0]\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=7.0,\\n maxZoom=12,\\n minZoom=5\\n )\\n\\n # TIGER state/county mapserver\\n tiger_boundaries = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\\n legend_title='States & Counties',\\n layer_options={'visible':True,'opacity':0.8},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n \\n # USGS Rest server for HUC watersheds \\n watersheds = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\\n legend_title='HUC Watersheds',\\n layer_options={'visible':False,'opacity':0.4},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # Previous 7-day precip from USGS (not working) \\n prec7_legend = MVLegendImageClass(value='7-day Precip Total',\\n image_url='https://vegdri.cr.usgs.gov/wms.php?service=WMS&request=GetLegendGraphic&format=image%2Fpng&width=20&height=20&LAYER=PRECIP_TP7') \\n precip7day = MVLayer(\\n source='ImageWMS',\\n options={'url': 'https://vegdri.cr.usgs.gov/wms.php?',\\n 'params': {'LAYERS': 'PRECIP_RD7'},\\n 'serverType': 'geoserver'},\\n layer_options={'visible':True,'opacity':0.5},\\n legend_title='Prev 7-day Precip',\\n legend_classes=[prec7_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # NWS Precip analysis data \\n nws_prec7 = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://idpgis.ncep.noaa.gov/arcgis/rest/services/NWS_Forecasts_Guidance_Warnings/rfc_dly_qpe/MapServer',\\n 'params': {'LAYERS': 'show:15'}},\\n legend_title='7-day % of Norm',\\n layer_options={'visible':False,'opacity':0.6},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n ##### USGS WMS Precip Layers\\n precip30_legend = MVLegendImageClass(value='Previous 30-day Precip',\\n image_url='https://vegdri.cr.usgs.gov/wms.php?service=WMS&request=GetLegendGraphic&format=image%2Fpng&width=20&height=20&LAYER=PRECIP_TP30') \\n precip30 = MVLayer(\\n source='ImageWMS',\\n options={'url': 'https://vegdri.cr.usgs.gov/wms.php?',\\n 'params': {'LAYERS': 'PRECIP_TP30'},\\n 'serverType': 'geoserver'},\\n layer_options={'visible':True,'opacity':0.4},\\n legend_title='30-day Total Precip',\\n legend_classes=[precip30_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n\\n # NEXRAD Radar reflectivity \\n nexrad_legend = MVLegendImageClass(value='Base Reflectivity',\\n image_url='https://mesonet.agron.iastate.edu/cgi-bin/wms/nexrad/n0q.cgi?version=1.1.1&service=WMS&request=GetLegendGraphic&layer=nexrad-n0q-900913&format=image/png&STYLE=default') \\n nexrad = MVLayer(\\n source='ImageWMS',\\n options={'url': 'https://mesonet.agron.iastate.edu/cgi-bin/wms/nexrad/n0q.cgi?',\\n 'params': {'LAYERS': 'nexrad-n0q-900913'}},\\n layer_options={'visible':True,'opacity':0.5},\\n legend_title='NEXRAD',\\n legend_classes=[nexrad_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # NOAA NOHRSC snow products\\n snodas_swe = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://idpgis.ncep.noaa.gov/arcgis/rest/services/NWS_Observations/NOHRSC_Snow_Analysis/MapServer',\\n 'params': {'LAYERS': 'show:7'}},\\n legend_title='SNODAS Model SWE',\\n layer_options={'visible':True,'opacity':0.7},\\n legend_classes=[\\n MVLegendClass('polygon', '0.04', fill='rgba(144,175,180,0.7)'),\\n MVLegendClass('polygon', '0.20', fill='rgba(128,165,192,0.7)'),\\n MVLegendClass('polygon', '0.39', fill='rgba(95,126,181,0.7)'),\\n MVLegendClass('polygon', '0.78', fill='rgba(69,73,171,0.7)'),\\n MVLegendClass('polygon', '2.00', fill='rgba(71,46,167,0.7)'),\\n MVLegendClass('polygon', '3.90', fill='rgba(79,20,144,0.7)'),\\n MVLegendClass('polygon', '5.90', fill='rgba(135,33,164,0.7)'),\\n MVLegendClass('polygon', '9.80', fill='rgba(155,53,148,0.7)'),\\n MVLegendClass('polygon', '20', fill='rgba(189,88,154,0.7)'),\\n MVLegendClass('polygon', '30', fill='rgba(189,115,144,0.7)'),\\n MVLegendClass('polygon', '39', fill='rgba(195,142,150,0.7)'),\\n MVLegendClass('polygon', '79', fill='rgba(179,158,153,0.7)')],\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # Coloado CDSS snowpack data (requires token --- expires)\\n snodas_cdss = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://gis.colorado.gov/oit/rest/services/DNR_CWCB/SNODAS/MapServer',\\n 'params': {'LAYERS': 'show:0','TOKEN':'4HhtbZGoUS6eXs7G93BmoyFjDnjQNfNC_pWr3N-FbLI.'}},\\n legend_title='SNODAS Mean',\\n layer_options={'visible':False,'opacity':0.5},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # testing homemand kml image dispaly for SNODAS % daily median SWE (kml not working - kmz contains png with data??) \\n snodas_kml_med = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/20180322_multyear_perc_med.kmz'},\\n layer_options={'visible':False,'opacity':0.5},\\n legend_title='SNODAS SWE % of Median',\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # Define map view options\\n drought_prec_map_view_options = MapView(\\n height='100%',\\n width='100%',\\n controls=['ZoomSlider', 'Rotate', 'FullScreen', 'ScaleLine', 'WMSLegend',\\n {'MousePosition': {'projection': 'EPSG:4326'}},\\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-112, 36.3, -98.5, 41.66]}}],\\n layers=[tiger_boundaries,snodas_swe,precip30,nexrad,watersheds],\\n view=view_options,\\n basemap='OpenStreetMap',\\n legend=True\\n )\\n\\n context = {\\n 'drought_prec_map_view_options':drought_prec_map_view_options,\\n }\\n\\n return render(request, 'co_drought/drought_prec.html', context)\",\n \"def main() -> None:\\n map_ssh = folium.Map(location=[45.523, -122.675], zoom_start=2)\\n\\n with open(\\\"lib/base_data.txt\\\") as tsv:\\n for row in csv.reader(tsv, delimiter=\\\"\\\\t\\\"):\\n name = row[0]\\n try:\\n x = float(row[1])\\n y = float(row[2])\\n folium.Marker([x, y], popup=name).add_to(map_ssh)\\n except ValueError:\\n pass\\n\\n map_ssh.save(\\\"map_ssh.html\\\")\",\n \"def test_map_settings_default():\\n m = view(world)\\n assert m.location == [\\n pytest.approx(-3.1774349999999956, rel=1e-6),\\n pytest.approx(2.842170943040401e-14, rel=1e-6),\\n ]\\n assert m.options[\\\"zoom\\\"] == 10\\n assert m.options[\\\"zoomControl\\\"] == True\\n assert m.position == \\\"relative\\\"\\n assert m.height == (100.0, \\\"%\\\")\\n assert m.width == (100.0, \\\"%\\\")\\n assert m.left == (0, \\\"%\\\")\\n assert m.top == (0, \\\"%\\\")\\n assert m.global_switches.no_touch is False\\n assert m.global_switches.disable_3d is False\\n assert \\\"openstreetmap\\\" in m.to_dict()[\\\"children\\\"].keys()\",\n \"def get_mapdata():\\n return render_template(\\\"l_heatmap.html\\\")\",\n \"def drought_map_nwmforecast(request):\\n \\n view_center = [-105.2, 39.0]\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=7.0,\\n maxZoom=12,\\n minZoom=5\\n )\\n\\n # TIGER state/county mapserver\\n tiger_boundaries = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\\n legend_title='States & Counties',\\n layer_options={'visible':True,'opacity':0.8},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n \\n # USGS Rest server for HUC watersheds \\n watersheds = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\\n legend_title='HUC Watersheds',\\n layer_options={'visible':False,'opacity':0.4},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n\\n # NOAA Rest server for NWM streamflow \\n nwm_stream = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://mapservice.nohrsc.noaa.gov/arcgis/rest/services/national_water_model/NWM_Stream_Analysis/MapServer',\\n 'params': {'LAYERS': 'show:1,2,3,4,5,12'}},\\n legend_title='NWM Streamflow',\\n layer_options={'visible':False,'opacity':1.0},\\n legend_classes=[\\n MVLegendClass('line', '> 1.25M', stroke='rgba(75,0,115,0.9)'),\\n MVLegendClass('line', '500K - 1.25M', stroke='rgba(176,28,232,0.9)'),\\n MVLegendClass('line', '100K - 500K', stroke='rgba(246,82,213,0.9)'),\\n MVLegendClass('line', '50K - 100K', stroke='rgba(254,7,7,0.9)'),\\n MVLegendClass('line', '25K - 50K', stroke='rgba(252,138,23,0.9)'),\\n MVLegendClass('line', '10K - 25K', stroke='rgba(45,108,183,0.9)'),\\n MVLegendClass('line', '5K - 10K', stroke='rgba(27,127,254,0.9)'),\\n MVLegendClass('line', '2.5K - 5K', stroke='rgba(79,169,195,0.9)'),\\n MVLegendClass('line', '250 - 2.5K', stroke='rgba(122,219,250,0.9)'),\\n MVLegendClass('line', '0 - 250', stroke='rgba(206,222,251,0.9)'),\\n MVLegendClass('line', 'No Data', stroke='rgba(195,199,201,0.9)')],\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n nwm_stream_anom = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://mapservice.nohrsc.noaa.gov/arcgis/rest/services/national_water_model/NWM_Stream_Analysis/MapServer',\\n 'params': {'LAYERS': 'show:7,8,9,10,11,12'}},\\n legend_title='NWM Flow Anamaly',\\n layer_options={'visible':True,'opacity':1.0},\\n legend_classes=[\\n MVLegendClass('line', 'High', stroke='rgba(176,28,232,0.9)'),\\n MVLegendClass('line', '', stroke='rgba(61,46,231,0.9)'),\\n MVLegendClass('line', '', stroke='rgba(52,231,181,0.9)'),\\n MVLegendClass('line', 'Moderate', stroke='rgba(102,218,148,0.9)'),\\n MVLegendClass('line', '', stroke='rgba(241,156,77,0.9)'),\\n MVLegendClass('line', '', stroke='rgba(175,62,44,0.9)'),\\n MVLegendClass('line', 'Low', stroke='rgba(241,42,90,0.9)'),\\n MVLegendClass('line', 'No Data', stroke='rgba(195,199,201,0.9)')],\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n\\n # NOAA Rest server for NWM soil moisture\\n nwm_soil_legend = MVLegendGeoServerImageClass(value='test', style='green', layer='NWM_Land_Analysis',\\n geoserver_url='https://mapservice.nohrsc.noaa.gov/arcgis/rest/services/national_water_model/NWM_Land_Analysis/MapServer/legend?f=pjson') \\n nwm_soil = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://mapservice.nohrsc.noaa.gov/arcgis/rest/services/national_water_model/NWM_Land_Analysis/MapServer'},\\n legend_title='NWM Soil Moisture (%)',\\n layer_options={'visible':True,'opacity':0.5},\\n legend_classes=[\\n MVLegendClass('polygon', '0.95 - 1.0', fill='rgba(49,56,148,0.5)'),\\n MVLegendClass('polygon', '0.85 - 0.95', fill='rgba(97,108,181,0.5)'),\\n MVLegendClass('polygon', '0.75 - 0.85', fill='rgba(145,180,216,0.5)'),\\n MVLegendClass('polygon', '0.65 - 0.75', fill='rgba(189,225,225,0.5)'),\\n MVLegendClass('polygon', '0.55 - 0.65', fill='rgba(223,240,209,0.5)'),\\n MVLegendClass('polygon', '0.45 - 0.55', fill='rgba(225,255,191,0.5)'),\\n MVLegendClass('polygon', '0.35 - 0.45', fill='rgba(255,222,150,0.5)'),\\n MVLegendClass('polygon', '0.25 - 0.35', fill='rgba(255,188,112,0.5)'),\\n MVLegendClass('polygon', '0.15 - 0.25', fill='rgba(235,141,81,0.5)'),\\n MVLegendClass('polygon', '0.05 - 0.15', fill='rgba(201,77,58,0.5)'),\\n MVLegendClass('polygon', '0 - 0.05', fill='rgba(166,0,38,0.5)')],\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n\\n # Define map view options\\n drought_nwmfx_map_view_options = MapView(\\n height='100%',\\n width='100%',\\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\\n {'MousePosition': {'projection': 'EPSG:4326'}},\\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-112, 36.3, -98.5, 41.66]}}],\\n layers=[tiger_boundaries,nwm_stream_anom,nwm_stream,nwm_soil,watersheds],\\n view=view_options,\\n basemap='OpenStreetMap',\\n legend=True\\n )\\n \\n toggle_switch = ToggleSwitch(display_text='Defualt Toggle',\\n name='toggle1')\\n\\n context = {\\n 'drought_nwmfx_map_view_options':drought_nwmfx_map_view_options,\\n 'toggle_switch': toggle_switch,\\n }\\n\\n return render(request, 'co_drought/drought_nwmfx.html', context)\",\n \"def __init__(self, mapfile, camera=None, light=None,\\n width=100.0, depth=100.0, height=10.0,\\n divx=0, divy=0, ntiles=1.0, name=\\\"\\\",\\n x=0.0, y=0.0, z=0.0, rx=0.0, ry=0.0, rz=0.0,\\n sx=1.0, sy=1.0, sz=1.0, cx=0.0, cy=0.0, cz=0.0, smooth=True, cubic=False):\\n super(ElevationMap, self).__init__(camera, light, name, x, y, z, rx, ry, rz,\\n sx, sy, sz, cx, cy, cz)\\n if mapfile[0] != '/':\\n mapfile = sys.path[0] + '/' + mapfile\\n if VERBOSE:\\n print(\\\"Loading height map ...\\\", mapfile)\\n\\n if divx > 200 or divy > 200:\\n print(\\\"... Map size can't be bigger than 200x200 divisions\\\")\\n divx = 200\\n divy = 200\\n\\n im = Image.open(mapfile)\\n im = ImageOps.invert(im)\\n ix, iy = im.size\\n if (ix > 200 and divx == 0) or (divx > 0):\\n if divx == 0:\\n divx = 200\\n divy = 200\\n im = im.resize((divx, divy), Image.ANTIALIAS)\\n ix, iy = im.size\\n if not im.mode == \\\"P\\\":\\n im = im.convert('P', palette=Image.ADAPTIVE)\\n\\n im = im.transpose(Image.FLIP_TOP_BOTTOM)\\n im = im.transpose(Image.FLIP_LEFT_RIGHT)\\n self.pixels = im.load()\\n self.width = width\\n self.depth = depth\\n self.height = height\\n self.ix = ix\\n self.iy = iy\\n self.ttype = GL_TRIANGLE_STRIP\\n\\n if VERBOSE:\\n print(\\\"Creating Elevation Map ...\\\", ix, iy)\\n\\n wh = width * 0.5\\n hh = depth * 0.5\\n ws = width / ix\\n hs = depth / iy\\n ht = height / 255.0\\n tx = 1.0*ntiles / ix\\n ty = 1.0*ntiles / iy\\n\\n verts = []\\n norms = []\\n tex_coords = []\\n idx = []\\n\\n for y in xrange(0, iy):\\n for x in xrange(0, ix):\\n hgt = (self.pixels[x, y])*ht\\n this_x = -wh + x*ws\\n this_z = -hh + y*hs\\n if cubic:\\n \\\"\\\"\\\" this is a bit experimental. It tries to make the map either zero\\n or height high. Vertices are moved 'under' adjacent ones if there is\\n a step to make vertical walls. Goes wrong in places - mainly because\\n it doesn't check diagonals\\n \\\"\\\"\\\"\\n if hgt > height / 2:\\n hgt = height\\n else:\\n hgt = 0.0\\n if hgt == 0 and y > 0 and y < iy-1 and x > 0 and x < ix-1:\\n if self.pixels[x-1, y] > 127:\\n this_x = -wh + (x-1)*ws\\n elif self.pixels[x+1, y] > 127:\\n this_x = -wh + (x+1)*ws\\n elif self.pixels[x, y-1] > 127:\\n this_z = -hh + (y-1)*hs\\n elif self.pixels[x, y+1] > 127:\\n this_z = -hh + (y+1)*hs\\n elif self.pixels[x-1, y-1] > 127:\\n this_x = -wh + (x-1)*ws\\n this_z = -hh + (y-1)*hs\\n elif self.pixels[x-1, y+1] > 127:\\n this_x = -wh + (x-1)*ws\\n this_z = -hh + (y+1)*hs\\n elif self.pixels[x+1, y-1] > 127:\\n this_x = -wh + (x+1)*ws\\n this_z = -hh + (y-1)*hs\\n elif self.pixels[x+1, y+1] > 127:\\n this_x = -wh + (x+1)*ws\\n this_z = -hh + (y+1)*hs\\n verts.append((this_x, hgt, this_z))\\n tex_coords.append(((ix-x) * tx,(iy-y) * ty))\\n\\n s = 0\\n #create one long triangle_strip by alternating X directions\\n for y in range(0, iy-1):\\n for x in range(0, ix-1):\\n i = (y * ix)+x\\n idx.append((i, i+ix, i+ix+1))\\n idx.append((i+ix+1, i+1, i))\\n s += 2\\n\\n self.buf = []\\n self.buf.append(Buffer(self, verts, tex_coords, idx, None, smooth))\",\n \"def test_simple_pass():\\n m = view(nybb)\\n m = view(world)\\n m = view(cities)\\n m = view(world.geometry)\",\n \"def __init__(self, frame, mapWindow, Map):\\n self.map = Map\\n self.frame = frame\\n self.mapWindow = mapWindow\\n self.toolbar = None\\n self.layerName = {}\",\n \"def onResize(self, event=None):\\n\\n # get new size of the view\\n (self.view_width, self.view_height) = self.GetClientSizeTuple()\\n\\n # if map > view in X axis\\n if self.map_width > self.view_width:\\n self.max_x_offset = self.map_width - self.view_width\\n # do nothing unless background is showing\\n # if map left edge right of view edge\\n if self.view_offset_x < 0:\\n # move view to hide background at left\\n self.view_offset_x = 0\\n elif self.view_offset_x + self.view_width > self.map_width:\\n # move view to hide background at right\\n self.view_offset_x = self.map_width - self.view_width\\n else:\\n # else view >= map - centre map in X direction\\n self.max_x_offset = self.map_width - self.view_width\\n self.view_offset_x = self.max_x_offset / 2\\n\\n # if map > view in Y axis\\n if self.map_height > self.view_height:\\n self.max_y_offset = self.map_height - self.view_height\\n # do nothing unless background is showing\\n # if map top edge below view edge\\n if self.view_offset_y < 0:\\n # move view to hide background at top\\n self.view_offset_y = 0\\n elif self.view_offset_y + self.view_height > self.map_height:\\n # move view to hide background at bottom\\n self.view_offset_y = self.map_height - self.view_height\\n else:\\n # else view >= map - centre map in Y direction\\n self.max_y_offset = self.map_height - self.view_height\\n self.view_offset_y = self.max_y_offset / 2\\n\\n # set the left/right/top/bottom lon/lat extents\\n self.recalc_view_lonlat_limits()\\n\\n # redraw tiles & layers\\n self.drawTilesLayers(clear=True)\",\n \"def add_osm_element(osm, type, zoom, tags = {}):\\n dlon = 0.006 * (2**13)/(2**zoom) #length\\n dlat = 0.003 * (2**13)/(2**zoom) #height\\n\\n if type == 'point':\\n tags['point'] = 'yes'\\n osm.append(create_osm_node(1, 0, 0, tags))\\n return (-dlon/2, -dlat, dlon/2, dlat)\\n\\n if type == 'line':\\n osm.append(create_osm_node(1, 0, -dlon/2))\\n osm.append(create_osm_node(2, 0, dlon/2))\\n osm.append(create_osm_way(3, (1, 2), tags))\\n return (-dlon/2, -dlat/2*1.5, dlon/2, dlat/2*1.5)\\n\\n if type == 'smallline':\\n osm.append(create_osm_node(1, 0, -dlon/2*0.6))\\n osm.append(create_osm_node(2, 0, dlon/2*.06))\\n osm.append(create_osm_way(3, (1, -2), tags))\\n return (-dlon/2, -dlat/2*1.5, dlon/2, dlat/2*1.5)\\n\\n if type == 'rectangle':\\n osm.append(create_osm_node(1, dlat/2, -dlon/2))\\n osm.append(create_osm_node(2, dlat/2, dlon/2))\\n osm.append(create_osm_node(3, -dlat/2, dlon/2))\\n osm.append(create_osm_node(4, -dlat/2, -dlon/2))\\n tags[\\\"area\\\"] = \\\"yes\\\"\\n osm.append(create_osm_way(5, (1,2,3,4,1), tags))\\n return (-3/4*dlon, -3/4*dlat, 3/4*dlon, 3/4*dlat)\\n\\n if type == 'square':\\n osm.append(create_osm_node(1, dlat/2, -dlat/2))\\n osm.append(create_osm_node(2, dlat/2, dlat/2))\\n osm.append(create_osm_node(3, -dlat/2, dlat/2))\\n osm.append(create_osm_node(4, -dlat/2, -dlat/2))\\n tags[\\\"area\\\"] = \\\"yes\\\"\\n osm.append(create_osm_way(5, (1,2,3,4,1), tags))\\n return (-3/4*dlon, -3/4*dlat, 3/4*dlon, 3/4*dlat)\\n\\n if type == 'rectanglepoint':\\n osm.append(create_osm_node(1, dlat/2, -dlon/2))\\n osm.append(create_osm_node(2, dlat/2, dlon/2))\\n osm.append(create_osm_node(3, -dlat/2, dlon/2))\\n osm.append(create_osm_node(4, -dlat/2, -dlon/2))\\n osm.append(create_osm_node(5, 0, 0, tags))\\n tags['name'] = 'name'\\n tags[\\\"area\\\"] = 'yes'\\n osm.append(create_osm_way(6, (1,2,3,4,1), tags))\\n return (-3/4*dlon, -3/4*dlat, 3/4*dlon, 3/4*dlat)\\n\\n if type == 'squarepoint':\\n osm.append(create_osm_node(1, dlat/2, -dlat/2))\\n osm.append(create_osm_node(2, dlat/2, dlat/2))\\n osm.append(create_osm_node(3, -dlat/2, dlat/2))\\n osm.append(create_osm_node(4, -dlat/2, -dlat/2))\\n osm.append(create_osm_node(5, 0, 0, tags))\\n tags['name'] = 'name'\\n tags[\\\"area\\\"] = 'yes'\\n osm.append(create_osm_way(6, (1,2,3,4,1), tags))\\n return (-3/4*dlon, -3/4*dlat, 3/4*dlon, 3/4*dlat)\\n\\n raise ValueError(\\\"Unknown element type '%s'\\\" % type)\",\n \"def basic_map(proj):\\n fig = plt.figure(figsize=(15, 10))\\n add_metpy_logo(fig, 0, 80, size='large')\\n view = fig.add_axes([0, 0, 1, 1], projection=proj)\\n view.set_extent([-120, -70, 20, 50])\\n view.add_feature(cfeature.STATES.with_scale('50m'))\\n view.add_feature(cfeature.OCEAN)\\n view.add_feature(cfeature.COASTLINE)\\n view.add_feature(cfeature.BORDERS, linestyle=':')\\n return fig, view\",\n \"def overwrite_nglview_default(widget):\\n nglview = import_(\\\"nglview\\\")\\n if not isinstance(widget, nglview.NGLWidget):\\n raise TypeError(\\n \\\"The argument widget can only be of type nglview.NGLWidget not \\\"\\n \\\"{}\\\".format(type(widget))\\n )\\n tooltip_js = \\\"\\\"\\\"\\n this.stage.mouseControls.add('hoverPick', (stage, pickingProxy) => {\\n let tooltip = this.stage.tooltip;\\n if(pickingProxy && pickingProxy.atom && !pickingProxy.bond){\\n let atom = pickingProxy.atom;\\n tooltip.innerText = \\\"ATOM: \\\" + atom.qualifiedName() + \\\", Index: \\\" + atom.index;\\n }\\n });\\n \\\"\\\"\\\"\\n\\n infotext_js = \\\"\\\"\\\"\\n this.stage.signals.clicked.removeAll();\\n this.stage.signals.clicked.add((pickingProxy) => {\\n if(pickingProxy){\\n let pickingText = null;\\n this.model.set('picked', {});\\n this.touch();\\n let currentPick = {};\\n if(pickingProxy.atom){\\n currentPick.atom1 = pickingProxy.atom.toObject();\\n currentPick.atom1.name = pickingProxy.atom.qualifiedName();\\n pickingText = \\\"Atom: \\\" + currentPick.atom1.name + \\\", Index: \\\"\\n + pickingProxy.atom.index;\\n }\\n else if(pickingProxy.bond){\\n currentPick.bond = pickingProxy.bond.toObject();\\n currentPick.atom1 = pickingProxy.bond.atom1.toObject();\\n currentPick.atom1.name = pickingProxy.bond.atom1.qualifiedName();\\n currentPick.atom2 = pickingProxy.bond.atom2.toObject();\\n currentPick.atom2.name = pickingProxy.bond.atom2.qualifiedName();\\n pickingText = \\\"Bond: \\\" + currentPick.atom1.name +\\n `(${pickingProxy.bond.atom1.index})` +\\n \\\" - \\\" + currentPick.atom2.name +\\n `(${pickingProxy.bond.atom2.index})`;\\n }\\n\\n if(pickingProxy.instance){\\n currentPick.instance = pickingProxy.instance;\\n }\\n var nComponents = this.stage.compList.length;\\n for(let i = 0; i < nComponents; i++){\\n let comp = this.stage.compList[i];\\n if(comp.uuid == pickingProxy.component.uuid){\\n currentPick.component = i;\\n }\\n }\\n this.model.set('picked', currentPick);\\n this.touch();\\n this.$pickingInfo.text(pickingText);\\n }\\n });\\n \\\"\\\"\\\"\\n widget._js(tooltip_js)\\n widget._js(infotext_js)\",\n \"def map(request):\\n # Test Comment\\n assert isinstance(request, HttpRequest)\\n return render(\\n request,\\n 'map.html',\\n context_instance=RequestContext(request, {})\\n )\",\n \"def layers(self): # -> LayerView:\\n ...\",\n \"def editor():\\n pass\",\n \"def writeObject(self,view,renderer):\\n\\n if not view.Source:\\n return \\\"\\\"\\n\\n # point light hook\\n proxy = getattr(view.Source,\\\"Proxy\\\",None)\\n if getattr(proxy,\\\"type\\\",None) == \\\"PointLight\\\":\\n return self.writePointLight(view,renderer)\\n\\n # get color and alpha\\n mat = None\\n color = None\\n alpha = None\\n if view.Material:\\n mat = view.Material\\n else:\\n if \\\"Material\\\" in view.Source.PropertiesList:\\n if view.Source.Material:\\n mat = view.Source.Material\\n if mat:\\n if \\\"Material\\\" in mat.PropertiesList:\\n if \\\"DiffuseColor\\\" in mat.Material:\\n color = mat.Material[\\\"DiffuseColor\\\"].strip(\\\"(\\\").strip(\\\")\\\").split(\\\",\\\")[:3]\\n if \\\"Transparency\\\" in mat.Material:\\n if float(mat.Material[\\\"Transparency\\\"]) > 0:\\n alpha = 1.0 - float(mat.Material[\\\"Transparency\\\"])\\n else:\\n alpha = 1.0\\n\\n if view.Source.ViewObject:\\n if not color:\\n if hasattr(view.Source.ViewObject,\\\"ShapeColor\\\"):\\n color = view.Source.ViewObject.ShapeColor[:3]\\n if not alpha:\\n if hasattr(view.Source.ViewObject,\\\"Transparency\\\"):\\n if view.Source.ViewObject.Transparency > 0:\\n alpha = 1.0-(float(view.Source.ViewObject.Transparency)/100.0)\\n if not color:\\n color = (1.0, 1.0, 1.0)\\n if not alpha:\\n alpha = 1.0\\n\\n # get mesh\\n mesh = None\\n if hasattr(view.Source,\\\"Group\\\"):\\n shps = [o.Shape for o in Draft.getGroupContents(view.Source) if hasattr(o,\\\"Shape\\\")]\\n mesh = MeshPart.meshFromShape(Shape=Part.makeCompound(shps),\\n LinearDeflection=0.1,\\n AngularDeflection=0.523599,\\n Relative=False)\\n elif view.Source.isDerivedFrom(\\\"Part::Feature\\\"):\\n mesh = MeshPart.meshFromShape(Shape=view.Source.Shape,\\n LinearDeflection=0.1,\\n AngularDeflection=0.523599,\\n Relative=False)\\n elif view.Source.isDerivedFrom(\\\"Mesh::Feature\\\"):\\n mesh = view.Source.Mesh\\n if not mesh:\\n return \\\"\\\"\\n\\n return renderer.writeObject(view,mesh,color,alpha)\",\n \"def drought_soc_risk_map(request):\\n \\n view_center = [-105.2, 39.0]\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=7.0,\\n maxZoom=12,\\n minZoom=5\\n )\\n\\n # TIGER state/county mapserver\\n tiger_boundaries = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\\n legend_title='States & Counties',\\n layer_options={'visible':True,'opacity':0.2},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n \\n ##### WMS Layers - Ryan\\n usdm_legend = MVLegendImageClass(value='Drought Category',\\n image_url='http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?map=/ms4w/apps/usdm/service/usdm_current_wms.map&version=1.3.0&service=WMS&request=GetLegendGraphic&sld_version=1.1.0&layer=usdm_current&format=image/png&STYLE=default')\\n usdm_current = MVLayer(\\n source='ImageWMS',\\n options={'url': 'http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?',\\n 'params': {'LAYERS':'usdm_current','FORMAT':'image/png','VERSION':'1.1.1','STYLES':'default','MAP':'/ms4w/apps/usdm/service/usdm_current_wms.map'}},\\n layer_options={'visible':False,'opacity':0.25},\\n legend_title='USDM',\\n legend_classes=[usdm_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # USGS Rest server for HUC watersheds \\n watersheds = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\\n legend_title='HUC Watersheds',\\n layer_options={'visible':False,'opacity':0.4},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # Sector drought vulnerability county risk score maps -> from 2018 CO Drought Plan update\\n vuln_legend = MVLegendImageClass(value='Risk Score',\\n image_url='/static/tethys_gizmos/data/ag_vuln_legend.jpg')\\n socecon_vuln_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/CO_SocEcon_vuln_score_2018.kml'},\\n layer_options={'visible':True,'opacity':0.75},\\n legend_title='Socioecon Risk Score',\\n feature_selection=True,\\n legend_classes=[vuln_legend],\\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\\n \\n # Define GeoJSON layer\\n # Data from CoCoRaHS Condition Monitoring: https://www.cocorahs.org/maps/conditionmonitoring/\\n with open(como_cocorahs) as f:\\n data = json.load(f)\\n \\n # the section below is grouping data by 'scalebar' drought condition\\n # this is a work around for displaying each drought report classification with a unique colored icon\\n data_sd = {}; data_md ={}; data_ml={}\\n data_sd[u'type'] = data['type']; data_md[u'type'] = data['type']; data_ml[u'type'] = data['type']\\n data_sd[u'features'] = [];data_md[u'features'] = [];data_ml[u'features'] = []\\n for element in data['features']:\\n if 'Severely Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_sd[u'features'].append(element)\\n if 'Moderately Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_md[u'features'].append(element)\\n if 'Mildly Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_ml[u'features'].append(element)\\n \\n cocojson_sevdry = MVLayer(\\n source='GeoJSON',\\n options=data_sd,\\n legend_title='CoCoRaHS Condition Monitor',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Severely Dry', fill='#67000d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#67000d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_moddry = MVLayer(\\n source='GeoJSON',\\n options=data_md,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Moderately Dry', fill='#a8190d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#a8190d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_mildry = MVLayer(\\n source='GeoJSON',\\n options=data_ml,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Mildly Dry', fill='#f17d44')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#f17d44'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n \\n # Define map view options\\n drought_soc_risk_map_view_options = MapView(\\n height='100%',\\n width='100%',\\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\\n {'MousePosition': {'projection': 'EPSG:4326'}},\\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-130, 22, -65, 54]}}],\\n layers=[tiger_boundaries,cocojson_sevdry,cocojson_moddry,cocojson_mildry,socecon_vuln_kml,usdm_current,watersheds],\\n view=view_options,\\n basemap='OpenStreetMap',\\n legend=True\\n )\\n\\n context = {\\n 'drought_soc_risk_map_view_options':drought_soc_risk_map_view_options,\\n }\\n\\n return render(request, 'co_drought/drought_soc_risk.html', context)\",\n \"def drought_env_risk_map(request):\\n \\n view_center = [-105.2, 39.0]\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=7.0,\\n maxZoom=12,\\n minZoom=5\\n )\\n\\n # TIGER state/county mapserver\\n tiger_boundaries = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\\n legend_title='States & Counties',\\n layer_options={'visible':True,'opacity':0.2},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n \\n ##### WMS Layers - Ryan\\n usdm_legend = MVLegendImageClass(value='Drought Category',\\n image_url='http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?map=/ms4w/apps/usdm/service/usdm_current_wms.map&version=1.3.0&service=WMS&request=GetLegendGraphic&sld_version=1.1.0&layer=usdm_current&format=image/png&STYLE=default')\\n usdm_current = MVLayer(\\n source='ImageWMS',\\n options={'url': 'http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?',\\n 'params': {'LAYERS':'usdm_current','FORMAT':'image/png','VERSION':'1.1.1','STYLES':'default','MAP':'/ms4w/apps/usdm/service/usdm_current_wms.map'}},\\n layer_options={'visible':False,'opacity':0.25},\\n legend_title='USDM',\\n legend_classes=[usdm_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # USGS Rest server for HUC watersheds \\n watersheds = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\\n legend_title='HUC Watersheds',\\n layer_options={'visible':False,'opacity':0.4},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # Sector drought vulnerability county risk score maps -> from 2018 CO Drought Plan update\\n vuln_legend = MVLegendImageClass(value='Risk Score',\\n image_url='/static/tethys_gizmos/data/ag_vuln_legend.jpg')\\n environ_vuln_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/CO_Environ_vuln_score_2018.kml'},\\n layer_options={'visible':True,'opacity':0.75},\\n legend_title='Environ Risk Score',\\n feature_selection=True,\\n legend_classes=[vuln_legend],\\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\\n \\n # Define GeoJSON layer\\n # Data from CoCoRaHS Condition Monitoring: https://www.cocorahs.org/maps/conditionmonitoring/\\n with open(como_cocorahs) as f:\\n data = json.load(f)\\n \\n # the section below is grouping data by 'scalebar' drought condition\\n # this is a work around for displaying each drought report classification with a unique colored icon\\n data_sd = {}; data_md ={}; data_ml={}\\n data_sd[u'type'] = data['type']; data_md[u'type'] = data['type']; data_ml[u'type'] = data['type']\\n data_sd[u'features'] = [];data_md[u'features'] = [];data_ml[u'features'] = []\\n for element in data['features']:\\n if 'Severely Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_sd[u'features'].append(element)\\n if 'Moderately Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_md[u'features'].append(element)\\n if 'Mildly Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_ml[u'features'].append(element)\\n \\n cocojson_sevdry = MVLayer(\\n source='GeoJSON',\\n options=data_sd,\\n legend_title='CoCoRaHS Condition Monitor',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Severely Dry', fill='#67000d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#67000d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_moddry = MVLayer(\\n source='GeoJSON',\\n options=data_md,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Moderately Dry', fill='#a8190d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#a8190d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_mildry = MVLayer(\\n source='GeoJSON',\\n options=data_ml,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Mildly Dry', fill='#f17d44')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#f17d44'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n \\n # Define map view options\\n drought_env_risk_map_view_options = MapView(\\n height='100%',\\n width='100%',\\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\\n {'MousePosition': {'projection': 'EPSG:4326'}},\\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-130, 22, -65, 54]}}],\\n layers=[tiger_boundaries,cocojson_sevdry,cocojson_moddry,cocojson_mildry,environ_vuln_kml,usdm_current,watersheds],\\n view=view_options,\\n basemap='OpenStreetMap',\\n legend=True\\n )\\n\\n context = {\\n 'drought_env_risk_map_view_options':drought_env_risk_map_view_options,\\n }\\n\\n return render(request, 'co_drought/drought_env_risk.html', context)\",\n \"def map(self):\\r\\n pass\",\n \"def __geo_interface__(self):\\n ...\",\n \"def show_map(pdb,show_sticks_all=False, show_sticks_metalbinding=True, show_probes=True, show_pdb_metals=True):\\n view=py3Dmol.view(width=1000, height=800)\\n\\n view.addModel(open(pdb+'.pdb', 'r').read(),'pdb')\\n if show_probes:\\n view.addModel(open(pdb+'_PredictedSites.xyz', 'r').read(),'xyz')\\n probes = open(pdb+'_PredictedSites.xyz', 'r').readlines()\\n if(int(probes[0])!=0):\\n probabilities = [p.replace('#','').split()[-1] for p in probes[2:]] # read p from comment in xyz file\\n colors = {}\\n # use different colors for the probabilities\\n for i,x in enumerate(probabilities):\\n colors[i] = '#%02x%02x%02x' % (0, 128, int(float(x)/float(probabilities[0])*255))\\n else: #no predicted site\\n colors = [] \\n view.addLabel(\\\"No probe predicted\\\", {'position': {'x':0, 'y':0, 'z':0}, 'backgroundColor': '#0080FF', 'fontColor': 'white'});\\n \\n view.zoomTo()\\n view.setBackgroundColor('white')\\n view.setStyle({},{'cartoon': {'color':'gray'}})\\n if show_sticks_all:\\n view.setStyle({}, {'stick':{},'cartoon': {'color':'gray'}})\\n if show_pdb_metals:\\n view.getModel(0).setStyle({'resn':\\\"ZN\\\"},{'sphere': {'opacity':.75}})\\n view.getModel(0).setStyle({'resn':\\\"CA\\\"},{'sphere': {'opacity':.75}})\\n view.getModel(0).setStyle({'resn':\\\"CU\\\"},{'sphere': {'opacity':.75}})\\n view.getModel(0).setStyle({'resn':\\\"HG\\\"},{'sphere': {'opacity':.75}})\\n view.getModel(0).setStyle({'resn':\\\"MG\\\"},{'sphere': {'opacity':.75}})\\n view.getModel(0).setStyle({'resn':\\\"FE\\\"},{'sphere': {'opacity':.75}})\\n view.getModel(0).setStyle({'resn':\\\"MN\\\"},{'sphere': {'opacity':.75}})\\n view.getModel(0).setStyle({'resn':\\\"NI\\\"},{'sphere': {'opacity':.75}})\\n view.getModel(0).setStyle({'resn':\\\"MB\\\"},{'sphere': {'opacity':.75}})\\n \\n if show_probes:\\n view.getModel(1).setStyle({},{'sphere': {'colorscheme':{'prop':'index', 'map':colors}}})\\n \\n # add hoverable labels for the residues and the predicted metals\\n # two callbacks are needed, one for the residues and one for the metals\\n # the metal one displays the probability\\n view.getModel(0).setHoverable({},True,'''function(atom,viewer,event,container) {\\n if(!atom.label) {\\n atom.label = viewer.addLabel(atom.resn+atom.resi+\\\":\\\"+atom.atom,{position: atom, backgroundColor: 'mintcream', fontColor:'black'});\\n }}''',\\n '''function(atom,viewer) { \\n if(atom.label) {\\n viewer.removeLabel(atom.label);\\n delete atom.label;\\n }\\n }''')\\n view.getModel(1).setHoverable({},True,'''function(atom,viewer,event,container) {\\n if(!atom.label) {\\n atom.label = viewer.addLabel(atom.atom+\\\" [\\\"+atom.serial+\\\"]\\\",{position: atom, backgroundColor: 'mintcream', fontColor:'black'});\\n }}''',\\n '''function(atom,viewer) { \\n if(atom.label) {\\n viewer.removeLabel(atom.label);\\n delete atom.label;\\n }\\n }''')\\n if show_sticks_metalbinding:\\n view.setStyle({'resn':\\\"HIS\\\"},{'stick': {}, 'cartoon': {'color':'gray'}})\\n view.setStyle({'resn':\\\"ASP\\\"},{'stick': {}, 'cartoon': {'color':'gray'}})\\n view.setStyle({'resn':\\\"GLU\\\"},{'stick': {}, 'cartoon': {'color':'gray'}})\\n view.setStyle({'resn':\\\"CYS\\\"},{'stick': {}, 'cartoon': {'color':'gray'}})\\n\\n return view.show()\",\n \"def set_view(self, s):\\n #s.scene.reset_zoom()\\n s.scene.z_plus_view()\\n c = s.scene.camera\\n c.azimuth(30)\\n c.elevation(30)\\n s.render()\",\n \"def html_page():\\n return render_template('Map_twitter.html')\",\n \"def export_locations_to_editor():\\n\\n categories = {}\\n\\n # Get all messages\\n\\n msgs = GPS.Message.list()\\n\\n # Filter them and organize them by category and file\\n for m in msgs:\\n if m.get_flags() & 2:\\n file = m.get_file()\\n category = m.get_category()\\n\\n if category in categories:\\n if file in categories[category]:\\n categories[category][file] += [m]\\n else:\\n categories[category][file] = [m]\\n else:\\n categories[category] = {file: [m]}\\n\\n if not categories:\\n GPS.MDI.dialog(\\\"The Locations view is empty.\\\")\\n return\\n\\n # Construct a string that we will write in the editor\\n\\n text = \\\"\\\"\\n\\n categories_list = [c for c in categories]\\n categories_list.sort()\\n\\n for c in categories_list:\\n text += c + \\\"\\\\n\\\"\\n\\n files_list = [f for f in categories[c]]\\n files_list.sort()\\n\\n for f in files_list:\\n text += \\\" %s\\\\n\\\" % f.path\\n messages = categories[c][f]\\n messages.sort(message_compare)\\n\\n for m in messages:\\n text += \\\" %s:%s %s\\\\n\\\" % (\\n m.get_line(),\\n m.get_column(),\\n m.get_text())\\n\\n text += \\\"\\\\n\\\"\\n\\n # Open an editor\\n\\n GPS.execute_action(\\\"new file\\\")\\n buf = GPS.EditorBuffer.get()\\n\\n # Write the contents\\n buf.insert(buf.at(1, 1), text)\",\n \"def __init__(self, lat, lng):\\n self.summary = \\\"Lorem ipsum\\\"\",\n \"def new_map(self):\\n self.wizard = NewMap(self)\",\n \"def view(self, root, title=\\\"No name\\\", radius=moonfieldViewer.R):\\n\\n return moonfieldViewer(root, self, title, radius)\",\n \"def render_model2(request, company, region, cityID, prID, perbox):\\n # This method returns the model which packs into the shipping box.\\n # render with the babylon viewer.\\n context = {\\\"company\\\": company, \\\"region\\\": region, \\\"city\\\": cityID, \\\"product\\\": prID,\\n \\\"target\\\": str(perbox)}\\n # context = {\\\"target_file\\\": unk, \\\"question\\\": Question.objects.all()[0]}\\n # if False:\\n # Http404(\\\"Example that is never triggered.\\\")\\n return HttpResponse(render(request, \\\"babylonview.html\\\", context=context))\",\n \"def set_view(self, s):\\n #s.scene.reset_zoom()\\n s.scene.z_plus_view()\\n c = s.scene.camera\\n c.azimuth(-30)\\n c.elevation(20)\\n s.render()\",\n \"def generate_map(\\n self, console: Console, size: Size, viewport: Region, scroll: Offset\\n ) -> LayoutMap:\",\n \"def storiesOnMap(request):\\n requestDict = request.POST\\n zoom = int(requestDict['zoom'])\\n north = Decimal(requestDict['north'])\\n south = Decimal(requestDict['south'])\\n east = Decimal(requestDict['east'])\\n west = Decimal(requestDict['west'])\\n # The \\\"old\\\" parameter contains a commma-separated list of story ids that are already displayed by the browser\\n currentlyDisplayedStoryIds = requestDict['old'].split(',')\\n\\n storiesToDisplay = models.Story.objects.filter(latitude__range=(south, north)).filter(longitude__range=(west, east)).order_by('-created')\\n\\n # Filter the amount of story markers to display based on the current zoom level\\n if len(storiesToDisplay) >= (zoom-1)*5:\\n storiesToDisplay = storiesToDisplay[(zoom-1)*5:zoom*5]\\n\\n response = []\\n for story in storiesToDisplay:\\n if str(story.id) not in currentlyDisplayedStoryIds:\\n\\n if story.contributor:\\n\\t\\tcontribName = story.contributor.name\\n else: \\n contribName = None\\n langName = story.language.name if story.language else None\\n response.append({'id': story.id,\\n 'title': story.title,\\n 'summary': story.summary,\\n 'link': story.link,\\n 'has_flv':story.has_flv(),\\n 'flv_id':story.flv_id(),\\n 'media_type':story.media_type,\\n 'imageRef': story.contributor.imageRef,\\n 'contributor': contribName,\\n 'language': langName,\\n 'created': story.created.strftime('%d %B %Y'),\\n 'lat': float(story.latitude),\\n 'long': float(story.longitude)})\\n return JsonResponse(response)\",\n \"def __init__(self, georecord, domain, GEOS_point=None, place=None):\\n\\n self.georecord = georecord\\n self.domain = domain\\n\\tself.markers = []\\n\\n if GeoLevel.objects.filter(parent=georecord.level).count() == 0:\\n # display siblings\\n mapped_records = GeoRecord.objects.filter(parent=georecord.parent, geom__isnull=False)\\n center = georecord.geom.centroid\\n has_children = False\\n else:\\n # display children\\n mapped_records = GeoRecord.objects.filter(parent=georecord, geom__isnull=False)\\n center = mapped_records.collect().centroid\\n has_children = True\\n\\n\\n if mapped_records.count() == 0:\\n return blank_map()\\n\\n polylines = None\\n if has_children:\\n # add an outline of the parent geo\\n polylines = [google.Polyline(\\n poly,\\n stroke_color=\\\"#444\\\",\\n stroke_weight=1.5,\\n z_index=2\\n ) for poly in georecord.geom]\\n\\n\\tif GEOS_point:\\n marker=google.Marker(geom=GEOS_point, title=place, clickable='true')\\n self.markers.append(marker)\\n\\n super(GeoSelectMap, self).__init__(\\n center=center,\\n zoom=self._zoom(),\\n markers=self.markers,\\n polygons=self._polygons(mapped_records),\\n polylines=polylines,\\n )\",\n \"def DEADcreate_v_fix_view():\\n sql_view = \\\"\\\"\\\"create or replace view v_fix as\\n SELECT \\n fix.fix_ident, \\n fix.fix_center,\\n ST_Y(ST_Transform(fix.fix_center, 4326)) as fix_lat84,\\n ST_X(ST_Transform(fix.fix_center, 4326)) as fix_lon84\\n \\n FROM \\n fix\\\"\\\"\\\"\\n conf.Cur.execute(sql_view)\\n conf.Con.commit()\",\n \"def drought_rec_risk_map(request):\\n \\n view_center = [-105.2, 39.0]\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=7.0,\\n maxZoom=12,\\n minZoom=5\\n )\\n\\n # TIGER state/county mapserver\\n tiger_boundaries = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\\n legend_title='States & Counties',\\n layer_options={'visible':True,'opacity':0.2},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n \\n ##### WMS Layers - Ryan\\n usdm_legend = MVLegendImageClass(value='Drought Category',\\n image_url='http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?map=/ms4w/apps/usdm/service/usdm_current_wms.map&version=1.3.0&service=WMS&request=GetLegendGraphic&sld_version=1.1.0&layer=usdm_current&format=image/png&STYLE=default')\\n usdm_current = MVLayer(\\n source='ImageWMS',\\n options={'url': 'http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?',\\n 'params': {'LAYERS':'usdm_current','FORMAT':'image/png','VERSION':'1.1.1','STYLES':'default','MAP':'/ms4w/apps/usdm/service/usdm_current_wms.map'}},\\n layer_options={'visible':False,'opacity':0.25},\\n legend_title='USDM',\\n legend_classes=[usdm_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # USGS Rest server for HUC watersheds \\n watersheds = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\\n legend_title='HUC Watersheds',\\n layer_options={'visible':False,'opacity':0.4},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # Sector drought vulnerability county risk score maps -> from 2018 CO Drought Plan update\\n vuln_legend = MVLegendImageClass(value='Risk Score',\\n image_url='/static/tethys_gizmos/data/ag_vuln_legend.jpg')\\n rec_vuln_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/CO_Rec_vuln_score_2018.kml'},\\n layer_options={'visible':True,'opacity':0.75},\\n legend_title='Recreation Risk Score',\\n feature_selection=True,\\n legend_classes=[vuln_legend],\\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\\n \\n # Define GeoJSON layer\\n # Data from CoCoRaHS Condition Monitoring: https://www.cocorahs.org/maps/conditionmonitoring/\\n with open(como_cocorahs) as f:\\n data = json.load(f)\\n \\n # the section below is grouping data by 'scalebar' drought condition\\n # this is a work around for displaying each drought report classification with a unique colored icon\\n data_sd = {}; data_md ={}; data_ml={}\\n data_sd[u'type'] = data['type']; data_md[u'type'] = data['type']; data_ml[u'type'] = data['type']\\n data_sd[u'features'] = [];data_md[u'features'] = [];data_ml[u'features'] = []\\n for element in data['features']:\\n if 'Severely Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_sd[u'features'].append(element)\\n if 'Moderately Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_md[u'features'].append(element)\\n if 'Mildly Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_ml[u'features'].append(element)\\n \\n cocojson_sevdry = MVLayer(\\n source='GeoJSON',\\n options=data_sd,\\n legend_title='CoCoRaHS Condition Monitor',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Severely Dry', fill='#67000d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#67000d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_moddry = MVLayer(\\n source='GeoJSON',\\n options=data_md,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Moderately Dry', fill='#a8190d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#a8190d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_mildry = MVLayer(\\n source='GeoJSON',\\n options=data_ml,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Mildly Dry', fill='#f17d44')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#f17d44'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n \\n # Define map view options\\n drought_rec_risk_map_view_options = MapView(\\n height='100%',\\n width='100%',\\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\\n {'MousePosition': {'projection': 'EPSG:4326'}},\\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-130, 22, -65, 54]}}],\\n layers=[tiger_boundaries,cocojson_sevdry,cocojson_moddry,cocojson_mildry,rec_vuln_kml,usdm_current,watersheds],\\n view=view_options,\\n basemap='OpenStreetMap',\\n legend=True\\n )\\n\\n context = {\\n 'drought_rec_risk_map_view_options':drought_rec_risk_map_view_options,\\n }\\n\\n return render(request, 'co_drought/drought_rec_risk.html', context)\",\n \"def _update_proxy(self, change):\\n # The superclass implementation is sufficient.\\n super(MapView, self)._update_proxy(change)\",\n \"def geofind():\\n return render_template('geo_find.html')\",\n \"def studio_view(self, context):\\n html_str = pkg_resources.resource_string(\\n __name__, \\\"static/html/oppia_edit.html\\\")\\n oppiaid = self.oppiaid or ''\\n frag = Fragment(unicode(html_str).format(\\n oppiaid=oppiaid, src=self.src, width=self.width,\\n height=self.height))\\n\\n js_str = pkg_resources.resource_string(\\n __name__, \\\"static/js/oppia_edit.js\\\")\\n frag.add_javascript(unicode(js_str))\\n frag.initialize_js('OppiaXBlockEditor')\\n\\n return frag\",\n \"def show_to_window(self):\\n if self.normal_mode:\\n self.show_image.show_original_image(\\n self.image, self.width_original_image)\\n self.show_image.show_result_image(\\n self.image, self.width_result_image, self.angle)\\n\\n else:\\n if self.panorama_mode:\\n image = draw_polygon(\\n self.image.copy(),\\n self.mapX_pano,\\n self.mapY_pano)\\n mapX = np.load(\\n './plugins/Thread_inspection/view_image/maps_pano/mapX.npy')\\n mapY = np.load(\\n './plugins/Thread_inspection/view_image/maps_pano/mapY.npy')\\n rho = self.panorama.rho\\n\\n self.result_image = cv2.remap(\\n self.image,\\n mapX,\\n mapY,\\n cv2.INTER_CUBIC)\\n self.result_image = self.result_image[round(\\n rho + round(self.moildev.getRhoFromAlpha(30))):self.h, 0:self.w]\\n # print(self.width_result_image)\\n else:\\n image = draw_polygon(self.image.copy(), self.mapX, self.mapY)\\n self.result_image = cv2.remap(\\n self.image,\\n self.mapX,\\n self.mapY,\\n cv2.INTER_CUBIC)\\n self.show_image.show_original_image(\\n image, self.width_original_image)\\n self.show_image.show_result_image(\\n self.result_image, self.width_result_image, self.angle)\",\n \"def _repr_html_(self):\\n # pylint: disable=protected-access\\n return self.folium_map._repr_html_()\\n # pylint: enable=protected-access\",\n \"def from_map_view(cls, map_view, figures):\\n renderers = [map_view.add_figure(figure) for figure in figures]\\n return cls(renderers)\",\n \"def __init__(self):\\n self.fields = [ \\n \\n# plugins.FieldWidget(\\\"widget\\\", descr=\\\"Start from widget\\\",\\n# default=\\\"/\\\"),\\n# plugins.FieldMarker(\\\"markersearch\\\", descr=\\\"Search for marker\\\"),\\n# plugins.FieldMarker(\\\"markerreplace\\\", descr=\\\"Replace with marker\\\"),\\n plugins.FieldBool(\\\"character\\\", descr=\\\"Plot character of bands\\\")\\n ]\",\n \"def drought_state_risk_map(request):\\n \\n view_center = [-105.2, 39.0]\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=7.0,\\n maxZoom=12,\\n minZoom=5\\n )\\n\\n # TIGER state/county mapserver\\n tiger_boundaries = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\\n legend_title='States & Counties',\\n layer_options={'visible':True,'opacity':0.2},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n \\n ##### WMS Layers - Ryan\\n usdm_legend = MVLegendImageClass(value='Drought Category',\\n image_url='http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?map=/ms4w/apps/usdm/service/usdm_current_wms.map&version=1.3.0&service=WMS&request=GetLegendGraphic&sld_version=1.1.0&layer=usdm_current&format=image/png&STYLE=default')\\n usdm_current = MVLayer(\\n source='ImageWMS',\\n options={'url': 'http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?',\\n 'params': {'LAYERS':'usdm_current','FORMAT':'image/png','VERSION':'1.1.1','STYLES':'default','MAP':'/ms4w/apps/usdm/service/usdm_current_wms.map'}},\\n layer_options={'visible':False,'opacity':0.25},\\n legend_title='USDM',\\n legend_classes=[usdm_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # USGS Rest server for HUC watersheds \\n watersheds = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\\n legend_title='HUC Watersheds',\\n layer_options={'visible':False,'opacity':0.4},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # Sector drought vulnerability county risk score maps -> from 2018 CO Drought Plan update\\n vuln_legend = MVLegendImageClass(value='Risk Score',\\n image_url='/static/tethys_gizmos/data/ag_vuln_legend.jpg')\\n state_vuln_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/CO_StateAssets_vuln_score_2018.kml'},\\n layer_options={'visible':True,'opacity':0.75},\\n legend_title='State Assets Risk Score',\\n feature_selection=True,\\n legend_classes=[vuln_legend],\\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\\n \\n # Define GeoJSON layer\\n # Data from CoCoRaHS Condition Monitoring: https://www.cocorahs.org/maps/conditionmonitoring/\\n with open(como_cocorahs) as f:\\n data = json.load(f)\\n \\n # the section below is grouping data by 'scalebar' drought condition\\n # this is a work around for displaying each drought report classification with a unique colored icon\\n data_sd = {}; data_md ={}; data_ml={}\\n data_sd[u'type'] = data['type']; data_md[u'type'] = data['type']; data_ml[u'type'] = data['type']\\n data_sd[u'features'] = [];data_md[u'features'] = [];data_ml[u'features'] = []\\n for element in data['features']:\\n if 'Severely Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_sd[u'features'].append(element)\\n if 'Moderately Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_md[u'features'].append(element)\\n if 'Mildly Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_ml[u'features'].append(element)\\n \\n cocojson_sevdry = MVLayer(\\n source='GeoJSON',\\n options=data_sd,\\n legend_title='CoCoRaHS Condition Monitor',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Severely Dry', fill='#67000d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#67000d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_moddry = MVLayer(\\n source='GeoJSON',\\n options=data_md,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Moderately Dry', fill='#a8190d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#a8190d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_mildry = MVLayer(\\n source='GeoJSON',\\n options=data_ml,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Mildly Dry', fill='#f17d44')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#f17d44'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n \\n # Define map view options\\n drought_state_risk_map_view_options = MapView(\\n height='100%',\\n width='100%',\\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\\n {'MousePosition': {'projection': 'EPSG:4326'}},\\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-130, 22, -65, 54]}}],\\n layers=[tiger_boundaries,cocojson_sevdry,cocojson_moddry,cocojson_mildry,state_vuln_kml,usdm_current,watersheds],\\n view=view_options,\\n basemap='OpenStreetMap',\\n legend=True\\n )\\n\\n context = {\\n 'drought_state_risk_map_view_options':drought_state_risk_map_view_options,\\n }\\n\\n return render(request, 'co_drought/drought_state_risk.html', context)\",\n \"def get(self, request):\\n context = self.getContext(GeoPostForm())\\n return render(request, 'geopost/entry.html', context)\",\n \"def __init__(self):\\n self.fields = [ \\n \\n #plugins.FieldWidget(\\\"widget\\\", descr=\\\"Start from widget\\\",\\n # default=\\\"/\\\"),\\n #plugins.FieldMarker(\\\"markersearch\\\", descr=\\\"Search for marker\\\"),\\n #plugins.FieldMarker(\\\"markerreplace\\\", descr=\\\"Replace with marker\\\"),\\n #plugins.FieldBool(\\\"character\\\", descr=\\\"Plot character of bands\\\")\\n ]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5956941","0.5876095","0.5870691","0.5804954","0.57842386","0.57654804","0.5738355","0.5679043","0.5668454","0.5618465","0.55423635","0.55370593","0.547862","0.54725426","0.54639965","0.54085356","0.54077595","0.5403992","0.5376458","0.5351264","0.5340279","0.5336544","0.5319627","0.5277651","0.5273797","0.5271965","0.5268214","0.5245012","0.5229783","0.5216632","0.52153474","0.5210137","0.51990026","0.51809514","0.5172675","0.51705664","0.51557934","0.51533","0.5150767","0.5147034","0.51439345","0.5142024","0.5136488","0.51266474","0.51208633","0.51180464","0.5111861","0.5109419","0.5107739","0.51068616","0.5084778","0.5076061","0.5070167","0.50644004","0.5063058","0.50615644","0.5059889","0.50594777","0.50555265","0.5046332","0.50458515","0.50424385","0.5040661","0.5035942","0.5028397","0.50125647","0.5008609","0.49916363","0.49838644","0.49836564","0.4982036","0.49808922","0.4973538","0.49722832","0.4970931","0.4953957","0.49535084","0.4950183","0.4942642","0.49412814","0.4937738","0.49355134","0.49249205","0.49138886","0.49113947","0.4908155","0.4904095","0.48925462","0.48848805","0.4881571","0.48778856","0.4858511","0.48575133","0.48557907","0.48523438","0.48490387","0.484815","0.48457557","0.48420948","0.4842045"],"string":"[\n \"0.5956941\",\n \"0.5876095\",\n \"0.5870691\",\n \"0.5804954\",\n \"0.57842386\",\n \"0.57654804\",\n \"0.5738355\",\n \"0.5679043\",\n \"0.5668454\",\n \"0.5618465\",\n \"0.55423635\",\n \"0.55370593\",\n \"0.547862\",\n \"0.54725426\",\n \"0.54639965\",\n \"0.54085356\",\n \"0.54077595\",\n \"0.5403992\",\n \"0.5376458\",\n \"0.5351264\",\n \"0.5340279\",\n \"0.5336544\",\n \"0.5319627\",\n \"0.5277651\",\n \"0.5273797\",\n \"0.5271965\",\n \"0.5268214\",\n \"0.5245012\",\n \"0.5229783\",\n \"0.5216632\",\n \"0.52153474\",\n \"0.5210137\",\n \"0.51990026\",\n \"0.51809514\",\n \"0.5172675\",\n \"0.51705664\",\n \"0.51557934\",\n \"0.51533\",\n \"0.5150767\",\n \"0.5147034\",\n \"0.51439345\",\n \"0.5142024\",\n \"0.5136488\",\n \"0.51266474\",\n \"0.51208633\",\n \"0.51180464\",\n \"0.5111861\",\n \"0.5109419\",\n \"0.5107739\",\n \"0.51068616\",\n \"0.5084778\",\n \"0.5076061\",\n \"0.5070167\",\n \"0.50644004\",\n \"0.5063058\",\n \"0.50615644\",\n \"0.5059889\",\n \"0.50594777\",\n \"0.50555265\",\n \"0.5046332\",\n \"0.50458515\",\n \"0.50424385\",\n \"0.5040661\",\n \"0.5035942\",\n \"0.5028397\",\n \"0.50125647\",\n \"0.5008609\",\n \"0.49916363\",\n \"0.49838644\",\n \"0.49836564\",\n \"0.4982036\",\n \"0.49808922\",\n \"0.4973538\",\n \"0.49722832\",\n \"0.4970931\",\n \"0.4953957\",\n \"0.49535084\",\n \"0.4950183\",\n \"0.4942642\",\n \"0.49412814\",\n \"0.4937738\",\n \"0.49355134\",\n \"0.49249205\",\n \"0.49138886\",\n \"0.49113947\",\n \"0.4908155\",\n \"0.4904095\",\n \"0.48925462\",\n \"0.48848805\",\n \"0.4881571\",\n \"0.48778856\",\n \"0.4858511\",\n \"0.48575133\",\n \"0.48557907\",\n \"0.48523438\",\n \"0.48490387\",\n \"0.484815\",\n \"0.48457557\",\n \"0.48420948\",\n \"0.4842045\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6068055"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":79078,"cells":{"query":{"kind":"string","value":"Test new OpenLayers functionality in a RAD environment currently being used to trial using GeoJSON for internal feature layers"},"document":{"kind":"string","value":"def test2():\n\n # Internal Feature Layers\n feature_queries = []\n feature_layers = db(db.gis_layer_feature.resource == \"office\").select()\n for layer in feature_layers:\n if layer.role_required and not auth.s3_has_role(layer.role_required):\n continue\n _layer = gis.get_feature_layer(layer.module,\n layer.resource,\n layer.name,\n layer.popup_label,\n config=config,\n marker_id=layer.marker_id,\n active=layer.visible,\n polygons=layer.polygons,\n opacity=layer.opacity)\n if _layer:\n # Add a URL for downloading the GeoJSON\n # @ToDO: add to gis.get_feature_layer\n _layer[\"url\"] = \"%s.geojson\" % URL(r=request, c=layer.module, f=layer.resource)\n marker = db(db.gis_marker.id == _layer[\"marker\"]).select(db.gis_marker.image,\n db.gis_marker.height,\n db.gis_marker.width,\n limitby=(0, 1)).first()\n _layer[\"marker\"] = marker\n feature_queries.append(_layer)\n\n return dict(feature_queries=feature_queries)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def setup_product():\n\n fiveconfigure.debug_mode = True\n import collective.geo.openlayers\n zcml.load_config('configuretest.zcml', collective.geo.openlayers)\n\n fiveconfigure.debug_mode = False","def test_layer_API(self):\n\n # Exceptions\n exclude = ['get_topN', 'get_bins',\n 'get_geotransform',\n 'get_nodata_value',\n 'get_attribute_names',\n 'get_resolution',\n 'get_geometry_type',\n 'get_geometry_name',\n 'to_vector_points',\n 'to_vector_layer']\n\n V = Vector() # Empty vector instance\n R = Raster() # Empty raster instance\n\n assert same_API(V, R, exclude=exclude)\n\n for filename in [os.path.join(TESTDATA,\n 'test_buildings.shp'),\n os.path.join(HAZDATA,\n 'Lembang_Earthquake_Scenario.asc')]:\n\n L = read_layer(filename)\n\n assert same_API(L, V, exclude=exclude)\n assert same_API(L, R, exclude=exclude)","def test_to_geojson(self):\n fc = self.read_feature()\n dest_filename = str(self.datadir.join('test.geojson'))\n fc.to_geojson(dest_filename)\n fc_check = read_feature_collection(dest_filename)\n self.check_feature(fc_check.features[0])","def test_basic(self):\n st.map(df1)\n\n c = json.loads(self.get_delta_from_queue().new_element.deck_gl_json_chart.json)\n\n self.assertIsNotNone(c.get(\"initialViewState\"))\n self.assertIsNotNone(c.get(\"layers\"))\n self.assertIsNotNone(c.get(\"mapStyle\"))\n self.assertEqual(len(c.get(\"layers\")), 1)\n self.assertEqual(c.get(\"initialViewState\").get(\"latitude\"), 2.5)\n self.assertEqual(c.get(\"initialViewState\").get(\"longitude\"), 25)\n self.assertEqual(c.get(\"initialViewState\").get(\"zoom\"), 3)\n self.assertEqual(c.get(\"initialViewState\").get(\"pitch\"), 0)\n self.assertEqual(c.get(\"layers\")[0].get(\"@@type\"), \"ScatterplotLayer\")","def get_geoserver_layers(geoserver_url, geoserver_username, geoserver_password):\n\tgeoserver_rest_url = geoserver_url + 'rest'\n\teprint(\"retrieving GeoServer layer info via {}\".format(geoserver_rest_url))\n\tcat = Catalog(geoserver_rest_url, username=geoserver_username, password=geoserver_password)\n\tall_layers = cat.get_layers()\n\treturn all_layers","def test_authentication_is_not_required(self):\n # Act\n response = self.client.get(self.url)\n # Assert\n self.assertEqual(response.status_code, 200)\n self.assertEqual(response.json, self.test_project.get_aoi_geometry_as_geojson())","def test_choropleth_pass():\n m = view(world, column=\"pop_est\")","def test_browserlayer(self):\n from {{cookiecutter.package_name}}.interfaces import (\n I{{cookiecutter.project_slug.capitalize()}}CoreLayer)\n from plone.browserlayer import utils\n self.assertIn(I{{cookiecutter.project_slug.capitalize()}}CoreLayer, utils.registered_layers())","def show(data_objects, **options):\n if not is_loaded():\n return data_objects\n\n # (else)\n if not hasattr(data_objects, '__iter__'):\n data_objects = [data_objects]\n\n # print(data_objects)\n scene = pygeojs.scene(**options)\n scene.createLayer('osm')\n\n if not data_objects:\n print('No data objects')\n return scene\n\n # feature_layer = scene.createLayer('feature')\n feature_layer = None\n\n combined_bounds = None\n # Reverse order so that first item ends on top\n for data_object in reversed(data_objects):\n if data_object._getdatatype() == gaia.types.VECTOR:\n # print('Adding vector object')\n # Special handling for vector datasets:\n # First, make a copy of the geopandas frame\n df = geopandas.GeoDataFrame.copy(data_object.get_data())\n\n # Convert to lon-lat if needed\n epsg = data_object.get_epsg()\n if epsg and str(epsg) != '4326':\n print('Converting crs')\n df[df.geometry.name] = df.geometry.to_crs(epsg='4326')\n\n # Strip any z coordinates (force to z = 1)\n df.geometry = df.geometry.scale(zfact=0.0).translate(zoff=1.0)\n # df.to_file('/home/john/temp/df.pandas')\n # print(df)\n # print(df.geometry)\n\n # Calculate bounds\n geopandas_bounds = df.geometry.total_bounds\n xmin, ymin, xmax, ymax = geopandas_bounds\n meta_bounds = [\n [xmin, ymin], [xmax, ymin], [xmax, ymax], [xmin, ymax]\n ]\n\n # Add map feature\n if feature_layer is None:\n feature_layer = scene.createLayer('feature')\n\n # Use __geo_interface__ to get the geojson\n feature_layer.readGeoJSON(df.__geo_interface__)\n # print(df.__geo_interface__)\n else:\n # Get bounds, in order to compute overall bounds\n meta = data_object.get_metadata()\n # print('meta: {}'.format(meta))\n # print(meta)\n raster_bounds = meta.get('bounds').get('coordinates')[0]\n # print(meta_bounds)\n assert raster_bounds, 'data_object missing bounds'\n\n # meta bounds inconsistent between sources, so compute brute force\n xvals, yvals = zip(*raster_bounds)\n xmin, xmax = min(xvals), max(xvals)\n ymin, ymax = min(yvals), max(yvals)\n meta_bounds = [\n [xmin, ymin], [xmax, ymin], [xmax, ymax], [xmin, ymax]\n ]\n\n # Bounds format is [xmin, ymin, xmax, ymax]\n bounds = [\n meta_bounds[0][0], meta_bounds[0][1],\n meta_bounds[2][0], meta_bounds[2][1]\n ]\n\n # print(bounds)\n if combined_bounds is None:\n combined_bounds = bounds\n else:\n combined_bounds[0] = min(combined_bounds[0], bounds[0])\n combined_bounds[1] = min(combined_bounds[1], bounds[1])\n combined_bounds[2] = max(combined_bounds[2], bounds[2])\n combined_bounds[3] = max(combined_bounds[3], bounds[3])\n\n # print('options:', options)\n rep = options.get('representation')\n if rep == 'outline':\n # Create polygon object\n rect = [\n [bounds[0], bounds[1]],\n [bounds[2], bounds[1]],\n [bounds[2], bounds[3]],\n [bounds[0], bounds[3]],\n [bounds[0], bounds[1]],\n ]\n geojs_polygon = geojson.Polygon([rect])\n properties = {\n 'fillColor': '#fff',\n 'fillOpacity': 0.1,\n 'stroke': True,\n 'strokeColor': '#333',\n 'strokeWidth': 2\n }\n geojson_feature = geojson.Feature(\n geometry=geojs_polygon, properties=properties)\n geojson_collection = geojson.FeatureCollection([geojson_feature])\n # print(geojson_collection)\n\n if feature_layer is None:\n feature_layer = scene.createLayer('feature')\n\n feature_layer.createFeature(\n 'geojson', geojson_collection, **options)\n\n elif data_object.__class__.__name__ == 'GirderDataObject':\n if data_object._getdatatype() == 'raster':\n # Use large-image display\n # Todo - verify that it is installed\n tiles_url = data_object._get_tiles_url()\n # print('tiles_url', tiles_url)\n opacity = 1.0\n if hasattr(data_object, 'opacity'):\n opacity = data_object.opacity\n scene.createLayer(\n 'osm', url=tiles_url, keepLower=False, opacity=opacity)\n else:\n raise GaiaException(\n 'Cannot display GirderDataObject with data type {}'.format(\n data_object._getdatatype()))\n\n elif data_object._getdatatype() == gaia.types.VECTOR:\n pass # vector objects handled above\n else:\n msg = 'Cannot display dataobject, type {}'.format(\n data_object.__class__.__name__)\n raise GaiaException(msg)\n\n # Send custom message to (javascript) client to set zoom & center\n rpc = {'method': 'set_zoom_and_center', 'params': combined_bounds}\n scene.send(rpc)\n return scene","def setgeo(rundata):\n#-------------------\n\n try:\n geodata = rundata.geodata\n except:\n print \"*** Error, this rundata has no geodata attribute\"\n raise AttributeError(\"Missing geodata attribute\")\n\n # == setgeo.data values ==\n geodata.variable_dt_refinement_ratios = True ## Overrides clawdata.inratt, above\n\n geodata.igravity = 1\n geodata.gravity = 9.81\n geodata.icoordsys = 2\n geodata.Rearth = 6367.5e3\n geodata.icoriolis = 0\n\n # == settsunami.data values ==\n geodata.sealevel = 0.\n geodata.drytolerance = 1.e-2\n geodata.wavetolerance = 1.e-1 ##\n geodata.depthdeep = 1.e6 ## Definition of \"deep\" water\n geodata.maxleveldeep = 10 ## Restriction on the number of deep water levels\n geodata.ifriction = 1 ## Friction switch. 0=off, 1=on\n # geodata.coeffmanning =0.0\n geodata.coeffmanning =.025\n geodata.frictiondepth = 10.\n\n #okushiri_dir = '/Users/FrankGonzalez/daily/modeling/tsunami-benchmarks/github/' \\\n #+ 'FrankGonzalez/geoclaw-group/benchmarks/bp09' ##\n okushiri_dir = '..' ## this directory\n \n # == settopo.data values ==\n geodata.topofiles = []\n # for topography, append lines of the form\n # [topotype, minlevel, maxlevel, t1, t2, fname]\n # geodata.topofiles.append([1, 1, 1, 0, 1.e10, \\\n # okushiri_dir + '/OK24.tt1']) ## 24-s, ~550-740 m Entire Domain (Dmitry's version of Kansai U.)\n geodata.topofiles.append([1, 1, 1, 0, 1.e10, \\\n okushiri_dir + '/OK08.tt1']) ## 8-s, ~184-247 m Okushiri (Dmitry's version of Kansai U.)\n geodata.topofiles.append([1, 1, 1, 0, 1.e10, \\\n okushiri_dir + '/OK03.tt1']) ## 2.67 s (8/3s), ~61-82 m Okushiri (Dmitry's version of Kansai U.)\n geodata.topofiles.append([1, 1, 1, 0., 1.e10, \\\n okushiri_dir + '/AO15.tt1']) ## 0.53-0.89 s, ~16.5-20.4 m, Aonae (Dmitry's version of Kansai U.)\n # geodata.topofiles.append([1, 1, 1, 0, 1.e10, \\\n # okushiri_dir + '/MO01.tt1']) ## 0.89 s, ~20-27 m, Monai (Dmitry's version of Kansai U.)\n # geodata.topofiles.append([1, 1, 1, 0., 1.e10, \\\n # okushiri_dir + '/MB05.tt1']) ## 0.13-0.18 s, ~4 m Monai (Dmitry's version of Kansai U.)\n\n # geodata.topofiles.append([-3, 1, 1, 0, 1.e10, \\\n # okushiri_dir + '/depth40_138.txt']) ## JODC 500 m\n # geodata.topofiles.append([-3, 1, 1, 0, 1.e10, \\\n # okushiri_dir + '/depth40_140.txt']) ## JODC 500 m\n # geodata.topofiles.append([-3, 1, 1, 0, 1.e10, \\\n # okushiri_dir + '/depth42_138.txt']) ## JODC 500 m\n # geodata.topofiles.append([-3, 1, 1, 0, 1.e10, \\\n # okushiri_dir + '/depth42_140.txt']) ## JODC 500 m\n \n # == setdtopo.data values ==\n geodata.dtopofiles = []\n # for moving topography, append lines of the form: (<= 1 allowed for now!)\n # [topotype, minlevel,maxlevel,fname]\n geodata.dtopofiles.append([1,2,3, okushiri_dir + '/HNO1993.txyz']) ## Dmitry N.'s version of Kansai U.\n\n # == setqinit.data values ==\n geodata.iqinit = 0\n geodata.qinitfiles = []\n # for qinit perturbations, append lines of the form: (<= 1 allowed for now!)\n # [minlev, maxlev, fname]\n #geodata.qinitfiles.append([1, 1, 'hump.xyz'])\n\n # == setregions.data values ==\n geodata.regions = []\n # to specify regions of refinement append lines of the form\n # [minlevel,maxlevel,t1,t2,x1,x2,y1,y2]\n # Note: Level 1 = 24 s & Levels [2,3,4,5] = RF [3,3,3,8] => Res of 8 sec to 8/3 sec to 8/9 to 1/9 sec/cell\n # Grid Limits\n # Name x1 x2 y1 y2\n # OK24 137.53666670 141.53000000 39.53666670 44.26333330\n # HNO 138.50000000 140.55000000 40.51666670 43.30000000\n # OK08 138.50111110 140.55222220 40.52111110 43.29888890\n # OK03 139.38925930 139.66407410 41.99592590 42.27074070\n # AO15 139.43419750 139.49987650 42.03118520 42.07251850\n # MO01 139.41123460 139.43320990 42.07790120 42.14580250\n # MB05 139.41385190 139.42639510 42.09458550 42.10343920\n \n #geodata.regions.append([1, 1, 0., 1e9, 0.0, 360.0, -90.0, 90.0]) ## OK24: 24-s, ~550-740 m Entire Domain\n geodata.regions.append([1, 2, 0., 1e9, 138.5, 139.7, 41.4, 43.3]) ## OK08: 8-s, ~184-247 m Okushiri \n geodata.regions.append([1, 3, 0., 1e9, 139.39, 139.6, 42.0, 42.25]) ## OK03: 2.67 s (8/3s), ~61-82 m Okushiri \n # geodata.regions.append([1, 4, 0., 1e9, 139.42, 139.57, 42.03, 42.23]) ## AO15: 0.53-8/9 s, ~16.5-20.4 m, Aonae \n #geodata.regions.append([1, 4, 0., 1e9, 139.40, 139.46, 42.03, 42.22]) ## West coast Okushiri\n geodata.regions.append([4, 4, 90., 1e9, 139.42, 139.431, 42.07, 42.12])\n \n\n # == setgauges.data values ==\n geodata.gauges = []\n # for gauges append lines of the form [gaugeno, x, y, t1, t2]\n \n # geodata.gauges.append([1,139.429211710298,42.188181491811,0.0,1e9]) ## Tsuji Obs\n # geodata.gauges.append([3,139.411185686023,42.162762869034,0.0,1e9]) ## Tsuji Obs\n # geodata.gauges.append([5,139.418261206409,42.137404393442,0.0,1e9]) ## Tsuji Obs\n geodata.gauges.append([6,139.428035766149,42.093012384481,0.0,1e9]) ## Tsuji Obs\n geodata.gauges.append([7,139.426244998662,42.116554785296,0.0,1e9]) ## Tsuji Obs\n geodata.gauges.append([8,139.423714744650,42.100414145210,0.0,1e9]) ## Tsuji Obs\n geodata.gauges.append([9,139.428901803617,42.076636582137,0.0,1e9]) ## Tsuji Obs\n # geodata.gauges.append([10,139.427853421935,42.065461519438,0.0,1e9]) ## Tsuji Obs\n # geodata.gauges.append([11,139.451539852594,42.044696547058,0.0,1e9]) ## Tsuji Obs\n # geodata.gauges.append([12,139.456528443496,42.051692262353,0.0,1e9]) ## Tsuji Obs\n # geodata.gauges.append([13,139.456528443496,42.051692262353,0.0,1e9]) ## Tsuji Obs\n # \n # == setfixedgrids.data values ==\n\n geodata.fixedgrids = []\n \n for g in geodata.gauges:\n xg = g[1]\n yg = g[2]\n xg1 = xg - 0.001\n xg2 = xg + 0.002\n yg1 = yg - 0.001\n yg2 = yg + 0.002\n nx = 31\n ny = 31\n gaugeno = g[0]\n if gaugeno == 9:\n xg2 = xg + 0.003\n nx = 41\n if gaugeno == 8:\n xg1 = xg - 0.002\n xg2 = xg + 0.001\n yg1 = yg - 0.002\n yg2 = yg + 0.001\n \n geodata.fixedgrids.append([210.0,360.0,11,xg1,xg2,yg1,yg2,nx,ny,0,1])\n geodata.regions.append([5, 5, 180., 1e9, xg1,xg2,yg1,yg2])\n \n \n return rundata\n\n # end of function setgeo\n # ----------------------","def test_render_world_map():\n\n gdpinfo = {\n \"gdpfile\": \"isp_gdp.csv\",\n \"separator\": \",\",\n \"quote\": '\"',\n \"min_year\": 1960,\n \"max_year\": 2015,\n \"country_name\": \"Country Name\",\n \"country_code\": \"Country Code\"\n }\n \n# gdpinfo = {\n# \"gdpfile\": \"gdptable1.csv\",\n# \"separator\": \",\",\n# \"quote\": '\"',\n# \"min_year\": 2000,\n# \"max_year\": 2005,\n# \"country_name\": \"Country Name\",\n# \"country_code\": \"Code\"\n# }\n\n \n # Get pygal country code map\n pygal_countries = pygal.maps.world.COUNTRIES\n \n #test\n #render_world_map(gdpinfo, pygal_countries, \"2002\", \"isp_gdp_world_name_1960.svg\")\n\n # 1960\n render_world_map(gdpinfo, pygal_countries, \"1960\", \"isp_gdp_world_name_1960.svg\")\n\n # 1980\n #render_world_map(gdpinfo, pygal_countries, \"1980\", \"isp_gdp_world_name_1980.svg\")\n\n # 2000\n #render_world_map(gdpinfo, pygal_countries, \"2000\", \"isp_gdp_world_name_2000.svg\")\n\n # 2010\n #render_world_map(gdpinfo, pygal_countries, \"2010\", \"isp_gdp_world_name_2010.svg\")","def test_01_get_geometry_collection_list(self):\n response = self.client.get(reverse('collection-lc'), format='json')\n self.assertEqual(response.status_code, status.HTTP_200_OK)","def test_geo_ops_smoke(geo_table):\n t = geo_table\n\n # alias for fields\n point = t.geo_point\n linestring = t.geo_linestring\n polygon = t.geo_polygon\n multipolygon = t.geo_multipolygon\n\n # test ops\n point.srid()\n point.x()\n point.y()\n\n linestring.contains(point)\n linestring.end_point()\n linestring.length()\n linestring.max_distance(point)\n linestring.point_n(1)\n linestring.start_point()\n linestring.x_max()\n linestring.x_min()\n linestring.y_max()\n linestring.y_min()\n\n polygon.area()\n polygon.perimeter()\n\n multipolygon.n_points()\n multipolygon.n_rings()","def test_addon_layer(self):\n layers = [l.getName() for l in registered_layers()]\n self.assertIn('IBriefyPloneLayer', layers)","def __init__(self, server_name):\n server_url = SERVER_URL + server_name + '/MapServer/'\n super(OsmpFeatureLayerCollection, self).__init__(server_url)","def setUp(self):\n uri = path.join(path.dirname(__file__),'data','StressTest.shp')\n self.vlayer = QgsVectorLayer(uri, \"StressTest_Layer\", \"ogr\")\n self.nxProfile = Profile(self.vlayer, None)\n self.nxProfile.pathfinder(8, 10)\n # ['DateTime', 'Date', 'Time', 'RealField', 'IntField', 'StringFiel', 'PathName', 'PathName2']","def generate_openlayers(self):\n\n args = {}\n args['title'] = self.options.title\n args['bingkey'] = self.options.bingkey\n args['south'], args['west'], args['north'], args['east'] = self.swne\n args['minzoom'] = self.tminz\n args['maxzoom'] = self.tmaxz\n args['tilesize'] = self.tilesize\n args['tileformat'] = self.tileext\n args['publishurl'] = self.options.url\n args['copyright'] = self.options.copyright\n if self.options.tmscompatible:\n args['tmsoffset'] = \"-1\"\n else:\n args['tmsoffset'] = \"\"\n if self.options.profile == 'raster':\n args['rasterzoomlevels'] = self.tmaxz+1\n args['rastermaxresolution'] = 2**(self.nativezoom) * self.out_gt[1]\n\n s = r\"\"\"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n <html xmlns=\"http://www.w3.org/1999/xhtml\"\n <head>\n <title>%(title)s</title>\n <meta http-equiv='imagetoolbar' content='no'/>\n <style type=\"text/css\"> v\\:* {behavior:url(#default#VML);}\n html, body { overflow: hidden; padding: 0; height: 100%%; width: 100%%; font-family: 'Lucida Grande',Geneva,Arial,Verdana,sans-serif; }\n body { margin: 10px; background: #fff; }\n h1 { margin: 0; padding: 6px; border:0; font-size: 20pt; }\n #header { height: 43px; padding: 0; background-color: #eee; border: 1px solid #888; }\n #subheader { height: 12px; text-align: right; font-size: 10px; color: #555;}\n #map { height: 95%%; border: 1px solid #888; }\n .olImageLoadError { display: none; }\n .olControlLayerSwitcher .layersDiv { border-radius: 10px 0 0 10px; }\n </style>\"\"\" % args # noqa\n\n if self.options.profile == 'mercator':\n s += \"\"\"\n <script src='http://maps.google.com/maps/api/js?sensor=false&v=3.7'></script>\n \"\"\" % args\n\n s += \"\"\"\n <script src=\"http://www.openlayers.org/api/2.12/OpenLayers.js\"></script>\n <script>\n var map;\n var mapBounds = new OpenLayers.Bounds( %(west)s, %(south)s, %(east)s, %(north)s);\n var mapMinZoom = %(minzoom)s;\n var mapMaxZoom = %(maxzoom)s;\n var emptyTileURL = \"http://www.maptiler.org/img/none.png\";\n OpenLayers.IMAGE_RELOAD_ATTEMPTS = 3;\n\n function init(){\"\"\" % args\n\n if self.options.profile == 'mercator':\n s += \"\"\"\n var options = {\n div: \"map\",\n controls: [],\n projection: \"EPSG:3857\",\n displayProjection: new OpenLayers.Projection(\"EPSG:4326\"),\n numZoomLevels: 20\n };\n map = new OpenLayers.Map(options);\n\n // Create Google Mercator layers\n var gmap = new OpenLayers.Layer.Google(\"Google Streets\",\n {\n type: google.maps.MapTypeId.ROADMAP,\n sphericalMercator: true\n });\n var gsat = new OpenLayers.Layer.Google(\"Google Satellite\",\n {\n type: google.maps.MapTypeId.SATELLITE,\n sphericalMercator: true\n });\n var ghyb = new OpenLayers.Layer.Google(\"Google Hybrid\",\n {\n type: google.maps.MapTypeId.HYBRID,\n sphericalMercator: true\n });\n var gter = new OpenLayers.Layer.Google(\"Google Terrain\",\n {\n type: google.maps.MapTypeId.TERRAIN,\n sphericalMercator: true\n });\n\n // Create Bing layers\n var broad = new OpenLayers.Layer.Bing({\n name: \"Bing Roads\",\n key: \"%(bingkey)s\",\n type: \"Road\",\n sphericalMercator: true\n });\n var baer = new OpenLayers.Layer.Bing({\n name: \"Bing Aerial\",\n key: \"%(bingkey)s\",\n type: \"Aerial\",\n sphericalMercator: true\n });\n var bhyb = new OpenLayers.Layer.Bing({\n name: \"Bing Hybrid\",\n key: \"%(bingkey)s\",\n type: \"AerialWithLabels\",\n sphericalMercator: true\n });\n\n // Create OSM layer\n var osm = new OpenLayers.Layer.OSM(\"OpenStreetMap\");\n\n \"\"\" % args # noqa\n\t\t \n if self.options.xyz:\n s += \"\"\"\t\t \n // create TMS Overlay layer\n var tmsoverlay = new OpenLayers.Layer.XYZ(\"XYZ Overlay\",\n \"${z}/${x}/${y}.png\", {\n transitionEffect: 'resize',\n isBaseLayer: false\n });\n\t\t\t\t \n\t\t \"\"\" % args # noqa\n else:\n s += \"\"\"\t\t \n // create TMS Overlay layer\n var tmsoverlay = new OpenLayers.Layer.TMS(\"TMS Overlay\", \"\",\n {\n serviceVersion: '.',\n layername: '.',\n alpha: true,\n type: '%(tileformat)s',\n isBaseLayer: false,\n getURL: getURL\n });\n\t\t\t\t \n\t\t \"\"\" % args # noqa\t\t \n\t\t \n s += \"\"\" \n if (OpenLayers.Util.alphaHack() == false) {\n tmsoverlay.setOpacity(0.7);\n }\n\n map.addLayers([gmap, gsat, ghyb, gter,\n broad, baer, bhyb,\n osm, tmsoverlay]);\n\n var switcherControl = new OpenLayers.Control.LayerSwitcher();\n map.addControl(switcherControl);\n switcherControl.maximizeControl();\n\n map.zoomToExtent(mapBounds.transform(map.displayProjection, map.projection));\n \"\"\" % args # noqa\n\n elif self.options.profile == 'geodetic':\n s += \"\"\"\n var options = {\n div: \"map\",\n controls: [],\n projection: \"EPSG:4326\"\n };\n map = new OpenLayers.Map(options);\n\n var wms = new OpenLayers.Layer.WMS(\"VMap0\",\n \"http://tilecache.osgeo.org/wms-c/Basic.py?\",\n {\n layers: 'basic',\n format: 'image/png'\n }\n );\n var tmsoverlay = new OpenLayers.Layer.TMS(\"TMS Overlay\", \"\",\n {\n serviceVersion: '.',\n layername: '.',\n alpha: true,\n type: '%(tileformat)s',\n isBaseLayer: false,\n getURL: getURL\n });\n if (OpenLayers.Util.alphaHack() == false) {\n tmsoverlay.setOpacity(0.7);\n }\n\n map.addLayers([wms,tmsoverlay]);\n\n var switcherControl = new OpenLayers.Control.LayerSwitcher();\n map.addControl(switcherControl);\n switcherControl.maximizeControl();\n\n map.zoomToExtent(mapBounds);\n \"\"\" % args # noqa\n\n elif self.options.profile == 'raster':\n s += \"\"\"\n var options = {\n div: \"map\",\n controls: [],\n maxExtent: new OpenLayers.Bounds(%(west)s, %(south)s, %(east)s, %(north)s),\n maxResolution: %(rastermaxresolution)f,\n numZoomLevels: %(rasterzoomlevels)d\n };\n map = new OpenLayers.Map(options);\n\n var layer = new OpenLayers.Layer.TMS(\"TMS Layer\", \"\",\n {\n serviceVersion: '.',\n layername: '.',\n alpha: true,\n type: '%(tileformat)s',\n getURL: getURL\n });\n\n map.addLayer(layer);\n map.zoomToExtent(mapBounds);\n \"\"\" % args # noqa\n\n s += \"\"\"\n map.addControls([new OpenLayers.Control.PanZoomBar(),\n new OpenLayers.Control.Navigation(),\n new OpenLayers.Control.MousePosition(),\n new OpenLayers.Control.ArgParser(),\n new OpenLayers.Control.Attribution()]);\n }\n \"\"\" % args\n\n if self.options.profile == 'mercator' and self.options.xyz is None:\n s += \"\"\"\n function getURL(bounds) {\n bounds = this.adjustBounds(bounds);\n var res = this.getServerResolution();\n var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\n var z = this.getServerZoom();\n if (this.map.baseLayer.CLASS_NAME === 'OpenLayers.Layer.Bing') {\n z+=1;\n }\n var path = this.serviceVersion + \"/\" + this.layername + \"/\" + z + \"/\" + x + \"/\" + y + \".\" + this.type;\n var url = this.url;\n if (OpenLayers.Util.isArray(url)) {\n url = this.selectUrl(path, url);\n }\n if (mapBounds.intersectsBounds(bounds) && (z >= mapMinZoom) && (z <= mapMaxZoom)) {\n return url + path;\n } else {\n return emptyTileURL;\n }\n }\n \"\"\" % args # noqa\n\n elif self.options.profile == 'geodetic':\n s += \"\"\"\n function getURL(bounds) {\n bounds = this.adjustBounds(bounds);\n var res = this.getServerResolution();\n var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\n var z = this.getServerZoom()%(tmsoffset)s;\n var path = this.serviceVersion + \"/\" + this.layername + \"/\" + z + \"/\" + x + \"/\" + y + \".\" + this.type;\n var url = this.url;\n if (OpenLayers.Util.isArray(url)) {\n url = this.selectUrl(path, url);\n }\n if (mapBounds.intersectsBounds(bounds) && (z >= mapMinZoom) && (z <= mapMaxZoom)) {\n return url + path;\n } else {\n return emptyTileURL;\n }\n }\n \"\"\" % args # noqa\n\n elif self.options.profile == 'raster':\n s += \"\"\"\n function getURL(bounds) {\n bounds = this.adjustBounds(bounds);\n var res = this.getServerResolution();\n var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\n var z = this.getServerZoom();\n var path = this.serviceVersion + \"/\" + this.layername + \"/\" + z + \"/\" + x + \"/\" + y + \".\" + this.type;\n var url = this.url;\n if (OpenLayers.Util.isArray(url)) {\n url = this.selectUrl(path, url);\n }\n if (mapBounds.intersectsBounds(bounds) && (z >= mapMinZoom) && (z <= mapMaxZoom)) {\n return url + path;\n } else {\n return emptyTileURL;\n }\n }\n \"\"\" % args # noqa\n\n s += \"\"\"\n function getWindowHeight() {\n if (self.innerHeight) return self.innerHeight;\n if (document.documentElement && document.documentElement.clientHeight)\n return document.documentElement.clientHeight;\n if (document.body) return document.body.clientHeight;\n return 0;\n }\n\n function getWindowWidth() {\n if (self.innerWidth) return self.innerWidth;\n if (document.documentElement && document.documentElement.clientWidth)\n return document.documentElement.clientWidth;\n if (document.body) return document.body.clientWidth;\n return 0;\n }\n\n function resize() {\n var map = document.getElementById(\"map\");\n var header = document.getElementById(\"header\");\n var subheader = document.getElementById(\"subheader\");\n map.style.height = (getWindowHeight()-80) + \"px\";\n map.style.width = (getWindowWidth()-20) + \"px\";\n header.style.width = (getWindowWidth()-20) + \"px\";\n subheader.style.width = (getWindowWidth()-20) + \"px\";\n if (map.updateSize) { map.updateSize(); };\n }\n\n onresize=function(){ resize(); };\n\n </script>\n </head>\n <body onload=\"init()\">\n <div id=\"header\"><h1>%(title)s</h1></div>\n <div id=\"subheader\">Generated by <a href=\"http://www.klokan.cz/projects/gdal2tiles/\">GDAL2Tiles</a>, Copyright © 2008 <a href=\"http://www.klokan.cz/\">Klokan Petr Pridal</a>, <a href=\"http://www.gdal.org/\">GDAL</a> & <a href=\"http://www.osgeo.org/\">OSGeo</a> <a href=\"http://code.google.com/soc/\">GSoC</a>\n <!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->\n </div>\n <div id=\"map\"></div>\n <script type=\"text/javascript\" >resize()</script>\n </body>\n </html>\"\"\" % args # noqa\n\n return s","def test_run_spatial_function(session):\n factories.ConnectionNodeFactory()\n q = session.query(func.ST_AsGeoJSON(models.ConnectionNode.the_geom))\n q.first()","def __init__(self, feat):\n\n self.feat = feat\n self.shape = shape(feat[\"geometry\"])\n\n self.prop = feat[\"properties\"]\n self.feat[\"properties\"][\"style\"] = {\n \"fill_opacity\": 0.1,\n \"opacity\": 0.1, \n \"color\": \"white\", \n \"weight\": 0.75}\n self.id = self.prop[\"grid_id\"]\n self.level = self.prop[\"grid_level\"]\n \n self.layer = GeoJSON(\n data=self.feat,\n hover_style = {\n \"weight\": 1, \n \"color\": \"white\",\n \"fillColor\": \"white\",\n \"fillOpacity\": 0.3})\n self.layer.on_click(self.toggle)\n self.on = False","def generate_openlayers( self ):\n\n args = {}\n args['title'] = self.options.title\n args['googlemapskey'] = self.options.googlekey\n args['yahooappid'] = self.options.yahookey\n args['south'], args['west'], args['north'], args['east'] = self.swne\n args['minzoom'] = self.tminz\n args['maxzoom'] = self.tmaxz\n args['tilesize'] = self.tilesize\n args['tileformat'] = format_extension[self.image_output.format]\n if self.image_output.format == \"PNG\":\n args['has_alpha'] = 'true'\n else:\n args['has_alpha'] = 'false'\n args['publishurl'] = \"\" if self.options.url is None else self.options.url\n args['copyright'] = self.options.copyright\n if self.options.profile in ('raster', 'gearth'):\n args['rasterzoomlevels'] = self.tmaxz+1\n args['rastermaxresolution'] = 2**(self.nativezoom) * self.out_gt[1]\n\n s = \"\"\"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n <html xmlns=\"http://www.w3.org/1999/xhtml>\"\n <head>\n <title>%(title)s</title>\n <meta http-equiv='imagetoolbar' content='no'/>\n <style type=\"text/css\"> v\\:* {behavior:url(#default#VML);}\n html, body { overflow: hidden; padding: 0; height: 100%%; width: 100%%; font-family: 'Lucida Grande',Geneva,Arial,Verdana,sans-serif; }\n body { margin: 10px; background: #fff; }\n h1 { margin: 0; padding: 6px; border:0; font-size: 20pt; }\n #header { height: 43px; padding: 0; background-color: #eee; border: 1px solid #888; }\n #subheader { height: 12px; text-align: right; font-size: 10px; color: #555;}\n #map { height: 95%%; border: 1px solid #888; }\n </style>\"\"\" % args\n\n if self.options.profile == 'mercator':\n s += \"\"\"\n <script src='http://dev.virtualearth.net/mapcontrol/mapcontrol.ashx?v=6.1'></script>\n <script src='http://maps.google.com/maps?file=api&v=2&key=%(googlemapskey)s' type='text/javascript'></script>\n <script src=\"http://api.maps.yahoo.com/ajaxymap?v=3.0&appid=%(yahooappid)s\"></script>\"\"\" % args\n\n s += \"\"\"\n <script src=\"http://www.openlayers.org/api/2.7/OpenLayers.js\" type=\"text/javascript\"></script>\n <script type=\"text/javascript\">\n var map;\n var mapBounds = new OpenLayers.Bounds( %(west)s, %(south)s, %(east)s, %(north)s);\n var mapMinZoom = %(minzoom)s;\n var mapMaxZoom = %(maxzoom)s;\n\n // avoid pink tiles\n OpenLayers.IMAGE_RELOAD_ATTEMPTS = 3;\n OpenLayers.Util.onImageLoadErrorColor = \"transparent\";\n\n function init(){\"\"\" % args\n\n if self.options.profile == 'mercator':\n s += \"\"\"\n var options = {\n controls: [],\n projection: new OpenLayers.Projection(\"EPSG:900913\"),\n displayProjection: new OpenLayers.Projection(\"EPSG:4326\"),\n units: \"m\",\n maxResolution: 156543.0339,\n maxExtent: new OpenLayers.Bounds(-20037508, -20037508, 20037508, 20037508.34)\n };\n map = new OpenLayers.Map('map', options);\n\n // create Google Mercator layers\n var gmap = new OpenLayers.Layer.Google(\"Google Streets\",\n { sphericalMercator: true, numZoomLevels: 20} );\n var gsat = new OpenLayers.Layer.Google(\"Google Satellite\",\n {type: G_SATELLITE_MAP, sphericalMercator: true, numZoomLevels: 20} );\n var ghyb = new OpenLayers.Layer.Google(\"Google Hybrid\",\n {type: G_HYBRID_MAP, sphericalMercator: true, numZoomLevels: 20});\n var gter = new OpenLayers.Layer.Google(\"Google Terrain\",\n {type: G_PHYSICAL_MAP, sphericalMercator: true, numZoomLevels: 20 });\n\n // create Virtual Earth layers\n OpenLayers.Layer.VirtualEarth.prototype.MAX_ZOOM_LEVEL=19;\n OpenLayers.Layer.VirtualEarth.prototype.RESOLUTIONS=OpenLayers.Layer.Google.prototype.RESOLUTIONS\n var veroad = new OpenLayers.Layer.VirtualEarth(\"Virtual Earth Roads\",\n {'type': VEMapStyle.Road, 'sphericalMercator': true, numZoomLevels: 20});\n var veaer = new OpenLayers.Layer.VirtualEarth(\"Virtual Earth Aerial\",\n {'type': VEMapStyle.Aerial, 'sphericalMercator': true, numZoomLevels: 20 });\n var vehyb = new OpenLayers.Layer.VirtualEarth(\"Virtual Earth Hybrid\",\n {'type': VEMapStyle.Hybrid, 'sphericalMercator': true});\n\n // create Yahoo layer\n var yahoo = new OpenLayers.Layer.Yahoo(\"Yahoo Street\",\n {'sphericalMercator': true});\n var yahoosat = new OpenLayers.Layer.Yahoo(\"Yahoo Satellite\",\n {'type': YAHOO_MAP_SAT, 'sphericalMercator': true});\n var yahoohyb = new OpenLayers.Layer.Yahoo(\"Yahoo Hybrid\",\n {'type': YAHOO_MAP_HYB, 'sphericalMercator': true});\n\n // create OSM/OAM layer\n var osm = new OpenLayers.Layer.TMS( \"OpenStreetMap\",\n \"http://tile.openstreetmap.org/\",\n { type: 'png', getURL: osm_getTileURL, displayOutsideMaxExtent: true,\n attribution: '<a href=\"http://www.openstreetmap.org/\">OpenStreetMap</a>'} );\n var oam = new OpenLayers.Layer.TMS( \"OpenAerialMap\",\n \"http://tile.openaerialmap.org/tiles/1.0.0/openaerialmap-900913/\",\n { type: 'png', getURL: osm_getTileURL } );\n\n // create TMS Overlay layer\n var tmsoverlay = new OpenLayers.Layer.TMS( \"TMS Overlay\", \"\",\n { // url: '', serviceVersion: '.', layername: '.',\n type: '%(tileformat)s', getURL: overlay_getTileURL, alpha: %(has_alpha)s,\n isBaseLayer: false\n });\n if (OpenLayers.Util.alphaHack() == false) { tmsoverlay.setOpacity(0.7); }\n\n map.addLayers([gmap, gsat, ghyb, gter, veroad, veaer, vehyb,\n yahoo, yahoosat, yahoohyb, osm, oam,\n tmsoverlay]);\n\n var switcherControl = new OpenLayers.Control.LayerSwitcher();\n map.addControl(switcherControl);\n switcherControl.maximizeControl();\n\n map.zoomToExtent( mapBounds.transform(map.displayProjection, map.projection ) );\n \"\"\" % args\n\n elif self.options.profile == 'geodetic':\n s += \"\"\"\n var options = {\n controls: [],\n projection: new OpenLayers.Projection(\"EPSG:4326\"),\n maxResolution: 0.703125,\n maxExtent: new OpenLayers.Bounds(-180, -90, 180, 90)\n };\n map = new OpenLayers.Map('map', options);\n\n layer = new OpenLayers.Layer.WMS( \"Blue Marble\",\n \"http://labs.metacarta.com/wms-c/Basic.py?\", {layers: 'satellite' } );\n map.addLayer(layer);\n wms = new OpenLayers.Layer.WMS( \"VMap0\",\n \"http://labs.metacarta.com/wms-c/Basic.py?\", {layers: 'basic', format: 'image/png' } );\n map.addLayer(wms);\n\n var tmsoverlay = new OpenLayers.Layer.TMS( \"TMS Overlay\", \"\",\n {\n serviceVersion: '.', layername: '.', alpha: %(has_alpha)s,\n type: '%(tileformat)s', getURL: overlay_getTileURL,\n isBaseLayer: false\n });\n map.addLayer(tmsoverlay);\n if (OpenLayers.Util.alphaHack() == false) { tmsoverlay.setOpacity(0.7); }\n\n var switcherControl = new OpenLayers.Control.LayerSwitcher();\n map.addControl(switcherControl);\n switcherControl.maximizeControl();\n\n map.zoomToExtent( mapBounds );\n \"\"\" % args\n\n elif self.options.profile in ('raster', 'gearth'):\n s += \"\"\"\n var options = {\n controls: [],\n maxExtent: new OpenLayers.Bounds( %(west)s, %(south)s, %(east)s, %(north)s ),\n maxResolution: %(rastermaxresolution)f,\n numZoomLevels: %(rasterzoomlevels)d\n };\n map = new OpenLayers.Map('map', options);\n\n var layer = new OpenLayers.Layer.TMS( \"TMS Layer\",\"\",\n { url: '', serviceVersion: '.', layername: '.', alpha: %(has_alpha)s,\n type: '%(tileformat)s', getURL: overlay_getTileURL\n });\n map.addLayer(layer);\n map.zoomToExtent( mapBounds );\n \"\"\" % args\n\n\n s += \"\"\"\n map.addControl(new OpenLayers.Control.PanZoomBar());\n map.addControl(new OpenLayers.Control.MousePosition());\n map.addControl(new OpenLayers.Control.MouseDefaults());\n map.addControl(new OpenLayers.Control.KeyboardDefaults());\n }\n \"\"\" % args\n\n if self.options.profile == 'mercator':\n s += \"\"\"\n function osm_getTileURL(bounds) {\n var res = this.map.getResolution();\n var x = Math.round((bounds.left - this.maxExtent.left) / (res * this.tileSize.w));\n var y = Math.round((this.maxExtent.top - bounds.top) / (res * this.tileSize.h));\n var z = this.map.getZoom();\n var limit = Math.pow(2, z);\n\n if (y < 0 || y >= limit) {\n return \"https://github.com/mj10777/mapmbtiles/img/none.png\";\n } else {\n x = ((x %% limit) + limit) %% limit;\n return this.url + z + \"/\" + x + \"/\" + y + \".\" + this.type;\n }\n }\n\n function overlay_getTileURL(bounds) {\n var res = this.map.getResolution();\n var x = Math.round((bounds.left - this.maxExtent.left) / (res * this.tileSize.w));\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\n var z = this.map.getZoom();\n if (this.map.baseLayer.name == 'Virtual Earth Roads' || this.map.baseLayer.name == 'Virtual Earth Aerial' || this.map.baseLayer.name == 'Virtual Earth Hybrid') {\n z = z + 1;\n }\n if (mapBounds.intersectsBounds( bounds ) && z >= mapMinZoom && z <= mapMaxZoom ) {\n //console.log( this.url + z + \"/\" + x + \"/\" + y + \".\" + this.type);\n return this.url + z + \"/\" + x + \"/\" + y + \".\" + this.type;\n } else {\n return \"https://github.com/mj10777/mapmbtiles/img/none.png\";\n }\n }\n \"\"\" % args\n\n elif self.options.profile == 'geodetic':\n s += \"\"\"\n function overlay_getTileURL(bounds) {\n bounds = this.adjustBounds(bounds);\n var res = this.map.getResolution();\n var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\n var z = this.map.getZoom();\n var path = this.serviceVersion + \"/\" + this.layername + \"/\" + z + \"/\" + x + \"/\" + y + \".\" + this.type;\n var url = this.url;\n if (mapBounds.intersectsBounds( bounds ) && z >= mapMinZoom && z <= mapMaxZoom) {\n // console.log( this.url + z + \"/\" + x + \"/\" + y + \".\" + this.type);\n return this.url + z + \"/\" + x + \"/\" + y + \".\" + this.type;\n } else {\n return \"https://github.com/mj10777/mapmbtiles/img/none.png\";\n }\n }\n \"\"\" % args\n\n elif self.options.profile in ('raster','gearth'):\n s += \"\"\"\n function overlay_getTileURL(bounds) {\n var res = this.map.getResolution();\n var x = Math.round((bounds.left - this.maxExtent.left) / (res * this.tileSize.w));\n var y = Math.round((bounds.bottom - this.maxExtent.bottom) / (res * this.tileSize.h));\n var z = this.map.getZoom();\n if (x >= 0 && y >= 0) {\n return this.url + z + \"/\" + x + \"/\" + y + \".\" + this.type;\n } else {\n return \"https://github.com/mj10777/mapmbtiles/img/none.png\";\n }\n }\n \"\"\" % args\n\n s += \"\"\"\n function getWindowHeight() {\n if (self.innerHeight) return self.innerHeight;\n if (document.documentElement && document.documentElement.clientHeight)\n return document.documentElement.clientHeight;\n if (document.body) return document.body.clientHeight;\n return 0;\n }\n\n function getWindowWidth() {\n if (self.innerWidth) return self.innerWidth;\n if (document.documentElement && document.documentElement.clientWidth)\n return document.documentElement.clientWidth;\n if (document.body) return document.body.clientWidth;\n return 0;\n }\n\n function resize() {\n var map = document.getElementById(\"map\");\n var header = document.getElementById(\"header\");\n var subheader = document.getElementById(\"subheader\");\n map.style.height = (getWindowHeight()-80) + \"px\";\n map.style.width = (getWindowWidth()-20) + \"px\";\n header.style.width = (getWindowWidth()-20) + \"px\";\n subheader.style.width = (getWindowWidth()-20) + \"px\";\n if (map.updateSize) { map.updateSize(); };\n }\n\n onresize=function(){ resize(); };\n\n </script>\n </head>\n <body onload=\"init()\">\n <div id=\"header\"><h1>%(title)s</h1></div>\n <div id=\"subheader\">Generated by <a href=\"https://github.com/mj10777/mapmbtiles\">MapMbTiles</a>/<a href=\"http://www.klokan.cz/projects/gdal2mbtiles/\">GDAL2MbTiles</a>, Copyright © 2008 <a href=\"http://www.klokan.cz/\">Klokan Petr Pridal</a>, <a href=\"http://www.gdal.org/\">GDAL</a> & <a href=\"http://www.osgeo.org/\">OSGeo</a> <a href=\"http://code.google.com/soc/\">GSoC</a>\n <!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->\n </div>\n <div id=\"map\"></div>\n <script type=\"text/javascript\" >resize()</script>\n </body>\n </html>\"\"\" % args\n\n return s","def setUp(self):\n self.plugin = attributePainter(IFACE)\n self.vector = QgsVectorLayer(os.path.join(self.plugin.plugin_dir,\"test\",\"testdata.gpkg|layername=testdata\"),\"testdata\",\"ogr\")","def loadLayers():\r\n\r\n # First unload any layers that may already be loaded\r\n for myLayer in QgsMapLayerRegistry.instance().mapLayers():\r\n QgsMapLayerRegistry.instance().removeMapLayer(myLayer)\r\n\r\n # Now go ahead and load our layers\r\n\r\n myRoot = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))\r\n myData = os.path.join(myRoot, 'test_data')\r\n myData = myData.replace('Tim Sutton', 'TIMSUT~1')\r\n myData = myData.replace('Rudi Thiede', 'RUDI~1')\r\n\r\n # List all layers in the correct order.\r\n myFileList = ['test.shp']\r\n\r\n myCanvasLayers = []\r\n for myFile in myFileList:\r\n # Extract basename and absolute path\r\n myBaseName, myExt = os.path.splitext(myFile)\r\n myPath = os.path.join(myData, myFile)\r\n\r\n # Create QGis Layer Instance\r\n if myExt in ['.asc', '.tif']:\r\n myLayer = QgsRasterLayer(myPath, myBaseName)\r\n elif myExt in ['.shp']:\r\n myLayer = QgsVectorLayer(myPath, myBaseName, 'ogr')\r\n else:\r\n msg = 'File %s had illegal extension' % myPath\r\n raise Exception(msg)\r\n\r\n msg = 'Layer \"%s\" is not valid' % str(myLayer.source())\r\n assert myLayer.isValid(), msg\r\n\r\n # Add layer to the registry (that QGis knows about)\r\n QgsMapLayerRegistry.instance().addMapLayer(myLayer)\r\n\r\n # Create Map Canvas Layer Instance and add to list\r\n myCanvasLayers.append(QgsMapCanvasLayer(myLayer))\r\n\r\n # Add MCL's to the CANVAS\r\n # NOTE: New layers *must* be added to the end of this list, otherwise\r\n # tests will break.\r\n CANVAS.setLayerSet(myCanvasLayers)","def test_core_functionality(self):\n # Test typing\n self.run_map_collection(\n _map_collection=self.example_map\n )","def setgeo(rundata):\n#-------------------\n\n try:\n geodata = rundata.geodata\n except:\n print \"*** Error, this rundata has no geodata attribute\"\n raise AttributeError(\"Missing geodata attribute\")\n\n # == setgeo.data values ==\n\n geodata.variable_dt_refinement_ratios = True\n\n geodata.igravity = 1\n geodata.gravity = 9.81\n geodata.icoordsys = 2\n geodata.Rearth = 6367.5e3\n geodata.icoriolis = 0\n\n # == settsunami.data values ==\n geodata.sealevel = 0.\n geodata.drytolerance = 1.e-3\n geodata.wavetolerance = 1.e-1\n geodata.depthdeep = 1.e2\n geodata.maxleveldeep = 4\n geodata.ifriction = 1\n geodata.coeffmanning =.025\n geodata.frictiondepth = 200.\n\n\n # == settopo.data values ==\n geodata.topofiles = []\n # for topography, append lines of the form\n # [topotype, minlevel, maxlevel, t1, t2, fname]\n geodata.topofiles.append([3, 1, 1, 0., 1e10, 'ebanda.asc'])\n \n\n # == setdtopo.data values ==\n geodata.dtopofiles = []\n # for moving topography, append lines of the form: (<= 1 allowed for now!)\n # [topotype, minlevel, maxlevel, fname]\n geodata.dtopofiles.append([3,1,3,'BandaArc1852.tt3'])\n\n geodata.iqinit = 0\n geodata.qinitfiles = []\n\n # == setgauges.data values ==\n geodata.gauges = []\n # for gauges append lines of the form [gaugeno,x,y,t1,t2]\n geodata.gauges.append([1, 109.000, -7.789, 0., 1e10]) #Cialciap\n geodata.gauges.append([2, 109.040, -7.722, 0., 1e10]) #Cialciap Bay\n geodata.gauges.append([3, 110.292, -8.027, 0., 1e10]) #Bantul\n geodata.gauges.append([4, 111.086, -8.233, 0., 1e10]) #Pacitan\n geodata.gauges.append([5, 111.558, -8.319, 0., 1e10]) #Pelang Beach\n geodata.gauges.append([6, 111.968, -8.286, 0., 1e10]) #Sine Beach\n geodata.gauges.append([7, 112.982, -8.326, 0., 1e10]) #Guying\n geodata.gauges.append([8, 113.176, -8.286, 0., 1e10]) #Muara\n geodata.gauges.append([9, 113.461, -8.383, 0., 1e10]) #Puger\n geodata.gauges.append([10, 113.336, -8.506, 0., 1e10]) #Barung Island\n geodata.gauges.append([11, 114.110, -8.621, 0., 1e10]) #Lampon\n geodata.gauges.append([12, 114.396, -8.231, 0., 1e10]) #Banyuwani\n geodata.gauges.append([13, 112.880, -7.278, 0., 1e10]) #Surabiya\n geodata.gauges.append([14, 114.965, -8.533, 0., 1e10]) #Tabanan\n geodata.gauges.append([15, 115.144, -8.697, 0., 1e10]) #Kuta\n geodata.gauges.append([16, 115.193, -8.848, 0., 1e10]) #Nusa Dua\n geodata.gauges.append([17, 116.064, -8.586, 0., 1e10]) #Mataram\n geodata.gauges.append([18, 115.260, -8.727, 0., 1e10]) #Sanur\n geodata.gauges.append([19, 116.031, -8.873, 0., 1e10]) #Sepi Bay\n geodata.gauges.append([20, 116.135, -8.872, 0., 1e10]) #Serangan Beach\n geodata.gauges.append([21, 116.283, -8.902, 0., 1e10]) #Kuta Lombok\n geodata.gauges.append([22, 116.400, -8.868, 0., 1e10]) #Awang Bay\n geodata.gauges.append([23, 116.466, -8.924, 0., 1e10]) #Surga Beach\n geodata.gauges.append([24, 116.744, -8.918, 0., 1e10]) #Maluk\n geodata.gauges.append([25, 116.833, -9.047, 0., 1e10]) #Tongo\n geodata.gauges.append([26, 117.199, -9.023, 0., 1e10]) #Linyuk\n geodata.gauges.append([27, 117.762, -8.939, 0., 1e10]) #Leppu\n geodata.gauges.append([28, 118.377, -8.785, 0., 1e10]) #Huu\n geodata.gauges.append([29, 118.172, -8.780, 0., 1e10]) #Rontu Beach\n geodata.gauges.append([30, 119.403, -8.729, 0., 1e10]) #Mantea Alley\n geodata.gauges.append([31, 119.374, -9.788, 0., 1e10]) #Nihiwatu\n geodata.gauges.append([32, 119.466, -9.742, 0., 1e10]) #Waigalli\n geodata.gauges.append([33, 119.945, -9.975, 0., 1e10]) #Tarimbang Beach\n geodata.gauges.append([34, 120.183, -10.233, 0., 1e10]) #Lalindi\n geodata.gauges.append([35, 120.264, -10.257, 0., 1e10]) #Manoekangga\n geodata.gauges.append([36, 120.546, -10.241, 0., 1e10]) #Baing\n geodata.gauges.append([37, 120.312, -9.661, 0., 1e10]) #Waingapu\n geodata.gauges.append([38, 119.871, -8.501, 0., 1e10]) #Labun Badjo\n geodata.gauges.append([39, 120.604, -8.822, 0., 1e10]) #Mborong\n geodata.gauges.append([40, 123.560, -10.166, 0., 1e10]) #Kupang\n geodata.gauges.append([41, 121.824, -10.491, 0., 1e10]) #Baa","def test_load_edition_data(self):\n key = \"OL1234W\"\n responses.add(\n responses.GET,\n \"https://openlibrary.org/works/OL1234W/editions\",\n json={\"hi\": \"there\"},\n )\n result = self.connector.load_edition_data(key)\n self.assertEqual(result, {\"hi\": \"there\"})","def generate_test_data(root: str) -> str:\n size = (64, 64)\n folder_path = os.path.join(root, \"enviroatlas_lotp\")\n\n if not os.path.exists(folder_path):\n os.makedirs(folder_path)\n\n for prefix in tile_list:\n for suffix, data_profile in layer_data_profiles.items():\n img_path = os.path.join(folder_path, f\"{prefix}_{suffix}.tif\")\n img_dir = os.path.dirname(img_path)\n if not os.path.exists(img_dir):\n os.makedirs(img_dir)\n\n data_profile[\"profile\"][\"height\"] = size[0]\n data_profile[\"profile\"][\"width\"] = size[1]\n data_profile[\"profile\"][\"transform\"] = Affine(\n 1.0, 0.0, 608170.0, 0.0, -1.0, 3381430.0\n )\n\n write_data(\n img_path,\n data_profile[\"profile\"],\n data_profile[\"data_type\"],\n data_profile[\"vals\"],\n )\n\n # build the spatial index\n schema = {\n \"geometry\": \"Polygon\",\n \"properties\": {\n \"split\": \"str\",\n \"naip\": \"str\",\n \"nlcd\": \"str\",\n \"roads\": \"str\",\n \"water\": \"str\",\n \"waterways\": \"str\",\n \"waterbodies\": \"str\",\n \"buildings\": \"str\",\n \"lc\": \"str\",\n \"prior_no_osm_no_buildings\": \"str\",\n \"prior\": \"str\",\n },\n }\n with fiona.open(\n os.path.join(folder_path, \"spatial_index.geojson\"),\n \"w\",\n driver=\"GeoJSON\",\n crs=\"EPSG:3857\",\n schema=schema,\n ) as dst:\n for prefix in tile_list:\n img_path = os.path.join(folder_path, f\"{prefix}_a_naip.tif\")\n with rasterio.open(img_path) as f:\n geom = shapely.geometry.mapping(shapely.geometry.box(*f.bounds))\n geom = fiona.transform.transform_geom(\n f.crs.to_string(), \"EPSG:3857\", geom\n )\n\n row = {\n \"geometry\": geom,\n \"properties\": {\n \"split\": prefix.split(\"/\")[0].replace(\"_tiles-debuffered\", \"\")\n },\n }\n for suffix, data_profile in layer_data_profiles.items():\n key = suffix_to_key_map[suffix]\n row[\"properties\"][key] = f\"{prefix}_{suffix}.tif\"\n dst.write(row)\n\n # Create archive\n archive_path = os.path.join(root, \"enviroatlas_lotp\")\n shutil.make_archive(archive_path, \"zip\", root_dir=root, base_dir=\"enviroatlas_lotp\")\n shutil.rmtree(folder_path)\n md5: str = calculate_md5(archive_path + \".zip\")\n return md5","def test_geometry_collection_get_bounds():\n geojson_data = {\n \"geometries\": [\n {\n \"coordinates\": [\n [\n [-1, 1],\n [0, 2],\n [-3, 4],\n [2, 0],\n ]\n ],\n \"type\": \"Polygon\",\n },\n ],\n \"type\": \"GeometryCollection\",\n }\n assert folium.GeoJson(geojson_data).get_bounds() == [[0, -3], [4, 2]]","def test_list_polygons(self, api_client):\n baker.make(Polygon, _quantity=2)\n url = self.base_url + \"/polygons/\"\n response = api_client().get(url)\n assert response.status_code == 200\n assert len(json.loads(response.content)) == 2","def testQGISEnvironment(self):\r\n\r\n r = QgsProviderRegistry.instance()\r\n #for item in r.providerList():\r\n # print str(item)\r\n\r\n print 'Provider count: %s' % len(r.providerList())\r\n assert 'gdal' in r.providerList()\r\n assert 'ogr' in r.providerList()","def test_access(geometry):\n geometry.print_list_of_geos()\n geometry.print_list_of_geos_children()\n\n logger.info('TOP GEO:')\n top_geo = geometry.get_top_geo()\n top_geo.print_geo_children()\n\n logger.info('INTERMEDIATE GEO (QUAD):')\n geo = geometry.get_geo('QUAD:V1', 0)\n #geo = geometry.get_top_geo()\n geo.print_geo_children()\n\n t0_sec = time()\n X,Y,Z = geo.get_pixel_coords(do_tilt=True)\n #X,Y = geo.get_2d_pixel_coords()\n s = 'X: %s' % str(X)\n s+= '\\n Consumed time to get 3d pixel coordinates = %7.3f sec' % (time()-t0_sec)\n s+= '\\n Geometry object: %s:%d X.shape:%s' % (geo.oname, geo.oindex, str(X.shape))\n logger.info(s)\n\n logger.info('Test of print_pixel_coords() for quad:')\n geometry.print_pixel_coords('QUAD:V1', 1)\n logger.info('Test of print_pixel_coords() for CSPAD:')\n geometry.print_pixel_coords()\n\n s = 'Test of get_pixel_areas() for QUAD:'\n A = geo.get_pixel_areas()\n s+= '\\n Geometry object: %s:%d A.shape:%s' % (geo.oname, geo.oindex, str(A.shape))\n s+= '\\n A[0,0:5,190:198]:\\n' + str(A[0,0:5,190:198])\n logger.info(s)\n\n s = 'Test of get_pixel_areas() for CSPAD:'\n A = top_geo.get_pixel_areas()\n s+= '\\n Geometry object: %s:%d A.shape:%s' % (geo.oname, geo.oindex, str(A.shape))\n s+= '\\n A[0,0,0:5,190:198]:\\n' + str(A[0,0,0:5,190:198])\n logger.info(s)\n\n s = 'Test of get_size_geo_array()'\n s+= '\\n for QUAD: %d' % geo.get_size_geo_array()\n s+= '\\n for CSPAD: %d' % top_geo.get_size_geo_array()\n logger.info(s)\n\n s = 'Test of get_pixel_scale_size()'\n s+= '\\n for QUAD : %8.2f' % geo.get_pixel_scale_size()\n s+= '\\n for CSPAD : %8.2f' % top_geo.get_pixel_scale_size()\n s+= '\\n for geometry: %8.2f' % geometry.get_pixel_scale_size()\n logger.info(s)\n\n s = 'Test of get_dict_of_comments():'\n d = geometry.get_dict_of_comments()\n s+= '\\n d[0] = %s' % str(d[0])\n logger.info(s)","def test_initialized() -> None:\n MapieRegressor()","def test_render_world_map():\n gdpinfo = {\n \"gdpfile\": \"isp_gdp.csv\",\n \"separator\": \",\",\n \"quote\": '\"',\n \"min_year\": 1960,\n \"max_year\": 2015,\n \"country_name\": \"Country Name\",\n \"country_code\": \"Country Code\"\n }\n\n # Get pygal country code map\n pygal_countries = pygal.maps.world.COUNTRIES\n #pygal_countries = {'KEN':'Kenya', 'IDN':'Indonesia', 'IND':'India', \\\n #'USA':'United States of America'}\n\n # 1960\n #render_world_map(gdpinfo, pygal_countries, \"1960\", \"isp_gdp_world_name_1960.svg\")\n\n # 1980\n #render_world_map(gdpinfo, pygal_countries, \"1980\", \"isp_gdp_world_name_1980.svg\")\n\n # 2000\n #render_world_map(gdpinfo, pygal_countries, \"2000\", \"isp_gdp_world_name_2000.svg\")\n\n # 2010\n render_world_map(gdpinfo, pygal_countries, \"2010\", \"isp_gdp_world_name_2010.svg\")","def test():\n root_path = os.path.dirname(os.path.realpath(__file__))\n test_path = os.path.join(root_path, 'test_files')\n with open(os.path.join(test_path, 'hexagons0.geojson')) as f:\n hexagons_old = load(f)\n with open(os.path.join(test_path, 'hexagons1.geojson')) as f:\n hexagons_new = load(f) \n return hexagons_new, hexagons_old","def test_main_no_argument():\n assert geojson2fromto.main() is False","def test_update_zoom_rooms_location_structure(self):\n pass","def test_get_polygons_nested(self):\n path = os.path.join(BASE_DIR, \"tests\", \"fixtures\", \"kenya.zip\")\n zip_file = zipfile.ZipFile(path)\n shapefile = get_shapefile(zip_file)\n\n with TemporaryDirectory() as temp_dir:\n tpath = temp_dir\n # Extract all files to Temporary Directory\n zip_file.extractall(tpath)\n # concatenate Shapefile path\n shp_path = os.path.join(tpath, shapefile)\n # Make the shapefile a DataSource\n data_source = DataSource(shp_path)\n layer = data_source[0]\n # Get geoms for all Polygons in Datasource\n geom_object_list = layer.get_geoms()\n polygons = get_polygons(geom_object_list)\n\n # check that we get the expected number of Polygons\n self.assertEqual(431, len(polygons))\n\n for item in polygons:\n self.assertTrue(isinstance(item, Polygon))\n\n # lets check get_polygons from the nested multipolygons\n multipolygon_list = [\n _ for _ in geom_object_list if isinstance(_, geometries.MultiPolygon)\n ]\n\n self.assertEqual(12, len(multipolygon_list))\n other_polygons = get_polygons(multipolygon_list)\n # check that we get the expected number of Polygons\n self.assertEqual(52, len(other_polygons))\n for item in other_polygons:\n self.assertTrue(isinstance(item, Polygon))\n # if we add all polygons, do we get the expected number?\n # 379 is the number of poolygons excluding nested multipolygons\n # see the `test_get_polygons_ignore_invalid` test below\n self.assertEqual(431, 379 + len(other_polygons))","def test_render_world_map():\n gdpinfo = {\n \"gdpfile\": \"isp_gdp.csv\",\n \"separator\": \",\",\n \"quote\": '\"',\n \"min_year\": 1960,\n \"max_year\": 2015,\n \"country_name\": \"Country Name\",\n \"country_code\": \"Country Code\"\n }\n\n codeinfo = {\n \"codefile\": \"isp_country_codes.csv\",\n \"separator\": \",\",\n \"quote\": '\"',\n \"plot_codes\": \"ISO3166-1-Alpha-2\",\n \"data_codes\": \"ISO3166-1-Alpha-3\"\n }\n\n # Get pygal country code map\n pygal_countries = pygal.maps.world.COUNTRIES\n\n # 1960\n render_world_map(gdpinfo, codeinfo, pygal_countries, \"1960\", \"isp_gdp_world_code_1960.svg\")\n\n # 1980\n render_world_map(gdpinfo, codeinfo, pygal_countries, \"1980\", \"isp_gdp_world_code_1980.svg\")\n\n # 2000\n render_world_map(gdpinfo, codeinfo, pygal_countries, \"2000\", \"isp_gdp_world_code_2000.svg\")\n\n # 2010\n render_world_map(gdpinfo, codeinfo, pygal_countries, \"2010\", \"isp_gdp_world_code_2010.svg\")","def test_render_world_map():\n gdpinfo = {\n \"gdpfile\": \"isp_gdp.csv\",\n \"separator\": \",\",\n \"quote\": '\"',\n \"min_year\": 1960,\n \"max_year\": 2015,\n \"country_name\": \"Country Name\",\n \"country_code\": \"Country Code\"\n }\n\n codeinfo = {\n \"codefile\": \"isp_country_codes.csv\",\n \"separator\": \",\",\n \"quote\": '\"',\n \"plot_codes\": \"ISO3166-1-Alpha-2\",\n \"data_codes\": \"ISO3166-1-Alpha-3\"\n }\n\n # Get pygal country code map\n pygal_countries = pygal.maps.world.COUNTRIES\n\n # 1960\n render_world_map(gdpinfo, codeinfo, pygal_countries, \"1960\", \"isp_gdp_world_code_1960.svg\")\n\n # 1980\n render_world_map(gdpinfo, codeinfo, pygal_countries, \"1980\", \"isp_gdp_world_code_1980.svg\")\n\n # 2000\n render_world_map(gdpinfo, codeinfo, pygal_countries, \"2000\", \"isp_gdp_world_code_2000.svg\")\n\n # 2010\n render_world_map(gdpinfo, codeinfo, pygal_countries, \"2010\", \"isp_gdp_world_code_2010.svg\")","def test_ocean() -> None:\n cfg = load_config()\n setup = ModelSetup(str(TEST_DIREC), cfg)\n ocean = Ocean(cfg, setup)\n ocean.compile_all()\n if cfg.run:\n ocean.run_all()\n if cfg.animate:\n ocean.animate_all()","def test_gelir_api(self):\n response = self.client.get(reverse('gelir-json', args=[self.sample_type]))\n self.assertContains(response, self.proband.gel_id)\n self.assertEquals(response.status_code, 200)","def get_webmap_operational_layers(web_map, layer_name):\r\n web_map_definition = web_map.definition\r\n for layer in web_map_definition['operationalLayers']:\r\n if layer_name in layer['title']:\r\n operational_layer = layer\r\n\r\n return operational_layer","def test_convert_features(convert_features_parameters):\n test_input = convert_features_parameters[0]\n expected_output = convert_features_parameters[1]\n assert geojson2fromto.convert(test_input) == expected_output","def wfs_common(request, response, mode, spatial_mode='wfs'):\n\n outputpath = configuration.get_config_value('server', 'outputpath')\n outputurl = configuration.get_config_value('server', 'outputurl')\n\n list_of_files = []\n for one_resource in request.inputs['resource']:\n # Download if not opendap\n # Adding a maximum file size from a server config file would\n # be possible here...\n try:\n nc_file = opendap_or_download(\n one_resource.data,\n auth_tkt_cookie=request.http_request.cookies,\n output_path='/tmp')\n except:\n raise Exception(traceback.format_exc())\n list_of_files.append(nc_file)\n\n if ('typename' in request.inputs) and ('featureids' in request.inputs):\n typename = request.inputs['typename'][0].data\n features = [f.data for f in request.inputs['featureids']]\n if 'geoserver' in request.inputs:\n geoserver = request.inputs['geoserver'][0].data\n else:\n geoserver = configuration.get_config_value('extra', 'geoserver')\n if 'mosaic' in request.inputs:\n mosaic = request.inputs['mosaic'][0].data\n else:\n mosaic = False\n try:\n conn = WebFeatureService(url=geoserver, version='2.0.0')\n resp = conn.getfeature([typename], featureid=features,\n outputFormat='application/json')\n feature = json.loads(resp.read())\n crs_code = owslib.crs.Crs(\n feature['crs']['properties']['name']).code\n crs = ocgis.CoordinateReferenceSystem(epsg=crs_code)\n geom = [\n {'geom': shape(f['geometry']), 'crs': crs,\n 'properties': f['properties']}\n for f in feature['features']]\n except Exception as e:\n msg = ('Failed to fetch features.\\ngeoserver: {0} \\n'\n 'typename: {1}\\nfeatures {2}\\n{3}').format(\n geoserver, typename, features, e)\n raise Exception(msg)\n if mosaic:\n new_geom = geom[0]\n for merge_geom in geom[1:]:\n new_geom['geom'] = new_geom['geom'].union(merge_geom['geom'])\n new_geom['properties'] = {'bbox': feature['bbox']}\n geom = new_geom\n elif spatial_mode == 'bbox':\n geom = [[request.inputs['lon0'][0].data,\n request.inputs['lat0'][0].data,\n request.inputs['lon1'][0].data,\n request.inputs['lat1'][0].data]]\n else:\n geom = [None]\n\n if ('initial_datetime' in request.inputs) and \\\n ('final_datetime' in request.inputs):\n tr = [request.inputs['initial_datetime'][0].data,\n request.inputs['final_datetime'][0].data]\n else:\n tr = None\n\n try:\n output_files = []\n output_urls = []\n mv_dir = tempfile.mkdtemp(dir=outputpath)\n os.chmod(mv_dir, 0755)\n\n for one_file in list_of_files:\n file_name = os.path.basename(one_file)\n if file_name[-3:] == '.nc':\n file_prefix = file_name[:-3]\n else:\n file_prefix = file_name\n ocgis.env.DIR_OUTPUT = tempfile.mkdtemp(dir=os.getcwd())\n ocgis.env.OVERWRITE = True\n nc = netCDF4.Dataset(one_file, 'r')\n var_names = guess_main_variables(nc)\n nc.close()\n rd = ocgis.RequestDataset(one_file, var_names)\n for i, one_geom in enumerate(geom):\n if one_geom is None:\n ocgis_geom = None\n elif spatial_mode == 'bbox':\n ocgis_geom = one_geom\n else:\n ocgis_geom = one_geom['geom']\n if mode == 'averager':\n # Extent errors are ignored\n try:\n # Here with aggregate=True, can't pass the whole\n # one_geom dictionary, is this a sign that this does\n # not support multipolygon?\n ops = ocgis.OcgOperations(\n dataset=rd, geom=ocgis_geom,\n spatial_operation='clip', aggregate=True,\n time_range=tr, output_format='nc',\n interpolate_spatial_bounds=True,\n prefix=file_prefix).execute()\n except ExtentError:\n continue\n elif mode == 'subsetter':\n # Extent errors are ignored\n try:\n # Still having problem with the geometry, previously\n # was passing geom=[one_geom]\n ops = ocgis.OcgOperations(\n dataset=rd, geom=ocgis_geom, time_range=tr,\n output_format='nc',\n interpolate_spatial_bounds=True,\n prefix=file_prefix).execute()\n except ExtentError:\n continue\n # Here, the global attribute 'subset_typename' and\n # 'subset_featureid' are added to the NetCDF file to keep\n # track of the feature used.\n if (geom != [None]) and (spatial_mode == 'wfs'):\n with netCDF4.Dataset(ops, 'a') as nc:\n nc.subset_typename = typename\n nc.subset_featureid = features[i]\n\n if (spatial_mode == 'wfs') and \\\n ('featureids' in request.inputs):\n mv_name = '{0}_{1}.nc'.format(\n os.path.basename(ops)[:-3], features[i])\n else:\n mv_name = '{0}_{1}.nc'.format(\n os.path.basename(ops)[:-3], 'subset')\n\n mv_file = os.path.join(mv_dir, mv_name)\n shutil.move(ops, mv_file)\n output_files.append(mv_file)\n shutil.rmtree(ocgis.env.DIR_OUTPUT)\n\n # Cover the case of an online wps server and the offline\n # mode for tests.\n if outputurl == 'file:///tmp':\n disk_file = 'file:///' + mv_file.lstrip('/')\n output_urls.append(disk_file)\n else:\n url_file = os.path.join(\n outputurl, os.path.basename(mv_dir), mv_name)\n output_urls.append(url_file)\n except:\n raise Exception(traceback.format_exc())\n\n # If only ExtentError occured, the output_urls will be empty...\n if not output_urls:\n raise ExtentError(message=\"All ocgis calls returned ExtentError.\")\n\n time_str = time.strftime(\"%Y-%m-%dT%H:%M:%SZ\", time.gmtime())\n output_file_name = \"result_%s_.json\" % (time_str,)\n output_file = os.path.join('/tmp', output_file_name)\n f1 = open(output_file, 'w')\n f1.write(json.dumps(output_urls))\n f1.close()\n response.outputs['output'].file = output_file\n response.outputs['output'].output_format = json_format\n response.update_status(\"done\", 100)\n return response","def test_no_crs():\n df = world.copy()\n df.crs = None\n m = view(df)\n assert \"openstreetmap\" not in m.to_dict()[\"children\"].keys()","def test_loading_a_simple_layer(self, sdoc):\n tdoc = ezdxf.new()\n loader = xref.Loader(sdoc, tdoc)\n loader.load_layers([\"first\"])\n loader.execute()\n assert document_has_no_errors(tdoc) is True\n\n layer = tdoc.layers.get(\"first\")\n\n assert layer is not sdoc.layers.get(\"first\"), \"expected a copy\"\n assert layer.dxf.name == \"FIRST\", \"expected the original layer name\"\n assert layer.doc is tdoc, \"bound to wrong document\"\n assert layer.dxf.handle in tdoc.entitydb, \"entity not in database\"\n assert layer.dxf.owner == tdoc.layers.head.dxf.handle, \"invalid owner handle\"\n assert layer.dxf.material_handle == tdoc.materials[\"global\"].dxf.handle","def preview_ways(geodataframe):\n\n # Map tiles from contextily are provided in the Web Mercator coordinate reference system (EPSG:3857).\n gdf_wm = geodataframe.to_crs(epsg='3857')\n # Add a column for the centre of each geometry\n gdf_wm['centroid'] = gdf_wm.geometry.centroid\n # Create plot using matplotlib functionality\n ax = gdf_wm.plot(figsize=(10, 6), color='blue', linewidth=2)\n gdf_wm.centroid.plot(ax=ax, marker='o', color='red', alpha=0.5, markersize=40)\n # Add a basemap from contextily. This map should look a lot like Overpass Turbo!\n ctx.add_basemap(ax, source=ctx.providers.OpenStreetMap.Mapnik)","def feature_layer_popup(map_service_name, map_service_type, web_map, layer_name):\r\n # get operational layer of a web map\r\n operational_layer = get_webmap_operational_layers(\r\n web_map=web_map,\r\n layer_name=layer_name\r\n )\r\n # get feature layer from feature layer collection\r\n target_layer = get_feature_layer_from_feature_service(\r\n map_service_name=map_service_name,\r\n map_service_type=map_service_type,\r\n layer_name=layer_name\r\n )\r\n\r\n # set popup info for the operational layer based on the type of services\r\n # hosted feature layer\r\n if operational_layer['popupInfo']:\r\n operational_layer_popup = operational_layer['popupInfo']\r\n\r\n # registered feature layer\r\n else:\r\n # set popup info\r\n operational_layer.update(popupInfo=target_layer['popupInfo'])\r\n operational_layer_popup = operational_layer['popupInfo']\r\n\r\n # set title for popup\r\n operational_layer_popup['title'] = layer_name\r\n\r\n # set description for popup\r\n layer_popup_description = customize_popup_description(\r\n operational_layer=operational_layer,\r\n map_service_type=map_service_type\r\n )\r\n operational_layer_popup['description'] = layer_popup_description\r\n\r\n # set decimal places and digit separators for numeric fields\r\n for field in operational_layer_popup['fieldInfos']:\r\n for fld in target_layer.properties.fields:\r\n # double\r\n if field['fieldName'] == fld.name and fld.type == \"esriFieldTypeDouble\":\r\n field.update({\"format\": {\"places\": 2, \"digitSeparator\": False}})\r\n # integer\r\n elif field['fieldName'] == fld.name and fld.type == \"esriFieldTypeInteger\":\r\n field.update({\"format\": {\"places\": 0, \"digitSeparator\": False}})\r\n\r\n print('customizing popup for', operational_layer['title'])","def test_alien_data(self):","def output_grid_information():\n # translate = [-74.26, 40.50]\n # scale = [0.02, 0.02]\n # step = 1\n\n translate = [0, 0]\n scale = [1, 1]\n step = 0.02\n\n lon_limits = [(-74.26 - translate[0]) / scale[0], (-73.76 - translate[0]) / scale[0]]\n lat_limits = [(40.48 - translate[1]) / scale[1], (40.94 - translate[1]) / scale[1]]\n\n lons = np.arange(lon_limits[0], lon_limits[1] - step, step)\n lats = np.arange(lat_limits[0], lat_limits[1] - step, step)\n\n all_json = {\n \"type\": \"FeatureCollection\"\n }\n\n gr_id = 0\n grid_df = pd.DataFrame(columns=['gr_id', 'c_lat', 'c_lon', 's_lon', 'w_lat', 'n_lon', 'e_lat'])\n features = []\n\n for lat in lats:\n for lon in lons:\n w_lon = lon\n e_lon = lon + step\n s_lat = lat\n n_lat = lat + step\n\n c_lon = lon + step / 2\n c_lat = lat + step / 2\n\n grid_df = grid_df.append(pd.DataFrame({\"gr_id\": [gr_id],\n \"c_lon\": [c_lon], \"c_lat\": [c_lat],\n \"w_lon\": [w_lon], \"s_lat\": [s_lat],\n \"e_lon\": [e_lon], \"n_lat\": [n_lat]}))\n\n coor = [[[s_lat, w_lon], [n_lat, w_lon], [n_lat, e_lon],\n [s_lat, e_lon], [s_lat, w_lon]]]\n\n feature = {\n \"type\": \"Feature\",\n \"geometry\": {\n \"type\": \"Polygon\",\n \"coordinates\": coor\n },\n \"properties\": {\n \"id\": str(gr_id)\n }\n }\n\n features.append(feature)\n\n gr_id += 1\n\n all_json['features'] = features\n\n with open(BaseDir + '/grid.geojson', 'w') as f:\n json.dump(all_json, f)\n\n grid_df.to_csv(BaseDir + '/grid_locs.csv', index=False)","def testGetActiveVectorLayer(self):\r\n #check when no layers are loaded that an exception is thrown\r\n myExceptionFlag = False\r\n myLayer = None\r\n try:\r\n myLayer = self.bucketFill.getActiveVectorLayer()\r\n except:\r\n #good we expect an error!\r\n myExceptionFlag = True\r\n myMessage = ('Expected an exception to be raised when no layer'\r\n 'is present, but none was received.')\r\n assert myExceptionFlag == True, myMessage\r\n\r\n # Now test that when a layer is loaded that we get\r\n # the expected response\r\n loadLayers()\r\n CANVAS.zoomToFullExtent()\r\n try:\r\n myLayer = self.bucketFill.getActiveVectorLayer()\r\n except:\r\n myErrorMessage = 'Layer could not be identified as a vector.'\r\n assert myLayer.isValid(), myErrorMessage","def run_script(iface):\n layer = QgsVectorLayer('Polygon?crs=epsg:4326', 'Mississippi' , \"memory\")\n pr = layer.dataProvider()\n poly = QgsFeature()\n geom = QgsGeometry.fromWkt(\"\"\"POLYGON ((-88.82 34.99,\n -88.09 34.89,\n -88.39 30.34,\n -89.57 30.18,\n -89.73 31,\n -91.63 30.99,\n -90.87 32.37,\n -91.23 33.44,\n -90.93 34.23,\n -90.30 34.99,\n -88.82 34.99))\"\"\")\n poly.setGeometry(geom)\n pr.addFeatures([poly])\n layer.updateExtents()\n QgsMapLayerRegistry.instance().addMapLayers([layer])","def home(request):\n gefs_layers,geoserver_wms_url,geoserver_workspace = listLayers()\n\n context = {\n 'gefs_layers':json.dumps(gefs_layers),\n 'geoserver_wms_url':geoserver_wms_url,\n 'geoserver_workspace':geoserver_workspace\n }\n\n return render(request, 'gefs/home.html', context)","def test_api_msa_endpoint(self):\n params = {'lender': '90000451965', 'metro': '49180'}\n url = reverse(msa)\n resp = self.client.get(url, params)\n result_dict = json.loads(resp.content)\n self.assertTrue(isinstance(result_dict, dict))\n self.assertContains(resp, 'features')","def testGetLayerInfo(self):\n container_obj = self.explorer_object.GetContainer(\n 'de44dd97cfd1c8d1c1aad7f75a435603991a7a39fa4f6b20a69bf4458809209c')\n layer_info = container_obj.GetLayerInfo(\n '1cee97b18f87b5fa91633db35f587e2c65c093facfa2cbbe83d5ebe06e1d9125')\n self.assertEqual('2018-12-26T08:20:42.831353376Z', layer_info['created'])\n self.assertEqual(['/bin/sh', '-c', '#(nop) ', 'CMD [\"sh\"]'],\n layer_info['container_config']['Cmd'])","def get_test_ODs() -> List[dict]:\n ods = gpd.read_file('data/tests/test_OD_lines.geojson')\n ods['orig_point'] = [geom.interpolate(0, normalized=True) for geom in ods['geometry']]\n ods['dest_point'] = [geom.interpolate(1, normalized=True) for geom in ods['geometry']]\n ods['orig_latLon'] = [get_lat_lon_from_geom(geom) for geom in ods['orig_point']]\n ods['dest_latLon'] = [get_lat_lon_from_geom(geom) for geom in ods['dest_point']]\n od_dicts = ods.to_dict(orient='records')\n od_dict = {}\n for od in od_dicts:\n od_dict[int(od['OD'])] = od\n return od_dict","def test_get_work_from_edition_data(self):\n data = {\"works\": [{\"key\": \"/work/OL1234W\"}]}\n responses.add(\n responses.GET,\n \"https://openlibrary.org/work/OL1234W\",\n json={\"hi\": \"there\"},\n status=200,\n )\n result = self.connector.get_work_from_edition_data(data)\n self.assertEqual(result, {\"hi\": \"there\"})","def test_get_clouds(self):\n pass","def zonal_stats(src_poly, src_raster, operator=['mean'], features=None):\n assert src_raster.geo_transform is not None, \"src_raster.geo_transform should not be None\"\n assert isinstance(operator, list), \"operator should be a list of string. ex: ['mean']\"\n features = list(range(src_raster.bands)) if features is None else features\n assert len(features) == src_raster.bands, \"length of features should equals number of bands of the raster\"\n df_shp = src_poly.copy()\n df_shp['poly_idx'] = list(range(len(df_shp)))\n df_shp['poly_idx'] = df_shp['poly_idx'].astype('float')\n poly_rst = tgp.ShapeGrid.rasterize_layer(df_shp, src_raster.rows, src_raster.cols, src_raster.geo_transform, 'poly_idx', all_touched=True, no_data_value=np.nan)\n X_combine = np.concatenate([poly_rst.data, src_raster.data], axis=-1)\n X_combine_df = pd.DataFrame(X_combine.reshape(-1, src_raster.bands))\n X_groupby = X_combine_df.groupby(0, as_index=False)\n for op in operator:\n columns = {0:'poly_idx'}\n for f_idx, f in enumerate(features):\n columns[f_idx+1] = f'zonal_{op}_{f}'\n if op == 'mean':\n df_shp = df_shp.merge(X_groupby.mean().rename(columns=columns), on='poly_idx', how='left')\n elif op == 'max':\n df_shp = df_shp.merge(X_groupby.max().rename(columns=columns), on='poly_idx', how='left')\n elif op == 'min':\n df_shp = df_shp.merge(X_groupby.min().rename(columns=columns), on='poly_idx', how='left')\n elif op == 'median':\n df_shp = df_shp.merge(X_groupby.median().rename(columns=columns), on='poly_idx', how='left')\n elif op == 'sum':\n df_shp = df_shp.merge(X_groupby.sum().rename(columns=columns), on='poly_idx', how='left')\n elif op == 'std':\n df_shp = df_shp.merge(X_groupby.std().rename(columns=columns), on='poly_idx', how='left')\n elif op == 'count':\n df_shp = df_shp.merge(X_groupby.count().rename(columns=columns), on='poly_idx', how='left')\n else:\n assert False, \"no this operator\"\n return df_shp","def test_simple_pass():\n m = view(nybb)\n m = view(world)\n m = view(cities)\n m = view(world.geometry)","def maya_useNewAPI():\n\n pass","def SetUpLayerManager(self):\n pass","def define_map(window=False, toolbar=False, config=None):\n\n if not config:\n config = gis.get_config()\n\n if not deployment_settings.get_security_map() or s3_has_role(\"MapAdmin\"):\n catalogue_toolbar = True\n else:\n catalogue_toolbar = False\n\n # @ToDo: Make these configurable\n search = True\n catalogue_overlays = True\n\n if config.wmsbrowser_url:\n wms_browser = {\"name\" : config.wmsbrowser_name,\n \"url\" : config.wmsbrowser_url}\n else:\n wms_browser = None\n\n # 'normal', 'mgrs' or 'off'\n mouse_position = deployment_settings.get_gis_mouse_position()\n\n # http://eden.sahanafoundation.org/wiki/BluePrintGISPrinting\n print_service = deployment_settings.get_gis_print_service()\n if print_service:\n print_tool = {\"url\": print_service}\n else:\n print_tool = {}\n\n # Internal Feature Layers\n feature_queries = []\n feature_layers = db(db.gis_layer_feature.enabled == True).select()\n for layer in feature_layers:\n if layer.role_required and not auth.s3_has_role(layer.role_required):\n # Skip layer is it i srestricted & we don't have the required role\n continue\n if layer.filter_field and layer.filter_value:\n table = db[\"%s_%s\" % (layer.module, layer.resource)]\n # Check for multiples\n filter_values = layer.filter_value.split(\"/\")\n if len(filter_values) == 1:\n _filter = (table[layer.filter_field] == filter_values[0])\n else:\n null = False\n for i in range(len(filter_values)):\n if filter_values[i] == \"\":\n # Catch NULLs\n null = True\n if null:\n _filter = ((table[layer.filter_field].belongs(filter_values)) | \\\n (table[layer.filter_field] == None))\n else:\n _filter = (table[layer.filter_field].belongs(filter_values))\n\n else:\n _filter = None\n _layer = gis.get_feature_layer(layer.module,\n layer.resource,\n layer.name,\n layer.popup_label,\n config=config,\n marker_id=layer.marker_id,\n _filter=_filter,\n active=layer.visible,\n polygons=layer.polygons,\n opacity=layer.opacity)\n if _layer:\n feature_queries.append(_layer)\n\n map = gis.show_map(\n window=window,\n catalogue_toolbar=catalogue_toolbar,\n wms_browser = wms_browser,\n toolbar=toolbar,\n search=search,\n catalogue_overlays=catalogue_overlays,\n feature_queries=feature_queries,\n mouse_position = mouse_position,\n print_tool = print_tool\n )\n\n return map","def get_feature_layers_collection(project_name):\r\n feature_layers_collection = get_portal_item(\r\n portal_connection=PORTAL_CONNECTION,\r\n item_name=\"{}_Map\".format(project_name),\r\n item_type=\"Feature Layer\"\r\n )\r\n\r\n return feature_layers_collection","def test_path_layer_cache(self):\n cache = caches[settings.MAPENTITY_CONFIG['GEOJSON_LAYERS_CACHE_BACKEND']]\n\n obj = self.modelfactory(draft=False)\n self.modelfactory(draft=True)\n\n # There are 7 queries to get layer without drafts\n with self.assertNumQueries(5):\n response = self.client.get(obj.get_layer_url())\n self.assertEqual(len(response.json()['features']), 2)\n\n # We check the content was created and cached without no_draft key\n # We check that any cached content can be found without no_draft (we still didn't ask for it)\n last_update_no_draft = Path.no_draft_latest_updated()\n last_update = Path.latest_updated()\n geojson_lookup_no_draft = 'en_path_%s_nodraft_json_layer' % last_update_no_draft.strftime('%y%m%d%H%M%S%f')\n geojson_lookup = 'en_path_%s_json_layer' % last_update.strftime('%y%m%d%H%M%S%f')\n content_no_draft = cache.get(geojson_lookup_no_draft)\n content = cache.get(geojson_lookup)\n\n self.assertIsNone(content_no_draft)\n self.assertEqual(response.content, content.content)\n\n # We have 1 less query because the generation of paths was cached\n with self.assertNumQueries(3):\n self.client.get(obj.get_layer_url())\n\n self.modelfactory(draft=True)\n\n # Cache is updated when we add a draft path\n with self.assertNumQueries(5):\n self.client.get(obj.get_layer_url())\n\n self.modelfactory(draft=False)\n\n # Cache is updated when we add a path\n with self.assertNumQueries(5):\n self.client.get(obj.get_layer_url())","def add_geojson(map, geojson, style_function, name='states' ):\n\n folium.GeoJson(\n geojson,\n name=name,\n style_function=style_function\n ).add_to(map)","def maya_useNewAPI():\r\n\r\n pass","def test_render_world_map():\n gdpinfo = gdpinfo_dict()\n codeinfo = codeinfo_dict()\n pygal_countries = pygal_country_dict()\n\n # 1960\n render_world_map(gdpinfo, codeinfo, pygal_countries, \"1960\", \"isp_gdp_world_code_1960.svg\")\n\n # 1980\n render_world_map(gdpinfo, codeinfo, pygal_countries, \"1980\", \"isp_gdp_world_code_1980.svg\")\n\n # 2000\n render_world_map(gdpinfo, codeinfo, pygal_countries, \"2000\", \"isp_gdp_world_code_2000.svg\")\n\n # 2010\n render_world_map(gdpinfo, codeinfo, pygal_countries, \"2010\", \"isp_gdp_world_code_2010.svg\")","def testGetLayerInfo(self):\n container_obj = self.explorer_object.GetContainer(\n '7b02fb3e8a665a63e32b909af5babb7d6ba0b64e10003b2d9534c7d5f2af8966')\n layer_info = container_obj.GetLayerInfo(\n 'sha256:'\n '7968321274dc6b6171697c33df7815310468e694ac5be0ec03ff053bb135e768')\n self.assertEqual('2017-01-13T22:13:54.401355854Z', layer_info['created'])\n self.assertEqual(['/bin/sh', '-c', '#(nop) ', 'CMD [\"sh\"]'],\n layer_info['container_config']['Cmd'])","def test_ExtractOverlaysSmoke(self):\n stage = self.ConstructStage()\n self.assertEqual(stage._ExtractOverlays(), ([], []))","def test_incomplete_polygons():\n assert not query_row(db_conf, 'osm_landusages', 30004)\n assert not query_row(db_conf, 'osm_landusages', 30006)","def folium_map(geojson_to_overlay, layer_name, location, style_function=None, tiles='Stamen Terrain', zoom_start=16,\n show_layer_control=True, width='100%', height='75%', attr=None, map_zoom=18, max_zoom=20, tms=False,\n zoom_beyond_max=None, base_tiles='OpenStreetMap', opacity=1):\n\n m = folium.Map(location=location, zoom_start=zoom_start, width=width, height=height, max_zoom=map_zoom,\n tiles=base_tiles)\n tiles = folium.TileLayer(tiles=tiles, attr=attr, name=attr, max_zoom=max_zoom)\n if tms is True:\n options = json.loads(tiles.options)\n options.update({'tms': True})\n tiles.options = json.dumps(options, sort_keys=True, indent=2)\n tiles._template = jinja2.Template(u\"\"\"\n {% macro script(this, kwargs) %}\n var {{this.get_name()}} = L.tileLayer(\n '{{this.tiles}}',\n {{ this.options }}\n ).addTo({{this._parent.get_name()}});\n {% endmacro %}\n \"\"\")\n if zoom_beyond_max is not None:\n options = json.loads(tiles.options)\n options.update({'maxNativeZoom': zoom_beyond_max, 'maxZoom': max_zoom})\n tiles.options = json.dumps(options, sort_keys=True, indent=2)\n tiles._template = jinja2.Template(u\"\"\"\n {% macro script(this, kwargs) %}\n var {{this.get_name()}} = L.tileLayer(\n '{{this.tiles}}',\n {{ this.options }}\n ).addTo({{this._parent.get_name()}});\n {% endmacro %}\n \"\"\")\n if opacity < 1:\n options = json.loads(tiles.options)\n options.update({'opacity': opacity})\n tiles.options = json.dumps(options, sort_keys=True, indent=2)\n tiles._template = jinja2.Template(u\"\"\"\n {% macro script(this, kwargs) %}\n var {{this.get_name()}} = L.tileLayer(\n '{{this.tiles}}',\n {{ this.options }}\n ).addTo({{this._parent.get_name()}});\n {% endmacro %}\n \"\"\")\n\n tiles.add_to(m)\n if style_function is not None:\n gj = folium.GeoJson(geojson_to_overlay, overlay=True, name=layer_name, style_function=style_function)\n else:\n gj = folium.GeoJson(geojson_to_overlay, overlay=True, name=layer_name)\n gj.add_to(m)\n\n if show_layer_control is True:\n folium.LayerControl().add_to(m)\n\n return m","def test_viewset_list_filter(self):\n # valid coordinate within a zone\n data = {\"coords\": \"55.710663495702725/9.52840811021021\"}\n response = self.client.get(reverse(\"servicearea-list\"), data, format='json')\n\n # we should get a http 200 and the zone\n self.assertEqual(response.status_code, 200)\n self.assertEqual(len(response.json()['features']), 1)\n\n # valid coordinate but outside the zone\n data = {\"coords\": \"55.71/22.52\"}\n response = self.client.get(reverse(\"servicearea-list\"), data, format='json')\n self.assertEqual(response.status_code, 200)\n self.assertEqual(len(response.json()['features']), 0)\n\n # invalid coordinate format\n data = {\"coords\": \"test\"}\n response = self.client.get(reverse(\"servicearea-list\"), data, format='json')\n self.assertEqual(response.status_code, 200)\n self.assertEqual(len(response.json()['features']), 0)\n\n # invalid coordinate format\n data = {\"coords\": \"lng/lat\"}\n response = self.client.get(reverse(\"servicearea-list\"), data, format='json')\n self.assertEqual(response.status_code, 200)\n self.assertEqual(len(response.json()['features']), 0)\n\n\n # invalid coordinate format\n data = {\"coords\": 1}\n response = self.client.get(reverse(\"servicearea-list\"), data, format='json')\n self.assertEqual(response.status_code, 200)\n self.assertEqual(len(response.json()['features']), 0)","def test_request_twms_legacy_nodate_from_year_layer(self):\n ref_hash = 'fd81999878be17f66c28b18c3cce3179'\n req_url = r'http://localhost/reproject/test/twms/twms.cgi?request=GetMap&layers=test_legacy_subdaily_jpg&srs=EPSG:3857&format=image%2Fjpeg&styles=&width=256&height=256&bbox=-20037508.34278925,-20037508.34278925,20037508.34278925,20037508.34278925'\n if DEBUG:\n print('\\nERROR!!! Testing: Request tile with no date and time (legacy sub-daily) from \"year\" layer via TWMS')\n print('URL: ' + req_url)\n check_result = check_tile_request(req_url, ref_hash)\n self.assertTrue(check_result, 'TWMS legacy no date and time subdaily request does not match what\\'s expected. URL: ' + req_url)\n\n# def test_request_wmts_nodate_year_zlevel(self):\n \"\"\"\n 17. Request tile with no date and time (z-level) from \"year\" layer via WMTS\n \"\"\"\n# ref_hash = '36bb79a33dbbe6173990103a8d6b67cb'\n# req_url = r'http://localhost/reproject/test/wmts/wmts.cgi?layer=test_zindex_jpg&tilematrixset=GoogleMapsCompatible_Level3&Service=WMTS&Request=GetTile&Version=1.0.0&Format=image%2Fjpeg&TileMatrix=0&TileCol=0&TileRow=0'\n# check_result = check_tile_request(req_url, ref_hash)\n# self.assertTrue(check_result, 'WMTS Z-Level JPG Tile Request does not match what\\'s expected. URL: ' + req_url)\n\n# def test_request_wmts_rest_nodate_year_zlevel(self):\n \"\"\"\n 17B. Request tile with no date and time (z-level) from \"year\" layer via WMTS (REST)\n \"\"\"\n# ref_hash = '36bb79a33dbbe6173990103a8d6b67cb'\n# req_url = r'http://localhost/reproject/test/wmts/test_zindex_jpg/default/GoogleMapsCompatible_Level3/0/0/0.jpeg'\n# check_result = check_tile_request(req_url, ref_hash)\n# self.assertTrue(check_result, 'WMTS (REST) Z-Level JPG Tile Request does not match what\\'s expected. URL: ' + req_url)\n\n# def test_request_twms_nodate_year_zlevel(self):\n \"\"\"\n 17C. Request tile with no date and time (z-level) from \"year\" layer via TWMS\n \"\"\"","def maya_useNewAPI():\n pass","def maya_useNewAPI():\n pass","def maya_useNewAPI():\n pass","def maya_useNewAPI():\n pass","def maya_useNewAPI():\n pass","def get_geojson_potholes(active=True, date=None):\n potholes = VwPothole.objects.all() if date is None \\\n else VwPothole.objects.raw(vw_pothole_by_date, {'datetime': '{} 23:59:59'.format(date)})\n\n pothole_features = [Feature(\n geometry=Point((float(pothole.lon), float(pothole.lat)), precision=8),\n id=pothole.id,\n properties={\"pothole_reports\": int(pothole.pothole_reports),\n \"fixed_reports\": int(pothole.fixed_reports),\n \"create_date\": str(pothole.create_date),\n \"effective_date\": str(pothole.effective_date),\n \"active\": pothole.effective_date is not None\n and convert_timestamp(pothole.effective_date) < datetime.utcnow()\n and convert_timestamp(pothole.fixed_date) > datetime.utcnow(),\n \"fixed_date\": str(pothole.fixed_date),\n \"fixed\": pothole.fixed_date and convert_timestamp(pothole.fixed_date) < datetime.utcnow(),\n \"severity\": str(('%f' % round(pothole.avg_severity, 2)).rstrip('.0')),\n \"utcnow\": str(datetime.utcnow())\n })\n for pothole in potholes\n # filter according to whether active is true\n if (active\n and pothole.effective_date is not None\n and convert_timestamp(pothole.fixed_date) > datetime.utcnow()\n and convert_timestamp(pothole.effective_date) < datetime.utcnow())\n or not active]\n\n pothole_collection = FeatureCollection(pothole_features)\n return dumps(pothole_collection)","def create_map(model1, model2=None, bbox=None, crs=None, filename=None,\n subset=None, return_data=False):\n\n import geojson\n from geojson import Point, LineString, Feature, GeometryCollection, FeatureCollection\n try: import pyproj\n except ImportError:\n raise ImportError('pyproj module needed. get this package here: ',\n 'https://pypi.python.org/pypi/pyproj')\n\n\n if model2 is not None:\n changes = INPDiff(model1, model2, section='[CONDUITS]')\n df = pd.concat([changes.added, changes.altered])\n subset = df.index.tolist()\n\n # else:\n # model2 = model1 #stupid, for file path\n\n\n if crs is None:\n #default coordinate system (http://spatialreference.org/ref/epsg/2272/):\n #NAD_1983_StatePlane_Pennsylvania_South_FIPS_3702_Feet\n crs = {\"type\": \"name\",\"properties\": {\"name\": \"EPSG:2272\"}}\n\n pa_plane = pyproj.Proj(init='epsg:2272', preserve_units=True)\n wgs = pyproj.Proj(proj='latlong', datum='WGS84', ellps='WGS84') #google maps, etc\n\n\n geometries = [] #array of features\n #collect the links\n for k,v in list(model2.list_objects('conduit', bbox, subset=subset).items()):\n props = {\n 'MaxQPercent':v.maxQpercent,\n 'id':v.id,\n 'lifecycle':v.lifecycle,\n 'geom1':v.geom1,\n 'geom2':v.geom2,\n }\n\n latlngs = [pyproj.transform(pa_plane, wgs, *xy) for xy in v.coordinates]\n geometry = LineString(latlngs, properties=props)\n geometries.append(geometry)\n\n\n if return_data is True:\n return FeatureCollection(geometries, crs=crs)\n\n if filename is None:\n filename = os.path.join(model2.inp.dir,\n REPORT_DIR_NAME,\n model2.name + '.html')\n\n #start writing that thing\n with open(BASEMAP_PATH, 'r') as bm:\n with open(filename, 'wb') as newmap:\n for line in bm:\n if 'SWMMIO DUMP JSON DATA HERE' in line:\n newmap.write('data = ')\n newmap.write(geojson.dumps(FeatureCollection(geometries, crs=crs)))\n else:\n newmap.write(line)","def test_build(self):\n mapdatas = self.grid.maps_from_module(\"evennia.contrib.grid.xyzgrid.example\")\n self.assertEqual(len(mapdatas), 2)\n\n self.grid.add_maps(*mapdatas)\n self.grid.spawn()\n\n # testing\n room1a = xyzroom.XYZRoom.objects.get_xyz(xyz=(3, 0, \"the large tree\"))\n room1b = xyzroom.XYZRoom.objects.get_xyz(xyz=(10, 8, \"the large tree\"))\n room2a = xyzroom.XYZRoom.objects.get_xyz(xyz=(1, 0, \"the small cave\"))\n room2b = xyzroom.XYZRoom.objects.get_xyz(xyz=(1, 3, \"the small cave\"))\n\n self.assertEqual(room1a.key, \"Dungeon Entrance\")\n self.assertTrue(room1a.db.desc.startswith(\"To the east\"))\n self.assertEqual(room1b.key, \"A gorgeous view\")\n self.assertTrue(room1b.db.desc.startswith(\"The view from here is breathtaking,\"))\n self.assertEqual(room2a.key, \"The entrance\")\n self.assertTrue(room2a.db.desc.startswith(\"This is the entrance to\"))\n self.assertEqual(room2b.key, \"North-west corner of the atrium\")\n self.assertTrue(room2b.db.desc.startswith(\"Sunlight sifts down\"))","def check_feature(feature, expected_name='Adriatic Sea',\n expected_type='Polygon'):\n assert feature['properties']['name'] == expected_name\n assert feature['properties']['component'] == 'ocean'\n assert feature['geometry']['type'] == expected_type","def test_reading_and_writing_of_vector_polygon_data(self):\n\n # Read and verify test data\n vectorname = 'kecamatan_jakarta_osm.shp'\n\n filename = '%s/%s' % (TESTDATA, vectorname)\n layer = read_layer(filename)\n geometry = layer.get_geometry()\n attributes = layer.get_data()\n\n assert layer.is_polygon_data\n\n # Check basic data integrity\n N = len(layer)\n\n assert len(geometry) == N\n assert len(attributes) == N\n assert len(attributes[0]) == 2\n\n assert FEATURE_COUNTS[vectorname] == N\n assert isinstance(layer.get_name(), basestring)\n\n # Check projection\n wkt = layer.get_projection(proj4=False)\n assert wkt.startswith('GEOGCS')\n\n assert layer.projection == Projection(DEFAULT_PROJECTION)\n\n # Check each polygon\n for i in range(N):\n geom = geometry[i]\n n = geom.shape[0]\n assert n >= 2\n assert geom.shape[1] == 2\n\n # Check that polygon is closed\n assert numpy.allclose(geom[0], geom[-1], rtol=0)\n\n # But that not all points are the same\n max_dist = 0\n for j in range(n):\n d = numpy.sum((geom[j] - geom[0]) ** 2) / n\n if d > max_dist:\n max_dist = d\n assert max_dist > 0\n\n # Check integrity of each feature\n expected_features = {13: {'KAB_NAME': 'JAKARTA PUSAT',\n 'KEC_NAME': 'SAWAH BESAR'},\n 20: {'KAB_NAME': 'JAKARTA SELATAN',\n 'KEC_NAME': 'MAMPANG PRAPATAN'}}\n\n for i in range(N):\n # Consistency with attributes read manually with qgis\n\n if i in expected_features:\n att = attributes[i]\n exp = expected_features[i]\n\n for key in exp:\n msg = ('Expected attribute %s was not found in feature %i'\n % (key, i))\n assert key in att, msg\n\n a = att[key]\n e = exp[key]\n msg = 'Got %s: \"%s\" but expected \"%s\"' % (key, a, e)\n assert a == e, msg\n\n # Write data back to file\n # FIXME (Ole): I would like to use gml here, but OGR does not\n # store the spatial reference! Ticket #18\n out_filename = unique_filename(suffix='.shp')\n Vector(geometry=geometry, data=attributes, projection=wkt,\n geometry_type='polygon').write_to_file(out_filename)\n\n # Read again and check\n layer = read_layer(out_filename)\n assert layer.is_polygon_data\n geometry_new = layer.get_geometry()\n attributes_new = layer.get_data()\n\n N = len(layer)\n assert len(geometry_new) == N\n assert len(attributes_new) == N\n\n for i in range(N):\n assert numpy.allclose(geometry[i],\n geometry_new[i],\n rtol=1.0e-6) # OGR works in single precision\n\n assert len(attributes_new[i]) == 2\n for key in attributes_new[i]:\n assert attributes_new[i][key] == attributes[i][key]","def run(self):\n if self.is_complete:\n LOG.debug(\"Skipping Geopackage, file exists\")\n return\n keys_points = self.feature_selection.key_union('points')\n keys_lines = self.feature_selection.key_union('lines')\n keys_polygons = self.feature_selection.key_union('polygons')\n osmconf = OSMConfig(self.stage_dir,points=keys_points,lines=keys_lines,polygons=keys_polygons)\n conf = osmconf.create_osm_conf()\n ogr_cmd = self.ogr_cmd.safe_substitute({'gpkg': self.output_gpkg,\n 'osm': self.input_pbf, 'osmconf': conf})\n LOG.debug('Running: %s' % ogr_cmd)\n subprocess.check_call(ogr_cmd, shell=True, executable='/bin/bash')\n\n \"\"\"\n Create the default osm gpkg schema\n \"\"\"\n conn = sqlite3.connect(self.output_gpkg)\n conn.enable_load_extension(True)\n cur = conn.cursor()\n cur.execute(\"select load_extension('mod_spatialite')\")\n cur.execute(\"CREATE TABLE boundary (id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, geom GEOMETRY)\");\n cur.execute(\"INSERT INTO boundary (geom) VALUES (GeomFromWKB(?,4326));\",(self.aoi_geom.wkb,))\n cur.executescript(SPATIAL_SQL)\n self.update_zindexes(cur,self.feature_selection)\n\n # add themes\n create_sqls, index_sqls = self.feature_selection.sqls\n for query in create_sqls:\n cur.executescript(query)\n for query in index_sqls:\n cur.executescript(query)\n conn.commit()\n conn.close()\n\n if self.per_theme:\n # this creates per-theme GPKGs\n for theme in self.feature_selection.themes:\n conn = sqlite3.connect(self.stage_dir + slugify(theme) + \".gpkg\")\n conn.enable_load_extension(True)\n cur = conn.cursor()\n cur.execute(\"attach database ? as 'geopackage'\",(self.output_gpkg,))\n cur.execute(\"create table gpkg_spatial_ref_sys as select * from geopackage.gpkg_spatial_ref_sys\")\n cur.execute(\"create table gpkg_contents as select * from geopackage.gpkg_contents where 0\")\n cur.execute(\"create table gpkg_geometry_columns as select * from geopackage.gpkg_geometry_columns where 0\")\n for geom_type in self.feature_selection.geom_types(theme):\n for stmt in self.feature_selection.create_sql(theme,geom_type):\n cur.executescript(stmt)\n conn.commit()\n conn.close()","def testGetLayerInfo(self):\n container_obj = self.explorer_object.GetContainer(\n '5dc287aa80b460652a5584e80a5c8c1233b0c0691972d75424cf5250b917600a')\n layer_info = container_obj.GetLayerInfo(\n 'sha256:'\n '5b0d59026729b68570d99bc4f3f7c31a2e4f2a5736435641565d93e7c25bd2c3')\n self.assertEqual('2018-01-24T04:29:35.590938514Z', layer_info['created'])\n self.assertEqual(['/bin/sh', '-c', '#(nop) ', 'CMD [\"sh\"]'],\n layer_info['container_config']['Cmd'])","def testGetLayerInfo(self):\n container_obj = self.explorer_object.GetContainer(\n '8e8b7f23eb7cbd4dfe7e91646ddd0e0f524218e25d50113559f078dfb2690206')\n layer_info = container_obj.GetLayerInfo(\n 'sha256:'\n '8ac48589692a53a9b8c2d1ceaa6b402665aa7fe667ba51ccc03002300856d8c7')\n self.assertEqual('2018-04-05T10:41:28.876407948Z', layer_info['created'])\n self.assertEqual(['/bin/sh', '-c', '#(nop) ', 'CMD [\"sh\"]'],\n layer_info['container_config']['Cmd'])","def crossWalkGeoBlacklight(data):\n\n dataJsonObj=deep_get(data,\"xml.fgdc\",[])\n if len (dataJsonObj)>0:\n dataJsonObj=deep_get(dataJsonObj[0],\"data\",{})\n else:\n dataJsonObj={}\n layername=os.path.splitext(os.path.basename(data['file']))[0]\n geoserver_layername = data['geoserverStoreName']\n gblight = assignMetaDataComponents(dataJsonObj,layername,geoserver_layername,data[\"resource_type\"])\n gblight['solr_geom']=data['bounds']\n data['geoblacklightschema']=gblight\n return data","def testGetPointsGeodesic(self):\n\n for i in range(10):\n self.basicGetPointsGeodesic()","def run(layers):","def test_reading_and_writing_of_vector_point_data(self):\n\n # First test that some error conditions are caught\n filename = unique_filename(suffix='nshoe66u')\n try:\n read_layer(filename)\n except ReadLayerError:\n pass\n else:\n msg = 'Exception for unknown extension should have been raised'\n raise Exception(msg)\n\n filename = unique_filename(suffix='.gml')\n try:\n read_layer(filename)\n except ReadLayerError:\n pass\n else:\n msg = 'Exception for non-existing file should have been raised'\n raise Exception(msg)\n\n # Read and verify test data\n for vectorname in ['test_buildings.shp',\n 'tsunami_building_exposure.shp',\n 'Padang_WGS84.shp',\n ]:\n\n filename = '%s/%s' % (TESTDATA, vectorname)\n layer = read_layer(filename)\n coords = numpy.array(layer.get_geometry())\n attributes = layer.get_data()\n\n # Check basic data integrity\n N = len(layer)\n assert coords.shape[0] == N\n assert coords.shape[1] == 2\n\n assert FEATURE_COUNTS[vectorname] == N\n\n assert isinstance(layer.get_name(), basestring)\n\n # Check projection\n wkt = layer.get_projection(proj4=False)\n assert wkt.startswith('GEOGCS')\n\n assert layer.projection == Projection(DEFAULT_PROJECTION)\n\n # Check integrity of each feature\n field_names = None\n for i in range(N):\n # Consistency between of geometry and fields\n\n x1 = coords[i, 0]\n x2 = attributes[i]['LONGITUDE']\n assert x2 is not None\n msg = 'Inconsistent longitudes: %f != %f' % (x1, x2)\n assert numpy.allclose(x1, x2), msg\n\n x1 = coords[i, 1]\n x2 = attributes[i]['LATITUDE']\n assert x2 is not None\n msg = 'Inconsistent longitudes: %f != %f' % (x1, x2)\n assert numpy.allclose(x1, x2), msg\n\n # Verify that each feature has the same fields\n if field_names is None:\n field_names = attributes[i].keys()\n else:\n assert len(field_names) == len(attributes[i].keys())\n assert field_names == attributes[i].keys()\n\n # Write data back to file\n # FIXME (Ole): I would like to use gml here, but OGR does not\n # store the spatial reference! Ticket #18\n out_filename = unique_filename(suffix='.shp')\n Vector(geometry=coords, data=attributes, projection=wkt,\n geometry_type='point').write_to_file(out_filename)\n\n # Read again and check\n layer = read_layer(out_filename)\n assert layer.is_point_data\n coords = numpy.array(layer.get_geometry())\n attributes = layer.get_data()\n\n # Check basic data integrity\n N = len(layer)\n assert coords.shape[0] == N\n assert coords.shape[1] == 2\n\n # Check projection\n assert layer.projection == Projection(DEFAULT_PROJECTION)\n\n # Check integrity of each feature\n field_names = None\n for i in range(N):\n\n # Consistency between of geometry and fields\n x1 = coords[i, 0]\n x2 = attributes[i]['LONGITUDE']\n assert x2 is not None\n msg = 'Inconsistent longitudes: %f != %f' % (x1, x2)\n assert numpy.allclose(x1, x2), msg\n\n x1 = coords[i, 1]\n x2 = attributes[i]['LATITUDE']\n assert x2 is not None\n msg = 'Inconsistent longitudes: %f != %f' % (x1, x2)\n assert numpy.allclose(x1, x2), msg\n\n # Verify that each feature has the same fields\n if field_names is None:\n field_names = attributes[i].keys()\n else:\n assert len(field_names) == len(attributes[i].keys())\n assert field_names == attributes[i].keys()\n\n # Test individual extraction\n lon = layer.get_data(attribute='LONGITUDE')\n assert numpy.allclose(lon, coords[:, 0])","def test_request_twms_legacy_datetime_from_year_layer(self):\n ref_hash = 'fd4fe96d84e4f10e61029890293fa3c8'\n req_url = r'http://localhost/reproject/test/twms/twms.cgi?request=GetMap&layers=test_legacy_subdaily_jpg&srs=EPSG:3857&format=image%2Fjpeg&styles=&width=256&height=256&bbox=-20037508.34278925,-20037508.34278925,20037508.34278925,20037508.34278925&TIME=2012-02-29T12:00:00Z'\n if DEBUG:\n print('\\nTesting: Request tile with date and time (legacy sub-daily) from \"year\" layer via TWMS')\n print('URL: ' + req_url)\n check_result = check_tile_request(req_url, ref_hash)\n self.assertTrue(check_result, 'TWMS legacy subdaily request does not match what\\'s expected. URL: ' + req_url)\n\n# def test_request_wmts_year_zlevel(self):\n \"\"\"\n 13. Request tile with date and time (z-level) from \"year\" layer via WMTS\n \"\"\"\n# ref_hash = '36bb79a33dbbe6173990103a8d6b67cb'\n# req_url = r'http://localhost/reproject/test/wmts/wmts.cgi?layer=test_zindex_jpg&tilematrixset=GoogleMapsCompatible_Level3&Service=WMTS&Request=GetTile&Version=1.0.0&Format=image%2Fjpeg&TileMatrix=0&TileCol=0&TileRow=0&TIME=2012-02-29T16:00:00Z'\n# check_result = check_tile_request(req_url, ref_hash)\n# self.assertTrue(check_result, 'WMTS Z-Level JPG Tile Request does not match what\\'s expected. URL: ' + req_url)\n\n# def test_request_wmts_rest_year_zlevel(self):\n \"\"\"\n 13B. Request tile with date and time (z-level) from \"year\" layer via WMTS (REST)\n \"\"\"\n# ref_hash = '36bb79a33dbbe6173990103a8d6b67cb'\n# req_url = r'http://localhost/reproject/test/wmts/test_zindex_jpg/default/2012-02-29T16:00:00Z/GoogleMapsCompatible_Level3/0/0/0.jpeg'\n# check_result = check_tile_request(req_url, ref_hash)\n# self.assertTrue(check_result, 'WMTS (REST) Z-Level JPG Tile Request does not match what\\'s expected. URL: ' + req_url)\n\n# def test_request_twms_year_zlevel(self):\n \"\"\"\n 13C. Request tile with date and time (z-level) from \"year\" layer via TWMS\n \"\"\"","def test_query(config):\n\n p = PostgreSQLProvider(config)\n feature_collection = p.query()\n assert feature_collection.get('type', None) == 'FeatureCollection'\n features = feature_collection.get('features', None)\n assert features is not None\n feature = features[0]\n properties = feature.get('properties', None)\n assert properties is not None\n geometry = feature.get('geometry', None)\n assert geometry is not None","def testGetOrderedLayers(self):\n container_obj = self.explorer_object.GetContainer(\n 'de44dd97cfd1c8d1c1aad7f75a435603991a7a39fa4f6b20a69bf4458809209c')\n layers = container_obj.GetOrderedLayers()\n self.assertEqual(2, len(layers))\n self.assertEqual(\n '1cee97b18f87b5fa91633db35f587e2c65c093facfa2cbbe83d5ebe06e1d9125',\n layers[0])","def get_house_est(api_key, year = str(), map = bool()):\n try:\n house_url = f'http://api.census.gov/data/{year}/pep/housing?get=HUEST&for=state:*&key={api_key}'\n r = requests.get(house_url)\n data = json.loads(r.content) \n house_df = pd.DataFrame(data[1:], columns=data[0]).\\\n rename(columns={\"HUEST\": \"Housing_Estimates\", \"state\": \"STATEFP\"})\n house_df['Housing_Estimates'] = house_df['Housing_Estimates'].astype(str).astype(int)\n geodata_url = f\"https://raw.githubusercontent.com/uscensusbureau/citysdk/master/v2/GeoJSON/20m/{year}/state.json\"\n geo_df = gpd.read_file(geodata_url)\n geo_df = geo_df.merge(house_df, on = 'STATEFP')\n if map == True:\n return geo_df.plot(column = 'Housing_Estimates')\n else:\n return geo_df\n r.raise_for_status()\n except HTTPError as http_err:\n print(f'HTTP error occurred: {http_err}')\n except Exception as err:\n print(f'An error occured. All parameters must exist in the Census GeoJSON database and API. Please check https://github.com/uscensusbureau/citysdk/tree/master/v2/GeoJSON: {err}')","def test_open_api(self):\n response = self.client.get(self.initiatives_url)\n self.assertEqual(response.status_code, status.HTTP_200_OK)","def test_format_coordinates():\n # GIVEN\n bpolys = geojson.FeatureCollection([{\"type\": \"Feature\",\n \"geometry\": {\"coordinates\": [[[[13,51], [13,51.1], [13.1,51.1], [13.1,51], [13,51]],\n [[13,51], [14,51.1], [14.1,51.1], [14.1,51], [14,51]]]],\n \"type\": \"MultiPolygon\"}}])\n time = \"2018-01-01\"\n keys = [\"landuse\"]\n values = [\"grass\"]\n\n # WHEN\n client = ohsome.OhsomeClient()\n response = client.elements.geometry.post(bpolys=ohsome.format_coordinates(bpolys), time=time, keys=keys, values=values)\n result = response.as_geodataframe()\n del client\n\n # THEN\n assert len(result.geometry) == 74","def test_loading_layer_with_complex_linetype(self, sdoc):\n tdoc = ezdxf.new()\n loader = xref.Loader(sdoc, tdoc)\n loader.load_layers([\"second\"])\n loader.execute()\n assert document_has_no_errors(tdoc) is True\n\n layer = tdoc.layers.get(\"second\")\n assert layer.dxf.name == \"SECOND\", \"expected the original layer name\"\n\n # Test if required resources are loaded:\n ltype = tdoc.linetypes.get(layer.dxf.linetype)\n assert ltype.dxf.name == \"SQUARE\", \"expected linetype SQUARE in target doc\"\n assert tdoc.styles.find_shx(\"ltypeshp.shx\") is not None","def test_02_get_geometry_collection_details(self):\n geometry_collection = GeometryCollection(**self.test_data)\n geometry_collection.save()\n response = self.client.get('/api/v1/collection/%s/' % geometry_collection.pk)\n self.assertEqual(response.status_code, status.HTTP_200_OK)","def main():\n # IMPORTANT: Specify a path to the new shapefile!\n data_dir = os.path.join(\"C:\\\\\",\"Users\",\"janni\",\"OneDrive\",\"Desktop\",\"data\")\n\n #Store route identification codes in to a list\n L_tracks=['\"tag_ident\"=72413','\"tag_ident\"=72417','\"tag_ident\"=73053','\"tag_ident\"=72364',\\\n '\"tag_ident\"=73054','\"tag_ident\"=79694','\"tag_ident\"=79698']\n\n if(os.path.isdir(data_dir)):\n print(\"Very good! You have chosen a valid directory!\")\n # load the point shapefile of the white-fronted goose manually!\n # access the active layer\n point_layer = iface.activeLayer()\n if not point_layer:\n print(\"Shape file failed to load!\")\n else:\n # 1\n addTimeAndDateObs(point_layer)\n print(\"-----------Created Date and Time objects-------------\")\n # 2\n addDistance(point_layer, L_tracks)\n print(\"-----------Distances calculation finished-------------\")\n # 3\n extractPoints(point_layer,Statistics(point_layer),data_dir)\n print(\"-----------Low distance points extracted and save to a new shapefile-------------\")\n print('Done')\n\n raster_fn = os.path.join(data_dir,\"Eurasia_Landcover.tif\")\n landuse_legend_fn = os.path.join(data_dir,'Eurasia_Landcover_Legend.csv')\n in_shape_fn = os.path.join(data_dir,\"lowDistance.shp\")\n out_shape_fn = os.path.join(data_dir,\"lowDistanceLanduseID.shp\")\n\n\n if(QgsProject.instance().mapLayersByName('lowDistanceLanduseID')==[]):\n processing.run(\"qgis:rastersampling\",\n {'COLUMN_PREFIX' : 'LanduseNr_',\n 'INPUT' : in_shape_fn,\n 'OUTPUT' : out_shape_fn,\n 'RASTERCOPY' : raster_fn})\n updated_shapefile = iface.addVectorLayer(out_shape_fn, '', 'ogr')\n else:\n updated_shapefile = QgsProject.instance().mapLayersByName('lowDistanceLanduseID')[0]\n #2\n convertIdFloatToInt(updated_shapefile)\n #3\n legend = preProcessLegend(landuse_legend_fn)\n #4\n convertIdToName(legend,updated_shapefile)\n #5\n plotLandUse(updated_shapefile,\"Pie\")\n print(\"-----------finished!-------------\")\n print(\"DONE! :)\")\n else:\n iface.messageBar().pushMessage(\"Error\", \"The directory does not exist. Please change data_dir in the code\",level = 1)\n print(\"Please specify a valid directory in the main function of Code_Distance.py!\")","def test_addon_layer(self):\n from spirit.plone.theming.interfaces import ISpiritPloneThemingLayer\n self.assertIn(ISpiritPloneThemingLayer, registered_layers())"],"string":"[\n \"def setup_product():\\n\\n fiveconfigure.debug_mode = True\\n import collective.geo.openlayers\\n zcml.load_config('configuretest.zcml', collective.geo.openlayers)\\n\\n fiveconfigure.debug_mode = False\",\n \"def test_layer_API(self):\\n\\n # Exceptions\\n exclude = ['get_topN', 'get_bins',\\n 'get_geotransform',\\n 'get_nodata_value',\\n 'get_attribute_names',\\n 'get_resolution',\\n 'get_geometry_type',\\n 'get_geometry_name',\\n 'to_vector_points',\\n 'to_vector_layer']\\n\\n V = Vector() # Empty vector instance\\n R = Raster() # Empty raster instance\\n\\n assert same_API(V, R, exclude=exclude)\\n\\n for filename in [os.path.join(TESTDATA,\\n 'test_buildings.shp'),\\n os.path.join(HAZDATA,\\n 'Lembang_Earthquake_Scenario.asc')]:\\n\\n L = read_layer(filename)\\n\\n assert same_API(L, V, exclude=exclude)\\n assert same_API(L, R, exclude=exclude)\",\n \"def test_to_geojson(self):\\n fc = self.read_feature()\\n dest_filename = str(self.datadir.join('test.geojson'))\\n fc.to_geojson(dest_filename)\\n fc_check = read_feature_collection(dest_filename)\\n self.check_feature(fc_check.features[0])\",\n \"def test_basic(self):\\n st.map(df1)\\n\\n c = json.loads(self.get_delta_from_queue().new_element.deck_gl_json_chart.json)\\n\\n self.assertIsNotNone(c.get(\\\"initialViewState\\\"))\\n self.assertIsNotNone(c.get(\\\"layers\\\"))\\n self.assertIsNotNone(c.get(\\\"mapStyle\\\"))\\n self.assertEqual(len(c.get(\\\"layers\\\")), 1)\\n self.assertEqual(c.get(\\\"initialViewState\\\").get(\\\"latitude\\\"), 2.5)\\n self.assertEqual(c.get(\\\"initialViewState\\\").get(\\\"longitude\\\"), 25)\\n self.assertEqual(c.get(\\\"initialViewState\\\").get(\\\"zoom\\\"), 3)\\n self.assertEqual(c.get(\\\"initialViewState\\\").get(\\\"pitch\\\"), 0)\\n self.assertEqual(c.get(\\\"layers\\\")[0].get(\\\"@@type\\\"), \\\"ScatterplotLayer\\\")\",\n \"def get_geoserver_layers(geoserver_url, geoserver_username, geoserver_password):\\n\\tgeoserver_rest_url = geoserver_url + 'rest'\\n\\teprint(\\\"retrieving GeoServer layer info via {}\\\".format(geoserver_rest_url))\\n\\tcat = Catalog(geoserver_rest_url, username=geoserver_username, password=geoserver_password)\\n\\tall_layers = cat.get_layers()\\n\\treturn all_layers\",\n \"def test_authentication_is_not_required(self):\\n # Act\\n response = self.client.get(self.url)\\n # Assert\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(response.json, self.test_project.get_aoi_geometry_as_geojson())\",\n \"def test_choropleth_pass():\\n m = view(world, column=\\\"pop_est\\\")\",\n \"def test_browserlayer(self):\\n from {{cookiecutter.package_name}}.interfaces import (\\n I{{cookiecutter.project_slug.capitalize()}}CoreLayer)\\n from plone.browserlayer import utils\\n self.assertIn(I{{cookiecutter.project_slug.capitalize()}}CoreLayer, utils.registered_layers())\",\n \"def show(data_objects, **options):\\n if not is_loaded():\\n return data_objects\\n\\n # (else)\\n if not hasattr(data_objects, '__iter__'):\\n data_objects = [data_objects]\\n\\n # print(data_objects)\\n scene = pygeojs.scene(**options)\\n scene.createLayer('osm')\\n\\n if not data_objects:\\n print('No data objects')\\n return scene\\n\\n # feature_layer = scene.createLayer('feature')\\n feature_layer = None\\n\\n combined_bounds = None\\n # Reverse order so that first item ends on top\\n for data_object in reversed(data_objects):\\n if data_object._getdatatype() == gaia.types.VECTOR:\\n # print('Adding vector object')\\n # Special handling for vector datasets:\\n # First, make a copy of the geopandas frame\\n df = geopandas.GeoDataFrame.copy(data_object.get_data())\\n\\n # Convert to lon-lat if needed\\n epsg = data_object.get_epsg()\\n if epsg and str(epsg) != '4326':\\n print('Converting crs')\\n df[df.geometry.name] = df.geometry.to_crs(epsg='4326')\\n\\n # Strip any z coordinates (force to z = 1)\\n df.geometry = df.geometry.scale(zfact=0.0).translate(zoff=1.0)\\n # df.to_file('/home/john/temp/df.pandas')\\n # print(df)\\n # print(df.geometry)\\n\\n # Calculate bounds\\n geopandas_bounds = df.geometry.total_bounds\\n xmin, ymin, xmax, ymax = geopandas_bounds\\n meta_bounds = [\\n [xmin, ymin], [xmax, ymin], [xmax, ymax], [xmin, ymax]\\n ]\\n\\n # Add map feature\\n if feature_layer is None:\\n feature_layer = scene.createLayer('feature')\\n\\n # Use __geo_interface__ to get the geojson\\n feature_layer.readGeoJSON(df.__geo_interface__)\\n # print(df.__geo_interface__)\\n else:\\n # Get bounds, in order to compute overall bounds\\n meta = data_object.get_metadata()\\n # print('meta: {}'.format(meta))\\n # print(meta)\\n raster_bounds = meta.get('bounds').get('coordinates')[0]\\n # print(meta_bounds)\\n assert raster_bounds, 'data_object missing bounds'\\n\\n # meta bounds inconsistent between sources, so compute brute force\\n xvals, yvals = zip(*raster_bounds)\\n xmin, xmax = min(xvals), max(xvals)\\n ymin, ymax = min(yvals), max(yvals)\\n meta_bounds = [\\n [xmin, ymin], [xmax, ymin], [xmax, ymax], [xmin, ymax]\\n ]\\n\\n # Bounds format is [xmin, ymin, xmax, ymax]\\n bounds = [\\n meta_bounds[0][0], meta_bounds[0][1],\\n meta_bounds[2][0], meta_bounds[2][1]\\n ]\\n\\n # print(bounds)\\n if combined_bounds is None:\\n combined_bounds = bounds\\n else:\\n combined_bounds[0] = min(combined_bounds[0], bounds[0])\\n combined_bounds[1] = min(combined_bounds[1], bounds[1])\\n combined_bounds[2] = max(combined_bounds[2], bounds[2])\\n combined_bounds[3] = max(combined_bounds[3], bounds[3])\\n\\n # print('options:', options)\\n rep = options.get('representation')\\n if rep == 'outline':\\n # Create polygon object\\n rect = [\\n [bounds[0], bounds[1]],\\n [bounds[2], bounds[1]],\\n [bounds[2], bounds[3]],\\n [bounds[0], bounds[3]],\\n [bounds[0], bounds[1]],\\n ]\\n geojs_polygon = geojson.Polygon([rect])\\n properties = {\\n 'fillColor': '#fff',\\n 'fillOpacity': 0.1,\\n 'stroke': True,\\n 'strokeColor': '#333',\\n 'strokeWidth': 2\\n }\\n geojson_feature = geojson.Feature(\\n geometry=geojs_polygon, properties=properties)\\n geojson_collection = geojson.FeatureCollection([geojson_feature])\\n # print(geojson_collection)\\n\\n if feature_layer is None:\\n feature_layer = scene.createLayer('feature')\\n\\n feature_layer.createFeature(\\n 'geojson', geojson_collection, **options)\\n\\n elif data_object.__class__.__name__ == 'GirderDataObject':\\n if data_object._getdatatype() == 'raster':\\n # Use large-image display\\n # Todo - verify that it is installed\\n tiles_url = data_object._get_tiles_url()\\n # print('tiles_url', tiles_url)\\n opacity = 1.0\\n if hasattr(data_object, 'opacity'):\\n opacity = data_object.opacity\\n scene.createLayer(\\n 'osm', url=tiles_url, keepLower=False, opacity=opacity)\\n else:\\n raise GaiaException(\\n 'Cannot display GirderDataObject with data type {}'.format(\\n data_object._getdatatype()))\\n\\n elif data_object._getdatatype() == gaia.types.VECTOR:\\n pass # vector objects handled above\\n else:\\n msg = 'Cannot display dataobject, type {}'.format(\\n data_object.__class__.__name__)\\n raise GaiaException(msg)\\n\\n # Send custom message to (javascript) client to set zoom & center\\n rpc = {'method': 'set_zoom_and_center', 'params': combined_bounds}\\n scene.send(rpc)\\n return scene\",\n \"def setgeo(rundata):\\n#-------------------\\n\\n try:\\n geodata = rundata.geodata\\n except:\\n print \\\"*** Error, this rundata has no geodata attribute\\\"\\n raise AttributeError(\\\"Missing geodata attribute\\\")\\n\\n # == setgeo.data values ==\\n geodata.variable_dt_refinement_ratios = True ## Overrides clawdata.inratt, above\\n\\n geodata.igravity = 1\\n geodata.gravity = 9.81\\n geodata.icoordsys = 2\\n geodata.Rearth = 6367.5e3\\n geodata.icoriolis = 0\\n\\n # == settsunami.data values ==\\n geodata.sealevel = 0.\\n geodata.drytolerance = 1.e-2\\n geodata.wavetolerance = 1.e-1 ##\\n geodata.depthdeep = 1.e6 ## Definition of \\\"deep\\\" water\\n geodata.maxleveldeep = 10 ## Restriction on the number of deep water levels\\n geodata.ifriction = 1 ## Friction switch. 0=off, 1=on\\n # geodata.coeffmanning =0.0\\n geodata.coeffmanning =.025\\n geodata.frictiondepth = 10.\\n\\n #okushiri_dir = '/Users/FrankGonzalez/daily/modeling/tsunami-benchmarks/github/' \\\\\\n #+ 'FrankGonzalez/geoclaw-group/benchmarks/bp09' ##\\n okushiri_dir = '..' ## this directory\\n \\n # == settopo.data values ==\\n geodata.topofiles = []\\n # for topography, append lines of the form\\n # [topotype, minlevel, maxlevel, t1, t2, fname]\\n # geodata.topofiles.append([1, 1, 1, 0, 1.e10, \\\\\\n # okushiri_dir + '/OK24.tt1']) ## 24-s, ~550-740 m Entire Domain (Dmitry's version of Kansai U.)\\n geodata.topofiles.append([1, 1, 1, 0, 1.e10, \\\\\\n okushiri_dir + '/OK08.tt1']) ## 8-s, ~184-247 m Okushiri (Dmitry's version of Kansai U.)\\n geodata.topofiles.append([1, 1, 1, 0, 1.e10, \\\\\\n okushiri_dir + '/OK03.tt1']) ## 2.67 s (8/3s), ~61-82 m Okushiri (Dmitry's version of Kansai U.)\\n geodata.topofiles.append([1, 1, 1, 0., 1.e10, \\\\\\n okushiri_dir + '/AO15.tt1']) ## 0.53-0.89 s, ~16.5-20.4 m, Aonae (Dmitry's version of Kansai U.)\\n # geodata.topofiles.append([1, 1, 1, 0, 1.e10, \\\\\\n # okushiri_dir + '/MO01.tt1']) ## 0.89 s, ~20-27 m, Monai (Dmitry's version of Kansai U.)\\n # geodata.topofiles.append([1, 1, 1, 0., 1.e10, \\\\\\n # okushiri_dir + '/MB05.tt1']) ## 0.13-0.18 s, ~4 m Monai (Dmitry's version of Kansai U.)\\n\\n # geodata.topofiles.append([-3, 1, 1, 0, 1.e10, \\\\\\n # okushiri_dir + '/depth40_138.txt']) ## JODC 500 m\\n # geodata.topofiles.append([-3, 1, 1, 0, 1.e10, \\\\\\n # okushiri_dir + '/depth40_140.txt']) ## JODC 500 m\\n # geodata.topofiles.append([-3, 1, 1, 0, 1.e10, \\\\\\n # okushiri_dir + '/depth42_138.txt']) ## JODC 500 m\\n # geodata.topofiles.append([-3, 1, 1, 0, 1.e10, \\\\\\n # okushiri_dir + '/depth42_140.txt']) ## JODC 500 m\\n \\n # == setdtopo.data values ==\\n geodata.dtopofiles = []\\n # for moving topography, append lines of the form: (<= 1 allowed for now!)\\n # [topotype, minlevel,maxlevel,fname]\\n geodata.dtopofiles.append([1,2,3, okushiri_dir + '/HNO1993.txyz']) ## Dmitry N.'s version of Kansai U.\\n\\n # == setqinit.data values ==\\n geodata.iqinit = 0\\n geodata.qinitfiles = []\\n # for qinit perturbations, append lines of the form: (<= 1 allowed for now!)\\n # [minlev, maxlev, fname]\\n #geodata.qinitfiles.append([1, 1, 'hump.xyz'])\\n\\n # == setregions.data values ==\\n geodata.regions = []\\n # to specify regions of refinement append lines of the form\\n # [minlevel,maxlevel,t1,t2,x1,x2,y1,y2]\\n # Note: Level 1 = 24 s & Levels [2,3,4,5] = RF [3,3,3,8] => Res of 8 sec to 8/3 sec to 8/9 to 1/9 sec/cell\\n # Grid Limits\\n # Name x1 x2 y1 y2\\n # OK24 137.53666670 141.53000000 39.53666670 44.26333330\\n # HNO 138.50000000 140.55000000 40.51666670 43.30000000\\n # OK08 138.50111110 140.55222220 40.52111110 43.29888890\\n # OK03 139.38925930 139.66407410 41.99592590 42.27074070\\n # AO15 139.43419750 139.49987650 42.03118520 42.07251850\\n # MO01 139.41123460 139.43320990 42.07790120 42.14580250\\n # MB05 139.41385190 139.42639510 42.09458550 42.10343920\\n \\n #geodata.regions.append([1, 1, 0., 1e9, 0.0, 360.0, -90.0, 90.0]) ## OK24: 24-s, ~550-740 m Entire Domain\\n geodata.regions.append([1, 2, 0., 1e9, 138.5, 139.7, 41.4, 43.3]) ## OK08: 8-s, ~184-247 m Okushiri \\n geodata.regions.append([1, 3, 0., 1e9, 139.39, 139.6, 42.0, 42.25]) ## OK03: 2.67 s (8/3s), ~61-82 m Okushiri \\n # geodata.regions.append([1, 4, 0., 1e9, 139.42, 139.57, 42.03, 42.23]) ## AO15: 0.53-8/9 s, ~16.5-20.4 m, Aonae \\n #geodata.regions.append([1, 4, 0., 1e9, 139.40, 139.46, 42.03, 42.22]) ## West coast Okushiri\\n geodata.regions.append([4, 4, 90., 1e9, 139.42, 139.431, 42.07, 42.12])\\n \\n\\n # == setgauges.data values ==\\n geodata.gauges = []\\n # for gauges append lines of the form [gaugeno, x, y, t1, t2]\\n \\n # geodata.gauges.append([1,139.429211710298,42.188181491811,0.0,1e9]) ## Tsuji Obs\\n # geodata.gauges.append([3,139.411185686023,42.162762869034,0.0,1e9]) ## Tsuji Obs\\n # geodata.gauges.append([5,139.418261206409,42.137404393442,0.0,1e9]) ## Tsuji Obs\\n geodata.gauges.append([6,139.428035766149,42.093012384481,0.0,1e9]) ## Tsuji Obs\\n geodata.gauges.append([7,139.426244998662,42.116554785296,0.0,1e9]) ## Tsuji Obs\\n geodata.gauges.append([8,139.423714744650,42.100414145210,0.0,1e9]) ## Tsuji Obs\\n geodata.gauges.append([9,139.428901803617,42.076636582137,0.0,1e9]) ## Tsuji Obs\\n # geodata.gauges.append([10,139.427853421935,42.065461519438,0.0,1e9]) ## Tsuji Obs\\n # geodata.gauges.append([11,139.451539852594,42.044696547058,0.0,1e9]) ## Tsuji Obs\\n # geodata.gauges.append([12,139.456528443496,42.051692262353,0.0,1e9]) ## Tsuji Obs\\n # geodata.gauges.append([13,139.456528443496,42.051692262353,0.0,1e9]) ## Tsuji Obs\\n # \\n # == setfixedgrids.data values ==\\n\\n geodata.fixedgrids = []\\n \\n for g in geodata.gauges:\\n xg = g[1]\\n yg = g[2]\\n xg1 = xg - 0.001\\n xg2 = xg + 0.002\\n yg1 = yg - 0.001\\n yg2 = yg + 0.002\\n nx = 31\\n ny = 31\\n gaugeno = g[0]\\n if gaugeno == 9:\\n xg2 = xg + 0.003\\n nx = 41\\n if gaugeno == 8:\\n xg1 = xg - 0.002\\n xg2 = xg + 0.001\\n yg1 = yg - 0.002\\n yg2 = yg + 0.001\\n \\n geodata.fixedgrids.append([210.0,360.0,11,xg1,xg2,yg1,yg2,nx,ny,0,1])\\n geodata.regions.append([5, 5, 180., 1e9, xg1,xg2,yg1,yg2])\\n \\n \\n return rundata\\n\\n # end of function setgeo\\n # ----------------------\",\n \"def test_render_world_map():\\n\\n gdpinfo = {\\n \\\"gdpfile\\\": \\\"isp_gdp.csv\\\",\\n \\\"separator\\\": \\\",\\\",\\n \\\"quote\\\": '\\\"',\\n \\\"min_year\\\": 1960,\\n \\\"max_year\\\": 2015,\\n \\\"country_name\\\": \\\"Country Name\\\",\\n \\\"country_code\\\": \\\"Country Code\\\"\\n }\\n \\n# gdpinfo = {\\n# \\\"gdpfile\\\": \\\"gdptable1.csv\\\",\\n# \\\"separator\\\": \\\",\\\",\\n# \\\"quote\\\": '\\\"',\\n# \\\"min_year\\\": 2000,\\n# \\\"max_year\\\": 2005,\\n# \\\"country_name\\\": \\\"Country Name\\\",\\n# \\\"country_code\\\": \\\"Code\\\"\\n# }\\n\\n \\n # Get pygal country code map\\n pygal_countries = pygal.maps.world.COUNTRIES\\n \\n #test\\n #render_world_map(gdpinfo, pygal_countries, \\\"2002\\\", \\\"isp_gdp_world_name_1960.svg\\\")\\n\\n # 1960\\n render_world_map(gdpinfo, pygal_countries, \\\"1960\\\", \\\"isp_gdp_world_name_1960.svg\\\")\\n\\n # 1980\\n #render_world_map(gdpinfo, pygal_countries, \\\"1980\\\", \\\"isp_gdp_world_name_1980.svg\\\")\\n\\n # 2000\\n #render_world_map(gdpinfo, pygal_countries, \\\"2000\\\", \\\"isp_gdp_world_name_2000.svg\\\")\\n\\n # 2010\\n #render_world_map(gdpinfo, pygal_countries, \\\"2010\\\", \\\"isp_gdp_world_name_2010.svg\\\")\",\n \"def test_01_get_geometry_collection_list(self):\\n response = self.client.get(reverse('collection-lc'), format='json')\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\",\n \"def test_geo_ops_smoke(geo_table):\\n t = geo_table\\n\\n # alias for fields\\n point = t.geo_point\\n linestring = t.geo_linestring\\n polygon = t.geo_polygon\\n multipolygon = t.geo_multipolygon\\n\\n # test ops\\n point.srid()\\n point.x()\\n point.y()\\n\\n linestring.contains(point)\\n linestring.end_point()\\n linestring.length()\\n linestring.max_distance(point)\\n linestring.point_n(1)\\n linestring.start_point()\\n linestring.x_max()\\n linestring.x_min()\\n linestring.y_max()\\n linestring.y_min()\\n\\n polygon.area()\\n polygon.perimeter()\\n\\n multipolygon.n_points()\\n multipolygon.n_rings()\",\n \"def test_addon_layer(self):\\n layers = [l.getName() for l in registered_layers()]\\n self.assertIn('IBriefyPloneLayer', layers)\",\n \"def __init__(self, server_name):\\n server_url = SERVER_URL + server_name + '/MapServer/'\\n super(OsmpFeatureLayerCollection, self).__init__(server_url)\",\n \"def setUp(self):\\n uri = path.join(path.dirname(__file__),'data','StressTest.shp')\\n self.vlayer = QgsVectorLayer(uri, \\\"StressTest_Layer\\\", \\\"ogr\\\")\\n self.nxProfile = Profile(self.vlayer, None)\\n self.nxProfile.pathfinder(8, 10)\\n # ['DateTime', 'Date', 'Time', 'RealField', 'IntField', 'StringFiel', 'PathName', 'PathName2']\",\n \"def generate_openlayers(self):\\n\\n args = {}\\n args['title'] = self.options.title\\n args['bingkey'] = self.options.bingkey\\n args['south'], args['west'], args['north'], args['east'] = self.swne\\n args['minzoom'] = self.tminz\\n args['maxzoom'] = self.tmaxz\\n args['tilesize'] = self.tilesize\\n args['tileformat'] = self.tileext\\n args['publishurl'] = self.options.url\\n args['copyright'] = self.options.copyright\\n if self.options.tmscompatible:\\n args['tmsoffset'] = \\\"-1\\\"\\n else:\\n args['tmsoffset'] = \\\"\\\"\\n if self.options.profile == 'raster':\\n args['rasterzoomlevels'] = self.tmaxz+1\\n args['rastermaxresolution'] = 2**(self.nativezoom) * self.out_gt[1]\\n\\n s = r\\\"\\\"\\\"<!DOCTYPE html PUBLIC \\\"-//W3C//DTD XHTML 1.0 Strict//EN\\\" \\\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\\\">\\n <html xmlns=\\\"http://www.w3.org/1999/xhtml\\\"\\n <head>\\n <title>%(title)s</title>\\n <meta http-equiv='imagetoolbar' content='no'/>\\n <style type=\\\"text/css\\\"> v\\\\:* {behavior:url(#default#VML);}\\n html, body { overflow: hidden; padding: 0; height: 100%%; width: 100%%; font-family: 'Lucida Grande',Geneva,Arial,Verdana,sans-serif; }\\n body { margin: 10px; background: #fff; }\\n h1 { margin: 0; padding: 6px; border:0; font-size: 20pt; }\\n #header { height: 43px; padding: 0; background-color: #eee; border: 1px solid #888; }\\n #subheader { height: 12px; text-align: right; font-size: 10px; color: #555;}\\n #map { height: 95%%; border: 1px solid #888; }\\n .olImageLoadError { display: none; }\\n .olControlLayerSwitcher .layersDiv { border-radius: 10px 0 0 10px; }\\n </style>\\\"\\\"\\\" % args # noqa\\n\\n if self.options.profile == 'mercator':\\n s += \\\"\\\"\\\"\\n <script src='http://maps.google.com/maps/api/js?sensor=false&v=3.7'></script>\\n \\\"\\\"\\\" % args\\n\\n s += \\\"\\\"\\\"\\n <script src=\\\"http://www.openlayers.org/api/2.12/OpenLayers.js\\\"></script>\\n <script>\\n var map;\\n var mapBounds = new OpenLayers.Bounds( %(west)s, %(south)s, %(east)s, %(north)s);\\n var mapMinZoom = %(minzoom)s;\\n var mapMaxZoom = %(maxzoom)s;\\n var emptyTileURL = \\\"http://www.maptiler.org/img/none.png\\\";\\n OpenLayers.IMAGE_RELOAD_ATTEMPTS = 3;\\n\\n function init(){\\\"\\\"\\\" % args\\n\\n if self.options.profile == 'mercator':\\n s += \\\"\\\"\\\"\\n var options = {\\n div: \\\"map\\\",\\n controls: [],\\n projection: \\\"EPSG:3857\\\",\\n displayProjection: new OpenLayers.Projection(\\\"EPSG:4326\\\"),\\n numZoomLevels: 20\\n };\\n map = new OpenLayers.Map(options);\\n\\n // Create Google Mercator layers\\n var gmap = new OpenLayers.Layer.Google(\\\"Google Streets\\\",\\n {\\n type: google.maps.MapTypeId.ROADMAP,\\n sphericalMercator: true\\n });\\n var gsat = new OpenLayers.Layer.Google(\\\"Google Satellite\\\",\\n {\\n type: google.maps.MapTypeId.SATELLITE,\\n sphericalMercator: true\\n });\\n var ghyb = new OpenLayers.Layer.Google(\\\"Google Hybrid\\\",\\n {\\n type: google.maps.MapTypeId.HYBRID,\\n sphericalMercator: true\\n });\\n var gter = new OpenLayers.Layer.Google(\\\"Google Terrain\\\",\\n {\\n type: google.maps.MapTypeId.TERRAIN,\\n sphericalMercator: true\\n });\\n\\n // Create Bing layers\\n var broad = new OpenLayers.Layer.Bing({\\n name: \\\"Bing Roads\\\",\\n key: \\\"%(bingkey)s\\\",\\n type: \\\"Road\\\",\\n sphericalMercator: true\\n });\\n var baer = new OpenLayers.Layer.Bing({\\n name: \\\"Bing Aerial\\\",\\n key: \\\"%(bingkey)s\\\",\\n type: \\\"Aerial\\\",\\n sphericalMercator: true\\n });\\n var bhyb = new OpenLayers.Layer.Bing({\\n name: \\\"Bing Hybrid\\\",\\n key: \\\"%(bingkey)s\\\",\\n type: \\\"AerialWithLabels\\\",\\n sphericalMercator: true\\n });\\n\\n // Create OSM layer\\n var osm = new OpenLayers.Layer.OSM(\\\"OpenStreetMap\\\");\\n\\n \\\"\\\"\\\" % args # noqa\\n\\t\\t \\n if self.options.xyz:\\n s += \\\"\\\"\\\"\\t\\t \\n // create TMS Overlay layer\\n var tmsoverlay = new OpenLayers.Layer.XYZ(\\\"XYZ Overlay\\\",\\n \\\"${z}/${x}/${y}.png\\\", {\\n transitionEffect: 'resize',\\n isBaseLayer: false\\n });\\n\\t\\t\\t\\t \\n\\t\\t \\\"\\\"\\\" % args # noqa\\n else:\\n s += \\\"\\\"\\\"\\t\\t \\n // create TMS Overlay layer\\n var tmsoverlay = new OpenLayers.Layer.TMS(\\\"TMS Overlay\\\", \\\"\\\",\\n {\\n serviceVersion: '.',\\n layername: '.',\\n alpha: true,\\n type: '%(tileformat)s',\\n isBaseLayer: false,\\n getURL: getURL\\n });\\n\\t\\t\\t\\t \\n\\t\\t \\\"\\\"\\\" % args # noqa\\t\\t \\n\\t\\t \\n s += \\\"\\\"\\\" \\n if (OpenLayers.Util.alphaHack() == false) {\\n tmsoverlay.setOpacity(0.7);\\n }\\n\\n map.addLayers([gmap, gsat, ghyb, gter,\\n broad, baer, bhyb,\\n osm, tmsoverlay]);\\n\\n var switcherControl = new OpenLayers.Control.LayerSwitcher();\\n map.addControl(switcherControl);\\n switcherControl.maximizeControl();\\n\\n map.zoomToExtent(mapBounds.transform(map.displayProjection, map.projection));\\n \\\"\\\"\\\" % args # noqa\\n\\n elif self.options.profile == 'geodetic':\\n s += \\\"\\\"\\\"\\n var options = {\\n div: \\\"map\\\",\\n controls: [],\\n projection: \\\"EPSG:4326\\\"\\n };\\n map = new OpenLayers.Map(options);\\n\\n var wms = new OpenLayers.Layer.WMS(\\\"VMap0\\\",\\n \\\"http://tilecache.osgeo.org/wms-c/Basic.py?\\\",\\n {\\n layers: 'basic',\\n format: 'image/png'\\n }\\n );\\n var tmsoverlay = new OpenLayers.Layer.TMS(\\\"TMS Overlay\\\", \\\"\\\",\\n {\\n serviceVersion: '.',\\n layername: '.',\\n alpha: true,\\n type: '%(tileformat)s',\\n isBaseLayer: false,\\n getURL: getURL\\n });\\n if (OpenLayers.Util.alphaHack() == false) {\\n tmsoverlay.setOpacity(0.7);\\n }\\n\\n map.addLayers([wms,tmsoverlay]);\\n\\n var switcherControl = new OpenLayers.Control.LayerSwitcher();\\n map.addControl(switcherControl);\\n switcherControl.maximizeControl();\\n\\n map.zoomToExtent(mapBounds);\\n \\\"\\\"\\\" % args # noqa\\n\\n elif self.options.profile == 'raster':\\n s += \\\"\\\"\\\"\\n var options = {\\n div: \\\"map\\\",\\n controls: [],\\n maxExtent: new OpenLayers.Bounds(%(west)s, %(south)s, %(east)s, %(north)s),\\n maxResolution: %(rastermaxresolution)f,\\n numZoomLevels: %(rasterzoomlevels)d\\n };\\n map = new OpenLayers.Map(options);\\n\\n var layer = new OpenLayers.Layer.TMS(\\\"TMS Layer\\\", \\\"\\\",\\n {\\n serviceVersion: '.',\\n layername: '.',\\n alpha: true,\\n type: '%(tileformat)s',\\n getURL: getURL\\n });\\n\\n map.addLayer(layer);\\n map.zoomToExtent(mapBounds);\\n \\\"\\\"\\\" % args # noqa\\n\\n s += \\\"\\\"\\\"\\n map.addControls([new OpenLayers.Control.PanZoomBar(),\\n new OpenLayers.Control.Navigation(),\\n new OpenLayers.Control.MousePosition(),\\n new OpenLayers.Control.ArgParser(),\\n new OpenLayers.Control.Attribution()]);\\n }\\n \\\"\\\"\\\" % args\\n\\n if self.options.profile == 'mercator' and self.options.xyz is None:\\n s += \\\"\\\"\\\"\\n function getURL(bounds) {\\n bounds = this.adjustBounds(bounds);\\n var res = this.getServerResolution();\\n var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));\\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\\n var z = this.getServerZoom();\\n if (this.map.baseLayer.CLASS_NAME === 'OpenLayers.Layer.Bing') {\\n z+=1;\\n }\\n var path = this.serviceVersion + \\\"/\\\" + this.layername + \\\"/\\\" + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n var url = this.url;\\n if (OpenLayers.Util.isArray(url)) {\\n url = this.selectUrl(path, url);\\n }\\n if (mapBounds.intersectsBounds(bounds) && (z >= mapMinZoom) && (z <= mapMaxZoom)) {\\n return url + path;\\n } else {\\n return emptyTileURL;\\n }\\n }\\n \\\"\\\"\\\" % args # noqa\\n\\n elif self.options.profile == 'geodetic':\\n s += \\\"\\\"\\\"\\n function getURL(bounds) {\\n bounds = this.adjustBounds(bounds);\\n var res = this.getServerResolution();\\n var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));\\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\\n var z = this.getServerZoom()%(tmsoffset)s;\\n var path = this.serviceVersion + \\\"/\\\" + this.layername + \\\"/\\\" + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n var url = this.url;\\n if (OpenLayers.Util.isArray(url)) {\\n url = this.selectUrl(path, url);\\n }\\n if (mapBounds.intersectsBounds(bounds) && (z >= mapMinZoom) && (z <= mapMaxZoom)) {\\n return url + path;\\n } else {\\n return emptyTileURL;\\n }\\n }\\n \\\"\\\"\\\" % args # noqa\\n\\n elif self.options.profile == 'raster':\\n s += \\\"\\\"\\\"\\n function getURL(bounds) {\\n bounds = this.adjustBounds(bounds);\\n var res = this.getServerResolution();\\n var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));\\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\\n var z = this.getServerZoom();\\n var path = this.serviceVersion + \\\"/\\\" + this.layername + \\\"/\\\" + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n var url = this.url;\\n if (OpenLayers.Util.isArray(url)) {\\n url = this.selectUrl(path, url);\\n }\\n if (mapBounds.intersectsBounds(bounds) && (z >= mapMinZoom) && (z <= mapMaxZoom)) {\\n return url + path;\\n } else {\\n return emptyTileURL;\\n }\\n }\\n \\\"\\\"\\\" % args # noqa\\n\\n s += \\\"\\\"\\\"\\n function getWindowHeight() {\\n if (self.innerHeight) return self.innerHeight;\\n if (document.documentElement && document.documentElement.clientHeight)\\n return document.documentElement.clientHeight;\\n if (document.body) return document.body.clientHeight;\\n return 0;\\n }\\n\\n function getWindowWidth() {\\n if (self.innerWidth) return self.innerWidth;\\n if (document.documentElement && document.documentElement.clientWidth)\\n return document.documentElement.clientWidth;\\n if (document.body) return document.body.clientWidth;\\n return 0;\\n }\\n\\n function resize() {\\n var map = document.getElementById(\\\"map\\\");\\n var header = document.getElementById(\\\"header\\\");\\n var subheader = document.getElementById(\\\"subheader\\\");\\n map.style.height = (getWindowHeight()-80) + \\\"px\\\";\\n map.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n header.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n subheader.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n if (map.updateSize) { map.updateSize(); };\\n }\\n\\n onresize=function(){ resize(); };\\n\\n </script>\\n </head>\\n <body onload=\\\"init()\\\">\\n <div id=\\\"header\\\"><h1>%(title)s</h1></div>\\n <div id=\\\"subheader\\\">Generated by <a href=\\\"http://www.klokan.cz/projects/gdal2tiles/\\\">GDAL2Tiles</a>, Copyright © 2008 <a href=\\\"http://www.klokan.cz/\\\">Klokan Petr Pridal</a>, <a href=\\\"http://www.gdal.org/\\\">GDAL</a> & <a href=\\\"http://www.osgeo.org/\\\">OSGeo</a> <a href=\\\"http://code.google.com/soc/\\\">GSoC</a>\\n <!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->\\n </div>\\n <div id=\\\"map\\\"></div>\\n <script type=\\\"text/javascript\\\" >resize()</script>\\n </body>\\n </html>\\\"\\\"\\\" % args # noqa\\n\\n return s\",\n \"def test_run_spatial_function(session):\\n factories.ConnectionNodeFactory()\\n q = session.query(func.ST_AsGeoJSON(models.ConnectionNode.the_geom))\\n q.first()\",\n \"def __init__(self, feat):\\n\\n self.feat = feat\\n self.shape = shape(feat[\\\"geometry\\\"])\\n\\n self.prop = feat[\\\"properties\\\"]\\n self.feat[\\\"properties\\\"][\\\"style\\\"] = {\\n \\\"fill_opacity\\\": 0.1,\\n \\\"opacity\\\": 0.1, \\n \\\"color\\\": \\\"white\\\", \\n \\\"weight\\\": 0.75}\\n self.id = self.prop[\\\"grid_id\\\"]\\n self.level = self.prop[\\\"grid_level\\\"]\\n \\n self.layer = GeoJSON(\\n data=self.feat,\\n hover_style = {\\n \\\"weight\\\": 1, \\n \\\"color\\\": \\\"white\\\",\\n \\\"fillColor\\\": \\\"white\\\",\\n \\\"fillOpacity\\\": 0.3})\\n self.layer.on_click(self.toggle)\\n self.on = False\",\n \"def generate_openlayers( self ):\\n\\n args = {}\\n args['title'] = self.options.title\\n args['googlemapskey'] = self.options.googlekey\\n args['yahooappid'] = self.options.yahookey\\n args['south'], args['west'], args['north'], args['east'] = self.swne\\n args['minzoom'] = self.tminz\\n args['maxzoom'] = self.tmaxz\\n args['tilesize'] = self.tilesize\\n args['tileformat'] = format_extension[self.image_output.format]\\n if self.image_output.format == \\\"PNG\\\":\\n args['has_alpha'] = 'true'\\n else:\\n args['has_alpha'] = 'false'\\n args['publishurl'] = \\\"\\\" if self.options.url is None else self.options.url\\n args['copyright'] = self.options.copyright\\n if self.options.profile in ('raster', 'gearth'):\\n args['rasterzoomlevels'] = self.tmaxz+1\\n args['rastermaxresolution'] = 2**(self.nativezoom) * self.out_gt[1]\\n\\n s = \\\"\\\"\\\"<!DOCTYPE html PUBLIC \\\"-//W3C//DTD XHTML 1.0 Strict//EN\\\" \\\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\\\">\\n <html xmlns=\\\"http://www.w3.org/1999/xhtml>\\\"\\n <head>\\n <title>%(title)s</title>\\n <meta http-equiv='imagetoolbar' content='no'/>\\n <style type=\\\"text/css\\\"> v\\\\:* {behavior:url(#default#VML);}\\n html, body { overflow: hidden; padding: 0; height: 100%%; width: 100%%; font-family: 'Lucida Grande',Geneva,Arial,Verdana,sans-serif; }\\n body { margin: 10px; background: #fff; }\\n h1 { margin: 0; padding: 6px; border:0; font-size: 20pt; }\\n #header { height: 43px; padding: 0; background-color: #eee; border: 1px solid #888; }\\n #subheader { height: 12px; text-align: right; font-size: 10px; color: #555;}\\n #map { height: 95%%; border: 1px solid #888; }\\n </style>\\\"\\\"\\\" % args\\n\\n if self.options.profile == 'mercator':\\n s += \\\"\\\"\\\"\\n <script src='http://dev.virtualearth.net/mapcontrol/mapcontrol.ashx?v=6.1'></script>\\n <script src='http://maps.google.com/maps?file=api&v=2&key=%(googlemapskey)s' type='text/javascript'></script>\\n <script src=\\\"http://api.maps.yahoo.com/ajaxymap?v=3.0&appid=%(yahooappid)s\\\"></script>\\\"\\\"\\\" % args\\n\\n s += \\\"\\\"\\\"\\n <script src=\\\"http://www.openlayers.org/api/2.7/OpenLayers.js\\\" type=\\\"text/javascript\\\"></script>\\n <script type=\\\"text/javascript\\\">\\n var map;\\n var mapBounds = new OpenLayers.Bounds( %(west)s, %(south)s, %(east)s, %(north)s);\\n var mapMinZoom = %(minzoom)s;\\n var mapMaxZoom = %(maxzoom)s;\\n\\n // avoid pink tiles\\n OpenLayers.IMAGE_RELOAD_ATTEMPTS = 3;\\n OpenLayers.Util.onImageLoadErrorColor = \\\"transparent\\\";\\n\\n function init(){\\\"\\\"\\\" % args\\n\\n if self.options.profile == 'mercator':\\n s += \\\"\\\"\\\"\\n var options = {\\n controls: [],\\n projection: new OpenLayers.Projection(\\\"EPSG:900913\\\"),\\n displayProjection: new OpenLayers.Projection(\\\"EPSG:4326\\\"),\\n units: \\\"m\\\",\\n maxResolution: 156543.0339,\\n maxExtent: new OpenLayers.Bounds(-20037508, -20037508, 20037508, 20037508.34)\\n };\\n map = new OpenLayers.Map('map', options);\\n\\n // create Google Mercator layers\\n var gmap = new OpenLayers.Layer.Google(\\\"Google Streets\\\",\\n { sphericalMercator: true, numZoomLevels: 20} );\\n var gsat = new OpenLayers.Layer.Google(\\\"Google Satellite\\\",\\n {type: G_SATELLITE_MAP, sphericalMercator: true, numZoomLevels: 20} );\\n var ghyb = new OpenLayers.Layer.Google(\\\"Google Hybrid\\\",\\n {type: G_HYBRID_MAP, sphericalMercator: true, numZoomLevels: 20});\\n var gter = new OpenLayers.Layer.Google(\\\"Google Terrain\\\",\\n {type: G_PHYSICAL_MAP, sphericalMercator: true, numZoomLevels: 20 });\\n\\n // create Virtual Earth layers\\n OpenLayers.Layer.VirtualEarth.prototype.MAX_ZOOM_LEVEL=19;\\n OpenLayers.Layer.VirtualEarth.prototype.RESOLUTIONS=OpenLayers.Layer.Google.prototype.RESOLUTIONS\\n var veroad = new OpenLayers.Layer.VirtualEarth(\\\"Virtual Earth Roads\\\",\\n {'type': VEMapStyle.Road, 'sphericalMercator': true, numZoomLevels: 20});\\n var veaer = new OpenLayers.Layer.VirtualEarth(\\\"Virtual Earth Aerial\\\",\\n {'type': VEMapStyle.Aerial, 'sphericalMercator': true, numZoomLevels: 20 });\\n var vehyb = new OpenLayers.Layer.VirtualEarth(\\\"Virtual Earth Hybrid\\\",\\n {'type': VEMapStyle.Hybrid, 'sphericalMercator': true});\\n\\n // create Yahoo layer\\n var yahoo = new OpenLayers.Layer.Yahoo(\\\"Yahoo Street\\\",\\n {'sphericalMercator': true});\\n var yahoosat = new OpenLayers.Layer.Yahoo(\\\"Yahoo Satellite\\\",\\n {'type': YAHOO_MAP_SAT, 'sphericalMercator': true});\\n var yahoohyb = new OpenLayers.Layer.Yahoo(\\\"Yahoo Hybrid\\\",\\n {'type': YAHOO_MAP_HYB, 'sphericalMercator': true});\\n\\n // create OSM/OAM layer\\n var osm = new OpenLayers.Layer.TMS( \\\"OpenStreetMap\\\",\\n \\\"http://tile.openstreetmap.org/\\\",\\n { type: 'png', getURL: osm_getTileURL, displayOutsideMaxExtent: true,\\n attribution: '<a href=\\\"http://www.openstreetmap.org/\\\">OpenStreetMap</a>'} );\\n var oam = new OpenLayers.Layer.TMS( \\\"OpenAerialMap\\\",\\n \\\"http://tile.openaerialmap.org/tiles/1.0.0/openaerialmap-900913/\\\",\\n { type: 'png', getURL: osm_getTileURL } );\\n\\n // create TMS Overlay layer\\n var tmsoverlay = new OpenLayers.Layer.TMS( \\\"TMS Overlay\\\", \\\"\\\",\\n { // url: '', serviceVersion: '.', layername: '.',\\n type: '%(tileformat)s', getURL: overlay_getTileURL, alpha: %(has_alpha)s,\\n isBaseLayer: false\\n });\\n if (OpenLayers.Util.alphaHack() == false) { tmsoverlay.setOpacity(0.7); }\\n\\n map.addLayers([gmap, gsat, ghyb, gter, veroad, veaer, vehyb,\\n yahoo, yahoosat, yahoohyb, osm, oam,\\n tmsoverlay]);\\n\\n var switcherControl = new OpenLayers.Control.LayerSwitcher();\\n map.addControl(switcherControl);\\n switcherControl.maximizeControl();\\n\\n map.zoomToExtent( mapBounds.transform(map.displayProjection, map.projection ) );\\n \\\"\\\"\\\" % args\\n\\n elif self.options.profile == 'geodetic':\\n s += \\\"\\\"\\\"\\n var options = {\\n controls: [],\\n projection: new OpenLayers.Projection(\\\"EPSG:4326\\\"),\\n maxResolution: 0.703125,\\n maxExtent: new OpenLayers.Bounds(-180, -90, 180, 90)\\n };\\n map = new OpenLayers.Map('map', options);\\n\\n layer = new OpenLayers.Layer.WMS( \\\"Blue Marble\\\",\\n \\\"http://labs.metacarta.com/wms-c/Basic.py?\\\", {layers: 'satellite' } );\\n map.addLayer(layer);\\n wms = new OpenLayers.Layer.WMS( \\\"VMap0\\\",\\n \\\"http://labs.metacarta.com/wms-c/Basic.py?\\\", {layers: 'basic', format: 'image/png' } );\\n map.addLayer(wms);\\n\\n var tmsoverlay = new OpenLayers.Layer.TMS( \\\"TMS Overlay\\\", \\\"\\\",\\n {\\n serviceVersion: '.', layername: '.', alpha: %(has_alpha)s,\\n type: '%(tileformat)s', getURL: overlay_getTileURL,\\n isBaseLayer: false\\n });\\n map.addLayer(tmsoverlay);\\n if (OpenLayers.Util.alphaHack() == false) { tmsoverlay.setOpacity(0.7); }\\n\\n var switcherControl = new OpenLayers.Control.LayerSwitcher();\\n map.addControl(switcherControl);\\n switcherControl.maximizeControl();\\n\\n map.zoomToExtent( mapBounds );\\n \\\"\\\"\\\" % args\\n\\n elif self.options.profile in ('raster', 'gearth'):\\n s += \\\"\\\"\\\"\\n var options = {\\n controls: [],\\n maxExtent: new OpenLayers.Bounds( %(west)s, %(south)s, %(east)s, %(north)s ),\\n maxResolution: %(rastermaxresolution)f,\\n numZoomLevels: %(rasterzoomlevels)d\\n };\\n map = new OpenLayers.Map('map', options);\\n\\n var layer = new OpenLayers.Layer.TMS( \\\"TMS Layer\\\",\\\"\\\",\\n { url: '', serviceVersion: '.', layername: '.', alpha: %(has_alpha)s,\\n type: '%(tileformat)s', getURL: overlay_getTileURL\\n });\\n map.addLayer(layer);\\n map.zoomToExtent( mapBounds );\\n \\\"\\\"\\\" % args\\n\\n\\n s += \\\"\\\"\\\"\\n map.addControl(new OpenLayers.Control.PanZoomBar());\\n map.addControl(new OpenLayers.Control.MousePosition());\\n map.addControl(new OpenLayers.Control.MouseDefaults());\\n map.addControl(new OpenLayers.Control.KeyboardDefaults());\\n }\\n \\\"\\\"\\\" % args\\n\\n if self.options.profile == 'mercator':\\n s += \\\"\\\"\\\"\\n function osm_getTileURL(bounds) {\\n var res = this.map.getResolution();\\n var x = Math.round((bounds.left - this.maxExtent.left) / (res * this.tileSize.w));\\n var y = Math.round((this.maxExtent.top - bounds.top) / (res * this.tileSize.h));\\n var z = this.map.getZoom();\\n var limit = Math.pow(2, z);\\n\\n if (y < 0 || y >= limit) {\\n return \\\"https://github.com/mj10777/mapmbtiles/img/none.png\\\";\\n } else {\\n x = ((x %% limit) + limit) %% limit;\\n return this.url + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n }\\n }\\n\\n function overlay_getTileURL(bounds) {\\n var res = this.map.getResolution();\\n var x = Math.round((bounds.left - this.maxExtent.left) / (res * this.tileSize.w));\\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\\n var z = this.map.getZoom();\\n if (this.map.baseLayer.name == 'Virtual Earth Roads' || this.map.baseLayer.name == 'Virtual Earth Aerial' || this.map.baseLayer.name == 'Virtual Earth Hybrid') {\\n z = z + 1;\\n }\\n if (mapBounds.intersectsBounds( bounds ) && z >= mapMinZoom && z <= mapMaxZoom ) {\\n //console.log( this.url + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type);\\n return this.url + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n } else {\\n return \\\"https://github.com/mj10777/mapmbtiles/img/none.png\\\";\\n }\\n }\\n \\\"\\\"\\\" % args\\n\\n elif self.options.profile == 'geodetic':\\n s += \\\"\\\"\\\"\\n function overlay_getTileURL(bounds) {\\n bounds = this.adjustBounds(bounds);\\n var res = this.map.getResolution();\\n var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));\\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\\n var z = this.map.getZoom();\\n var path = this.serviceVersion + \\\"/\\\" + this.layername + \\\"/\\\" + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n var url = this.url;\\n if (mapBounds.intersectsBounds( bounds ) && z >= mapMinZoom && z <= mapMaxZoom) {\\n // console.log( this.url + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type);\\n return this.url + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n } else {\\n return \\\"https://github.com/mj10777/mapmbtiles/img/none.png\\\";\\n }\\n }\\n \\\"\\\"\\\" % args\\n\\n elif self.options.profile in ('raster','gearth'):\\n s += \\\"\\\"\\\"\\n function overlay_getTileURL(bounds) {\\n var res = this.map.getResolution();\\n var x = Math.round((bounds.left - this.maxExtent.left) / (res * this.tileSize.w));\\n var y = Math.round((bounds.bottom - this.maxExtent.bottom) / (res * this.tileSize.h));\\n var z = this.map.getZoom();\\n if (x >= 0 && y >= 0) {\\n return this.url + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n } else {\\n return \\\"https://github.com/mj10777/mapmbtiles/img/none.png\\\";\\n }\\n }\\n \\\"\\\"\\\" % args\\n\\n s += \\\"\\\"\\\"\\n function getWindowHeight() {\\n if (self.innerHeight) return self.innerHeight;\\n if (document.documentElement && document.documentElement.clientHeight)\\n return document.documentElement.clientHeight;\\n if (document.body) return document.body.clientHeight;\\n return 0;\\n }\\n\\n function getWindowWidth() {\\n if (self.innerWidth) return self.innerWidth;\\n if (document.documentElement && document.documentElement.clientWidth)\\n return document.documentElement.clientWidth;\\n if (document.body) return document.body.clientWidth;\\n return 0;\\n }\\n\\n function resize() {\\n var map = document.getElementById(\\\"map\\\");\\n var header = document.getElementById(\\\"header\\\");\\n var subheader = document.getElementById(\\\"subheader\\\");\\n map.style.height = (getWindowHeight()-80) + \\\"px\\\";\\n map.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n header.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n subheader.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n if (map.updateSize) { map.updateSize(); };\\n }\\n\\n onresize=function(){ resize(); };\\n\\n </script>\\n </head>\\n <body onload=\\\"init()\\\">\\n <div id=\\\"header\\\"><h1>%(title)s</h1></div>\\n <div id=\\\"subheader\\\">Generated by <a href=\\\"https://github.com/mj10777/mapmbtiles\\\">MapMbTiles</a>/<a href=\\\"http://www.klokan.cz/projects/gdal2mbtiles/\\\">GDAL2MbTiles</a>, Copyright © 2008 <a href=\\\"http://www.klokan.cz/\\\">Klokan Petr Pridal</a>, <a href=\\\"http://www.gdal.org/\\\">GDAL</a> & <a href=\\\"http://www.osgeo.org/\\\">OSGeo</a> <a href=\\\"http://code.google.com/soc/\\\">GSoC</a>\\n <!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->\\n </div>\\n <div id=\\\"map\\\"></div>\\n <script type=\\\"text/javascript\\\" >resize()</script>\\n </body>\\n </html>\\\"\\\"\\\" % args\\n\\n return s\",\n \"def setUp(self):\\n self.plugin = attributePainter(IFACE)\\n self.vector = QgsVectorLayer(os.path.join(self.plugin.plugin_dir,\\\"test\\\",\\\"testdata.gpkg|layername=testdata\\\"),\\\"testdata\\\",\\\"ogr\\\")\",\n \"def loadLayers():\\r\\n\\r\\n # First unload any layers that may already be loaded\\r\\n for myLayer in QgsMapLayerRegistry.instance().mapLayers():\\r\\n QgsMapLayerRegistry.instance().removeMapLayer(myLayer)\\r\\n\\r\\n # Now go ahead and load our layers\\r\\n\\r\\n myRoot = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))\\r\\n myData = os.path.join(myRoot, 'test_data')\\r\\n myData = myData.replace('Tim Sutton', 'TIMSUT~1')\\r\\n myData = myData.replace('Rudi Thiede', 'RUDI~1')\\r\\n\\r\\n # List all layers in the correct order.\\r\\n myFileList = ['test.shp']\\r\\n\\r\\n myCanvasLayers = []\\r\\n for myFile in myFileList:\\r\\n # Extract basename and absolute path\\r\\n myBaseName, myExt = os.path.splitext(myFile)\\r\\n myPath = os.path.join(myData, myFile)\\r\\n\\r\\n # Create QGis Layer Instance\\r\\n if myExt in ['.asc', '.tif']:\\r\\n myLayer = QgsRasterLayer(myPath, myBaseName)\\r\\n elif myExt in ['.shp']:\\r\\n myLayer = QgsVectorLayer(myPath, myBaseName, 'ogr')\\r\\n else:\\r\\n msg = 'File %s had illegal extension' % myPath\\r\\n raise Exception(msg)\\r\\n\\r\\n msg = 'Layer \\\"%s\\\" is not valid' % str(myLayer.source())\\r\\n assert myLayer.isValid(), msg\\r\\n\\r\\n # Add layer to the registry (that QGis knows about)\\r\\n QgsMapLayerRegistry.instance().addMapLayer(myLayer)\\r\\n\\r\\n # Create Map Canvas Layer Instance and add to list\\r\\n myCanvasLayers.append(QgsMapCanvasLayer(myLayer))\\r\\n\\r\\n # Add MCL's to the CANVAS\\r\\n # NOTE: New layers *must* be added to the end of this list, otherwise\\r\\n # tests will break.\\r\\n CANVAS.setLayerSet(myCanvasLayers)\",\n \"def test_core_functionality(self):\\n # Test typing\\n self.run_map_collection(\\n _map_collection=self.example_map\\n )\",\n \"def setgeo(rundata):\\n#-------------------\\n\\n try:\\n geodata = rundata.geodata\\n except:\\n print \\\"*** Error, this rundata has no geodata attribute\\\"\\n raise AttributeError(\\\"Missing geodata attribute\\\")\\n\\n # == setgeo.data values ==\\n\\n geodata.variable_dt_refinement_ratios = True\\n\\n geodata.igravity = 1\\n geodata.gravity = 9.81\\n geodata.icoordsys = 2\\n geodata.Rearth = 6367.5e3\\n geodata.icoriolis = 0\\n\\n # == settsunami.data values ==\\n geodata.sealevel = 0.\\n geodata.drytolerance = 1.e-3\\n geodata.wavetolerance = 1.e-1\\n geodata.depthdeep = 1.e2\\n geodata.maxleveldeep = 4\\n geodata.ifriction = 1\\n geodata.coeffmanning =.025\\n geodata.frictiondepth = 200.\\n\\n\\n # == settopo.data values ==\\n geodata.topofiles = []\\n # for topography, append lines of the form\\n # [topotype, minlevel, maxlevel, t1, t2, fname]\\n geodata.topofiles.append([3, 1, 1, 0., 1e10, 'ebanda.asc'])\\n \\n\\n # == setdtopo.data values ==\\n geodata.dtopofiles = []\\n # for moving topography, append lines of the form: (<= 1 allowed for now!)\\n # [topotype, minlevel, maxlevel, fname]\\n geodata.dtopofiles.append([3,1,3,'BandaArc1852.tt3'])\\n\\n geodata.iqinit = 0\\n geodata.qinitfiles = []\\n\\n # == setgauges.data values ==\\n geodata.gauges = []\\n # for gauges append lines of the form [gaugeno,x,y,t1,t2]\\n geodata.gauges.append([1, 109.000, -7.789, 0., 1e10]) #Cialciap\\n geodata.gauges.append([2, 109.040, -7.722, 0., 1e10]) #Cialciap Bay\\n geodata.gauges.append([3, 110.292, -8.027, 0., 1e10]) #Bantul\\n geodata.gauges.append([4, 111.086, -8.233, 0., 1e10]) #Pacitan\\n geodata.gauges.append([5, 111.558, -8.319, 0., 1e10]) #Pelang Beach\\n geodata.gauges.append([6, 111.968, -8.286, 0., 1e10]) #Sine Beach\\n geodata.gauges.append([7, 112.982, -8.326, 0., 1e10]) #Guying\\n geodata.gauges.append([8, 113.176, -8.286, 0., 1e10]) #Muara\\n geodata.gauges.append([9, 113.461, -8.383, 0., 1e10]) #Puger\\n geodata.gauges.append([10, 113.336, -8.506, 0., 1e10]) #Barung Island\\n geodata.gauges.append([11, 114.110, -8.621, 0., 1e10]) #Lampon\\n geodata.gauges.append([12, 114.396, -8.231, 0., 1e10]) #Banyuwani\\n geodata.gauges.append([13, 112.880, -7.278, 0., 1e10]) #Surabiya\\n geodata.gauges.append([14, 114.965, -8.533, 0., 1e10]) #Tabanan\\n geodata.gauges.append([15, 115.144, -8.697, 0., 1e10]) #Kuta\\n geodata.gauges.append([16, 115.193, -8.848, 0., 1e10]) #Nusa Dua\\n geodata.gauges.append([17, 116.064, -8.586, 0., 1e10]) #Mataram\\n geodata.gauges.append([18, 115.260, -8.727, 0., 1e10]) #Sanur\\n geodata.gauges.append([19, 116.031, -8.873, 0., 1e10]) #Sepi Bay\\n geodata.gauges.append([20, 116.135, -8.872, 0., 1e10]) #Serangan Beach\\n geodata.gauges.append([21, 116.283, -8.902, 0., 1e10]) #Kuta Lombok\\n geodata.gauges.append([22, 116.400, -8.868, 0., 1e10]) #Awang Bay\\n geodata.gauges.append([23, 116.466, -8.924, 0., 1e10]) #Surga Beach\\n geodata.gauges.append([24, 116.744, -8.918, 0., 1e10]) #Maluk\\n geodata.gauges.append([25, 116.833, -9.047, 0., 1e10]) #Tongo\\n geodata.gauges.append([26, 117.199, -9.023, 0., 1e10]) #Linyuk\\n geodata.gauges.append([27, 117.762, -8.939, 0., 1e10]) #Leppu\\n geodata.gauges.append([28, 118.377, -8.785, 0., 1e10]) #Huu\\n geodata.gauges.append([29, 118.172, -8.780, 0., 1e10]) #Rontu Beach\\n geodata.gauges.append([30, 119.403, -8.729, 0., 1e10]) #Mantea Alley\\n geodata.gauges.append([31, 119.374, -9.788, 0., 1e10]) #Nihiwatu\\n geodata.gauges.append([32, 119.466, -9.742, 0., 1e10]) #Waigalli\\n geodata.gauges.append([33, 119.945, -9.975, 0., 1e10]) #Tarimbang Beach\\n geodata.gauges.append([34, 120.183, -10.233, 0., 1e10]) #Lalindi\\n geodata.gauges.append([35, 120.264, -10.257, 0., 1e10]) #Manoekangga\\n geodata.gauges.append([36, 120.546, -10.241, 0., 1e10]) #Baing\\n geodata.gauges.append([37, 120.312, -9.661, 0., 1e10]) #Waingapu\\n geodata.gauges.append([38, 119.871, -8.501, 0., 1e10]) #Labun Badjo\\n geodata.gauges.append([39, 120.604, -8.822, 0., 1e10]) #Mborong\\n geodata.gauges.append([40, 123.560, -10.166, 0., 1e10]) #Kupang\\n geodata.gauges.append([41, 121.824, -10.491, 0., 1e10]) #Baa\",\n \"def test_load_edition_data(self):\\n key = \\\"OL1234W\\\"\\n responses.add(\\n responses.GET,\\n \\\"https://openlibrary.org/works/OL1234W/editions\\\",\\n json={\\\"hi\\\": \\\"there\\\"},\\n )\\n result = self.connector.load_edition_data(key)\\n self.assertEqual(result, {\\\"hi\\\": \\\"there\\\"})\",\n \"def generate_test_data(root: str) -> str:\\n size = (64, 64)\\n folder_path = os.path.join(root, \\\"enviroatlas_lotp\\\")\\n\\n if not os.path.exists(folder_path):\\n os.makedirs(folder_path)\\n\\n for prefix in tile_list:\\n for suffix, data_profile in layer_data_profiles.items():\\n img_path = os.path.join(folder_path, f\\\"{prefix}_{suffix}.tif\\\")\\n img_dir = os.path.dirname(img_path)\\n if not os.path.exists(img_dir):\\n os.makedirs(img_dir)\\n\\n data_profile[\\\"profile\\\"][\\\"height\\\"] = size[0]\\n data_profile[\\\"profile\\\"][\\\"width\\\"] = size[1]\\n data_profile[\\\"profile\\\"][\\\"transform\\\"] = Affine(\\n 1.0, 0.0, 608170.0, 0.0, -1.0, 3381430.0\\n )\\n\\n write_data(\\n img_path,\\n data_profile[\\\"profile\\\"],\\n data_profile[\\\"data_type\\\"],\\n data_profile[\\\"vals\\\"],\\n )\\n\\n # build the spatial index\\n schema = {\\n \\\"geometry\\\": \\\"Polygon\\\",\\n \\\"properties\\\": {\\n \\\"split\\\": \\\"str\\\",\\n \\\"naip\\\": \\\"str\\\",\\n \\\"nlcd\\\": \\\"str\\\",\\n \\\"roads\\\": \\\"str\\\",\\n \\\"water\\\": \\\"str\\\",\\n \\\"waterways\\\": \\\"str\\\",\\n \\\"waterbodies\\\": \\\"str\\\",\\n \\\"buildings\\\": \\\"str\\\",\\n \\\"lc\\\": \\\"str\\\",\\n \\\"prior_no_osm_no_buildings\\\": \\\"str\\\",\\n \\\"prior\\\": \\\"str\\\",\\n },\\n }\\n with fiona.open(\\n os.path.join(folder_path, \\\"spatial_index.geojson\\\"),\\n \\\"w\\\",\\n driver=\\\"GeoJSON\\\",\\n crs=\\\"EPSG:3857\\\",\\n schema=schema,\\n ) as dst:\\n for prefix in tile_list:\\n img_path = os.path.join(folder_path, f\\\"{prefix}_a_naip.tif\\\")\\n with rasterio.open(img_path) as f:\\n geom = shapely.geometry.mapping(shapely.geometry.box(*f.bounds))\\n geom = fiona.transform.transform_geom(\\n f.crs.to_string(), \\\"EPSG:3857\\\", geom\\n )\\n\\n row = {\\n \\\"geometry\\\": geom,\\n \\\"properties\\\": {\\n \\\"split\\\": prefix.split(\\\"/\\\")[0].replace(\\\"_tiles-debuffered\\\", \\\"\\\")\\n },\\n }\\n for suffix, data_profile in layer_data_profiles.items():\\n key = suffix_to_key_map[suffix]\\n row[\\\"properties\\\"][key] = f\\\"{prefix}_{suffix}.tif\\\"\\n dst.write(row)\\n\\n # Create archive\\n archive_path = os.path.join(root, \\\"enviroatlas_lotp\\\")\\n shutil.make_archive(archive_path, \\\"zip\\\", root_dir=root, base_dir=\\\"enviroatlas_lotp\\\")\\n shutil.rmtree(folder_path)\\n md5: str = calculate_md5(archive_path + \\\".zip\\\")\\n return md5\",\n \"def test_geometry_collection_get_bounds():\\n geojson_data = {\\n \\\"geometries\\\": [\\n {\\n \\\"coordinates\\\": [\\n [\\n [-1, 1],\\n [0, 2],\\n [-3, 4],\\n [2, 0],\\n ]\\n ],\\n \\\"type\\\": \\\"Polygon\\\",\\n },\\n ],\\n \\\"type\\\": \\\"GeometryCollection\\\",\\n }\\n assert folium.GeoJson(geojson_data).get_bounds() == [[0, -3], [4, 2]]\",\n \"def test_list_polygons(self, api_client):\\n baker.make(Polygon, _quantity=2)\\n url = self.base_url + \\\"/polygons/\\\"\\n response = api_client().get(url)\\n assert response.status_code == 200\\n assert len(json.loads(response.content)) == 2\",\n \"def testQGISEnvironment(self):\\r\\n\\r\\n r = QgsProviderRegistry.instance()\\r\\n #for item in r.providerList():\\r\\n # print str(item)\\r\\n\\r\\n print 'Provider count: %s' % len(r.providerList())\\r\\n assert 'gdal' in r.providerList()\\r\\n assert 'ogr' in r.providerList()\",\n \"def test_access(geometry):\\n geometry.print_list_of_geos()\\n geometry.print_list_of_geos_children()\\n\\n logger.info('TOP GEO:')\\n top_geo = geometry.get_top_geo()\\n top_geo.print_geo_children()\\n\\n logger.info('INTERMEDIATE GEO (QUAD):')\\n geo = geometry.get_geo('QUAD:V1', 0)\\n #geo = geometry.get_top_geo()\\n geo.print_geo_children()\\n\\n t0_sec = time()\\n X,Y,Z = geo.get_pixel_coords(do_tilt=True)\\n #X,Y = geo.get_2d_pixel_coords()\\n s = 'X: %s' % str(X)\\n s+= '\\\\n Consumed time to get 3d pixel coordinates = %7.3f sec' % (time()-t0_sec)\\n s+= '\\\\n Geometry object: %s:%d X.shape:%s' % (geo.oname, geo.oindex, str(X.shape))\\n logger.info(s)\\n\\n logger.info('Test of print_pixel_coords() for quad:')\\n geometry.print_pixel_coords('QUAD:V1', 1)\\n logger.info('Test of print_pixel_coords() for CSPAD:')\\n geometry.print_pixel_coords()\\n\\n s = 'Test of get_pixel_areas() for QUAD:'\\n A = geo.get_pixel_areas()\\n s+= '\\\\n Geometry object: %s:%d A.shape:%s' % (geo.oname, geo.oindex, str(A.shape))\\n s+= '\\\\n A[0,0:5,190:198]:\\\\n' + str(A[0,0:5,190:198])\\n logger.info(s)\\n\\n s = 'Test of get_pixel_areas() for CSPAD:'\\n A = top_geo.get_pixel_areas()\\n s+= '\\\\n Geometry object: %s:%d A.shape:%s' % (geo.oname, geo.oindex, str(A.shape))\\n s+= '\\\\n A[0,0,0:5,190:198]:\\\\n' + str(A[0,0,0:5,190:198])\\n logger.info(s)\\n\\n s = 'Test of get_size_geo_array()'\\n s+= '\\\\n for QUAD: %d' % geo.get_size_geo_array()\\n s+= '\\\\n for CSPAD: %d' % top_geo.get_size_geo_array()\\n logger.info(s)\\n\\n s = 'Test of get_pixel_scale_size()'\\n s+= '\\\\n for QUAD : %8.2f' % geo.get_pixel_scale_size()\\n s+= '\\\\n for CSPAD : %8.2f' % top_geo.get_pixel_scale_size()\\n s+= '\\\\n for geometry: %8.2f' % geometry.get_pixel_scale_size()\\n logger.info(s)\\n\\n s = 'Test of get_dict_of_comments():'\\n d = geometry.get_dict_of_comments()\\n s+= '\\\\n d[0] = %s' % str(d[0])\\n logger.info(s)\",\n \"def test_initialized() -> None:\\n MapieRegressor()\",\n \"def test_render_world_map():\\n gdpinfo = {\\n \\\"gdpfile\\\": \\\"isp_gdp.csv\\\",\\n \\\"separator\\\": \\\",\\\",\\n \\\"quote\\\": '\\\"',\\n \\\"min_year\\\": 1960,\\n \\\"max_year\\\": 2015,\\n \\\"country_name\\\": \\\"Country Name\\\",\\n \\\"country_code\\\": \\\"Country Code\\\"\\n }\\n\\n # Get pygal country code map\\n pygal_countries = pygal.maps.world.COUNTRIES\\n #pygal_countries = {'KEN':'Kenya', 'IDN':'Indonesia', 'IND':'India', \\\\\\n #'USA':'United States of America'}\\n\\n # 1960\\n #render_world_map(gdpinfo, pygal_countries, \\\"1960\\\", \\\"isp_gdp_world_name_1960.svg\\\")\\n\\n # 1980\\n #render_world_map(gdpinfo, pygal_countries, \\\"1980\\\", \\\"isp_gdp_world_name_1980.svg\\\")\\n\\n # 2000\\n #render_world_map(gdpinfo, pygal_countries, \\\"2000\\\", \\\"isp_gdp_world_name_2000.svg\\\")\\n\\n # 2010\\n render_world_map(gdpinfo, pygal_countries, \\\"2010\\\", \\\"isp_gdp_world_name_2010.svg\\\")\",\n \"def test():\\n root_path = os.path.dirname(os.path.realpath(__file__))\\n test_path = os.path.join(root_path, 'test_files')\\n with open(os.path.join(test_path, 'hexagons0.geojson')) as f:\\n hexagons_old = load(f)\\n with open(os.path.join(test_path, 'hexagons1.geojson')) as f:\\n hexagons_new = load(f) \\n return hexagons_new, hexagons_old\",\n \"def test_main_no_argument():\\n assert geojson2fromto.main() is False\",\n \"def test_update_zoom_rooms_location_structure(self):\\n pass\",\n \"def test_get_polygons_nested(self):\\n path = os.path.join(BASE_DIR, \\\"tests\\\", \\\"fixtures\\\", \\\"kenya.zip\\\")\\n zip_file = zipfile.ZipFile(path)\\n shapefile = get_shapefile(zip_file)\\n\\n with TemporaryDirectory() as temp_dir:\\n tpath = temp_dir\\n # Extract all files to Temporary Directory\\n zip_file.extractall(tpath)\\n # concatenate Shapefile path\\n shp_path = os.path.join(tpath, shapefile)\\n # Make the shapefile a DataSource\\n data_source = DataSource(shp_path)\\n layer = data_source[0]\\n # Get geoms for all Polygons in Datasource\\n geom_object_list = layer.get_geoms()\\n polygons = get_polygons(geom_object_list)\\n\\n # check that we get the expected number of Polygons\\n self.assertEqual(431, len(polygons))\\n\\n for item in polygons:\\n self.assertTrue(isinstance(item, Polygon))\\n\\n # lets check get_polygons from the nested multipolygons\\n multipolygon_list = [\\n _ for _ in geom_object_list if isinstance(_, geometries.MultiPolygon)\\n ]\\n\\n self.assertEqual(12, len(multipolygon_list))\\n other_polygons = get_polygons(multipolygon_list)\\n # check that we get the expected number of Polygons\\n self.assertEqual(52, len(other_polygons))\\n for item in other_polygons:\\n self.assertTrue(isinstance(item, Polygon))\\n # if we add all polygons, do we get the expected number?\\n # 379 is the number of poolygons excluding nested multipolygons\\n # see the `test_get_polygons_ignore_invalid` test below\\n self.assertEqual(431, 379 + len(other_polygons))\",\n \"def test_render_world_map():\\n gdpinfo = {\\n \\\"gdpfile\\\": \\\"isp_gdp.csv\\\",\\n \\\"separator\\\": \\\",\\\",\\n \\\"quote\\\": '\\\"',\\n \\\"min_year\\\": 1960,\\n \\\"max_year\\\": 2015,\\n \\\"country_name\\\": \\\"Country Name\\\",\\n \\\"country_code\\\": \\\"Country Code\\\"\\n }\\n\\n codeinfo = {\\n \\\"codefile\\\": \\\"isp_country_codes.csv\\\",\\n \\\"separator\\\": \\\",\\\",\\n \\\"quote\\\": '\\\"',\\n \\\"plot_codes\\\": \\\"ISO3166-1-Alpha-2\\\",\\n \\\"data_codes\\\": \\\"ISO3166-1-Alpha-3\\\"\\n }\\n\\n # Get pygal country code map\\n pygal_countries = pygal.maps.world.COUNTRIES\\n\\n # 1960\\n render_world_map(gdpinfo, codeinfo, pygal_countries, \\\"1960\\\", \\\"isp_gdp_world_code_1960.svg\\\")\\n\\n # 1980\\n render_world_map(gdpinfo, codeinfo, pygal_countries, \\\"1980\\\", \\\"isp_gdp_world_code_1980.svg\\\")\\n\\n # 2000\\n render_world_map(gdpinfo, codeinfo, pygal_countries, \\\"2000\\\", \\\"isp_gdp_world_code_2000.svg\\\")\\n\\n # 2010\\n render_world_map(gdpinfo, codeinfo, pygal_countries, \\\"2010\\\", \\\"isp_gdp_world_code_2010.svg\\\")\",\n \"def test_render_world_map():\\n gdpinfo = {\\n \\\"gdpfile\\\": \\\"isp_gdp.csv\\\",\\n \\\"separator\\\": \\\",\\\",\\n \\\"quote\\\": '\\\"',\\n \\\"min_year\\\": 1960,\\n \\\"max_year\\\": 2015,\\n \\\"country_name\\\": \\\"Country Name\\\",\\n \\\"country_code\\\": \\\"Country Code\\\"\\n }\\n\\n codeinfo = {\\n \\\"codefile\\\": \\\"isp_country_codes.csv\\\",\\n \\\"separator\\\": \\\",\\\",\\n \\\"quote\\\": '\\\"',\\n \\\"plot_codes\\\": \\\"ISO3166-1-Alpha-2\\\",\\n \\\"data_codes\\\": \\\"ISO3166-1-Alpha-3\\\"\\n }\\n\\n # Get pygal country code map\\n pygal_countries = pygal.maps.world.COUNTRIES\\n\\n # 1960\\n render_world_map(gdpinfo, codeinfo, pygal_countries, \\\"1960\\\", \\\"isp_gdp_world_code_1960.svg\\\")\\n\\n # 1980\\n render_world_map(gdpinfo, codeinfo, pygal_countries, \\\"1980\\\", \\\"isp_gdp_world_code_1980.svg\\\")\\n\\n # 2000\\n render_world_map(gdpinfo, codeinfo, pygal_countries, \\\"2000\\\", \\\"isp_gdp_world_code_2000.svg\\\")\\n\\n # 2010\\n render_world_map(gdpinfo, codeinfo, pygal_countries, \\\"2010\\\", \\\"isp_gdp_world_code_2010.svg\\\")\",\n \"def test_ocean() -> None:\\n cfg = load_config()\\n setup = ModelSetup(str(TEST_DIREC), cfg)\\n ocean = Ocean(cfg, setup)\\n ocean.compile_all()\\n if cfg.run:\\n ocean.run_all()\\n if cfg.animate:\\n ocean.animate_all()\",\n \"def test_gelir_api(self):\\n response = self.client.get(reverse('gelir-json', args=[self.sample_type]))\\n self.assertContains(response, self.proband.gel_id)\\n self.assertEquals(response.status_code, 200)\",\n \"def get_webmap_operational_layers(web_map, layer_name):\\r\\n web_map_definition = web_map.definition\\r\\n for layer in web_map_definition['operationalLayers']:\\r\\n if layer_name in layer['title']:\\r\\n operational_layer = layer\\r\\n\\r\\n return operational_layer\",\n \"def test_convert_features(convert_features_parameters):\\n test_input = convert_features_parameters[0]\\n expected_output = convert_features_parameters[1]\\n assert geojson2fromto.convert(test_input) == expected_output\",\n \"def wfs_common(request, response, mode, spatial_mode='wfs'):\\n\\n outputpath = configuration.get_config_value('server', 'outputpath')\\n outputurl = configuration.get_config_value('server', 'outputurl')\\n\\n list_of_files = []\\n for one_resource in request.inputs['resource']:\\n # Download if not opendap\\n # Adding a maximum file size from a server config file would\\n # be possible here...\\n try:\\n nc_file = opendap_or_download(\\n one_resource.data,\\n auth_tkt_cookie=request.http_request.cookies,\\n output_path='/tmp')\\n except:\\n raise Exception(traceback.format_exc())\\n list_of_files.append(nc_file)\\n\\n if ('typename' in request.inputs) and ('featureids' in request.inputs):\\n typename = request.inputs['typename'][0].data\\n features = [f.data for f in request.inputs['featureids']]\\n if 'geoserver' in request.inputs:\\n geoserver = request.inputs['geoserver'][0].data\\n else:\\n geoserver = configuration.get_config_value('extra', 'geoserver')\\n if 'mosaic' in request.inputs:\\n mosaic = request.inputs['mosaic'][0].data\\n else:\\n mosaic = False\\n try:\\n conn = WebFeatureService(url=geoserver, version='2.0.0')\\n resp = conn.getfeature([typename], featureid=features,\\n outputFormat='application/json')\\n feature = json.loads(resp.read())\\n crs_code = owslib.crs.Crs(\\n feature['crs']['properties']['name']).code\\n crs = ocgis.CoordinateReferenceSystem(epsg=crs_code)\\n geom = [\\n {'geom': shape(f['geometry']), 'crs': crs,\\n 'properties': f['properties']}\\n for f in feature['features']]\\n except Exception as e:\\n msg = ('Failed to fetch features.\\\\ngeoserver: {0} \\\\n'\\n 'typename: {1}\\\\nfeatures {2}\\\\n{3}').format(\\n geoserver, typename, features, e)\\n raise Exception(msg)\\n if mosaic:\\n new_geom = geom[0]\\n for merge_geom in geom[1:]:\\n new_geom['geom'] = new_geom['geom'].union(merge_geom['geom'])\\n new_geom['properties'] = {'bbox': feature['bbox']}\\n geom = new_geom\\n elif spatial_mode == 'bbox':\\n geom = [[request.inputs['lon0'][0].data,\\n request.inputs['lat0'][0].data,\\n request.inputs['lon1'][0].data,\\n request.inputs['lat1'][0].data]]\\n else:\\n geom = [None]\\n\\n if ('initial_datetime' in request.inputs) and \\\\\\n ('final_datetime' in request.inputs):\\n tr = [request.inputs['initial_datetime'][0].data,\\n request.inputs['final_datetime'][0].data]\\n else:\\n tr = None\\n\\n try:\\n output_files = []\\n output_urls = []\\n mv_dir = tempfile.mkdtemp(dir=outputpath)\\n os.chmod(mv_dir, 0755)\\n\\n for one_file in list_of_files:\\n file_name = os.path.basename(one_file)\\n if file_name[-3:] == '.nc':\\n file_prefix = file_name[:-3]\\n else:\\n file_prefix = file_name\\n ocgis.env.DIR_OUTPUT = tempfile.mkdtemp(dir=os.getcwd())\\n ocgis.env.OVERWRITE = True\\n nc = netCDF4.Dataset(one_file, 'r')\\n var_names = guess_main_variables(nc)\\n nc.close()\\n rd = ocgis.RequestDataset(one_file, var_names)\\n for i, one_geom in enumerate(geom):\\n if one_geom is None:\\n ocgis_geom = None\\n elif spatial_mode == 'bbox':\\n ocgis_geom = one_geom\\n else:\\n ocgis_geom = one_geom['geom']\\n if mode == 'averager':\\n # Extent errors are ignored\\n try:\\n # Here with aggregate=True, can't pass the whole\\n # one_geom dictionary, is this a sign that this does\\n # not support multipolygon?\\n ops = ocgis.OcgOperations(\\n dataset=rd, geom=ocgis_geom,\\n spatial_operation='clip', aggregate=True,\\n time_range=tr, output_format='nc',\\n interpolate_spatial_bounds=True,\\n prefix=file_prefix).execute()\\n except ExtentError:\\n continue\\n elif mode == 'subsetter':\\n # Extent errors are ignored\\n try:\\n # Still having problem with the geometry, previously\\n # was passing geom=[one_geom]\\n ops = ocgis.OcgOperations(\\n dataset=rd, geom=ocgis_geom, time_range=tr,\\n output_format='nc',\\n interpolate_spatial_bounds=True,\\n prefix=file_prefix).execute()\\n except ExtentError:\\n continue\\n # Here, the global attribute 'subset_typename' and\\n # 'subset_featureid' are added to the NetCDF file to keep\\n # track of the feature used.\\n if (geom != [None]) and (spatial_mode == 'wfs'):\\n with netCDF4.Dataset(ops, 'a') as nc:\\n nc.subset_typename = typename\\n nc.subset_featureid = features[i]\\n\\n if (spatial_mode == 'wfs') and \\\\\\n ('featureids' in request.inputs):\\n mv_name = '{0}_{1}.nc'.format(\\n os.path.basename(ops)[:-3], features[i])\\n else:\\n mv_name = '{0}_{1}.nc'.format(\\n os.path.basename(ops)[:-3], 'subset')\\n\\n mv_file = os.path.join(mv_dir, mv_name)\\n shutil.move(ops, mv_file)\\n output_files.append(mv_file)\\n shutil.rmtree(ocgis.env.DIR_OUTPUT)\\n\\n # Cover the case of an online wps server and the offline\\n # mode for tests.\\n if outputurl == 'file:///tmp':\\n disk_file = 'file:///' + mv_file.lstrip('/')\\n output_urls.append(disk_file)\\n else:\\n url_file = os.path.join(\\n outputurl, os.path.basename(mv_dir), mv_name)\\n output_urls.append(url_file)\\n except:\\n raise Exception(traceback.format_exc())\\n\\n # If only ExtentError occured, the output_urls will be empty...\\n if not output_urls:\\n raise ExtentError(message=\\\"All ocgis calls returned ExtentError.\\\")\\n\\n time_str = time.strftime(\\\"%Y-%m-%dT%H:%M:%SZ\\\", time.gmtime())\\n output_file_name = \\\"result_%s_.json\\\" % (time_str,)\\n output_file = os.path.join('/tmp', output_file_name)\\n f1 = open(output_file, 'w')\\n f1.write(json.dumps(output_urls))\\n f1.close()\\n response.outputs['output'].file = output_file\\n response.outputs['output'].output_format = json_format\\n response.update_status(\\\"done\\\", 100)\\n return response\",\n \"def test_no_crs():\\n df = world.copy()\\n df.crs = None\\n m = view(df)\\n assert \\\"openstreetmap\\\" not in m.to_dict()[\\\"children\\\"].keys()\",\n \"def test_loading_a_simple_layer(self, sdoc):\\n tdoc = ezdxf.new()\\n loader = xref.Loader(sdoc, tdoc)\\n loader.load_layers([\\\"first\\\"])\\n loader.execute()\\n assert document_has_no_errors(tdoc) is True\\n\\n layer = tdoc.layers.get(\\\"first\\\")\\n\\n assert layer is not sdoc.layers.get(\\\"first\\\"), \\\"expected a copy\\\"\\n assert layer.dxf.name == \\\"FIRST\\\", \\\"expected the original layer name\\\"\\n assert layer.doc is tdoc, \\\"bound to wrong document\\\"\\n assert layer.dxf.handle in tdoc.entitydb, \\\"entity not in database\\\"\\n assert layer.dxf.owner == tdoc.layers.head.dxf.handle, \\\"invalid owner handle\\\"\\n assert layer.dxf.material_handle == tdoc.materials[\\\"global\\\"].dxf.handle\",\n \"def preview_ways(geodataframe):\\n\\n # Map tiles from contextily are provided in the Web Mercator coordinate reference system (EPSG:3857).\\n gdf_wm = geodataframe.to_crs(epsg='3857')\\n # Add a column for the centre of each geometry\\n gdf_wm['centroid'] = gdf_wm.geometry.centroid\\n # Create plot using matplotlib functionality\\n ax = gdf_wm.plot(figsize=(10, 6), color='blue', linewidth=2)\\n gdf_wm.centroid.plot(ax=ax, marker='o', color='red', alpha=0.5, markersize=40)\\n # Add a basemap from contextily. This map should look a lot like Overpass Turbo!\\n ctx.add_basemap(ax, source=ctx.providers.OpenStreetMap.Mapnik)\",\n \"def feature_layer_popup(map_service_name, map_service_type, web_map, layer_name):\\r\\n # get operational layer of a web map\\r\\n operational_layer = get_webmap_operational_layers(\\r\\n web_map=web_map,\\r\\n layer_name=layer_name\\r\\n )\\r\\n # get feature layer from feature layer collection\\r\\n target_layer = get_feature_layer_from_feature_service(\\r\\n map_service_name=map_service_name,\\r\\n map_service_type=map_service_type,\\r\\n layer_name=layer_name\\r\\n )\\r\\n\\r\\n # set popup info for the operational layer based on the type of services\\r\\n # hosted feature layer\\r\\n if operational_layer['popupInfo']:\\r\\n operational_layer_popup = operational_layer['popupInfo']\\r\\n\\r\\n # registered feature layer\\r\\n else:\\r\\n # set popup info\\r\\n operational_layer.update(popupInfo=target_layer['popupInfo'])\\r\\n operational_layer_popup = operational_layer['popupInfo']\\r\\n\\r\\n # set title for popup\\r\\n operational_layer_popup['title'] = layer_name\\r\\n\\r\\n # set description for popup\\r\\n layer_popup_description = customize_popup_description(\\r\\n operational_layer=operational_layer,\\r\\n map_service_type=map_service_type\\r\\n )\\r\\n operational_layer_popup['description'] = layer_popup_description\\r\\n\\r\\n # set decimal places and digit separators for numeric fields\\r\\n for field in operational_layer_popup['fieldInfos']:\\r\\n for fld in target_layer.properties.fields:\\r\\n # double\\r\\n if field['fieldName'] == fld.name and fld.type == \\\"esriFieldTypeDouble\\\":\\r\\n field.update({\\\"format\\\": {\\\"places\\\": 2, \\\"digitSeparator\\\": False}})\\r\\n # integer\\r\\n elif field['fieldName'] == fld.name and fld.type == \\\"esriFieldTypeInteger\\\":\\r\\n field.update({\\\"format\\\": {\\\"places\\\": 0, \\\"digitSeparator\\\": False}})\\r\\n\\r\\n print('customizing popup for', operational_layer['title'])\",\n \"def test_alien_data(self):\",\n \"def output_grid_information():\\n # translate = [-74.26, 40.50]\\n # scale = [0.02, 0.02]\\n # step = 1\\n\\n translate = [0, 0]\\n scale = [1, 1]\\n step = 0.02\\n\\n lon_limits = [(-74.26 - translate[0]) / scale[0], (-73.76 - translate[0]) / scale[0]]\\n lat_limits = [(40.48 - translate[1]) / scale[1], (40.94 - translate[1]) / scale[1]]\\n\\n lons = np.arange(lon_limits[0], lon_limits[1] - step, step)\\n lats = np.arange(lat_limits[0], lat_limits[1] - step, step)\\n\\n all_json = {\\n \\\"type\\\": \\\"FeatureCollection\\\"\\n }\\n\\n gr_id = 0\\n grid_df = pd.DataFrame(columns=['gr_id', 'c_lat', 'c_lon', 's_lon', 'w_lat', 'n_lon', 'e_lat'])\\n features = []\\n\\n for lat in lats:\\n for lon in lons:\\n w_lon = lon\\n e_lon = lon + step\\n s_lat = lat\\n n_lat = lat + step\\n\\n c_lon = lon + step / 2\\n c_lat = lat + step / 2\\n\\n grid_df = grid_df.append(pd.DataFrame({\\\"gr_id\\\": [gr_id],\\n \\\"c_lon\\\": [c_lon], \\\"c_lat\\\": [c_lat],\\n \\\"w_lon\\\": [w_lon], \\\"s_lat\\\": [s_lat],\\n \\\"e_lon\\\": [e_lon], \\\"n_lat\\\": [n_lat]}))\\n\\n coor = [[[s_lat, w_lon], [n_lat, w_lon], [n_lat, e_lon],\\n [s_lat, e_lon], [s_lat, w_lon]]]\\n\\n feature = {\\n \\\"type\\\": \\\"Feature\\\",\\n \\\"geometry\\\": {\\n \\\"type\\\": \\\"Polygon\\\",\\n \\\"coordinates\\\": coor\\n },\\n \\\"properties\\\": {\\n \\\"id\\\": str(gr_id)\\n }\\n }\\n\\n features.append(feature)\\n\\n gr_id += 1\\n\\n all_json['features'] = features\\n\\n with open(BaseDir + '/grid.geojson', 'w') as f:\\n json.dump(all_json, f)\\n\\n grid_df.to_csv(BaseDir + '/grid_locs.csv', index=False)\",\n \"def testGetActiveVectorLayer(self):\\r\\n #check when no layers are loaded that an exception is thrown\\r\\n myExceptionFlag = False\\r\\n myLayer = None\\r\\n try:\\r\\n myLayer = self.bucketFill.getActiveVectorLayer()\\r\\n except:\\r\\n #good we expect an error!\\r\\n myExceptionFlag = True\\r\\n myMessage = ('Expected an exception to be raised when no layer'\\r\\n 'is present, but none was received.')\\r\\n assert myExceptionFlag == True, myMessage\\r\\n\\r\\n # Now test that when a layer is loaded that we get\\r\\n # the expected response\\r\\n loadLayers()\\r\\n CANVAS.zoomToFullExtent()\\r\\n try:\\r\\n myLayer = self.bucketFill.getActiveVectorLayer()\\r\\n except:\\r\\n myErrorMessage = 'Layer could not be identified as a vector.'\\r\\n assert myLayer.isValid(), myErrorMessage\",\n \"def run_script(iface):\\n layer = QgsVectorLayer('Polygon?crs=epsg:4326', 'Mississippi' , \\\"memory\\\")\\n pr = layer.dataProvider()\\n poly = QgsFeature()\\n geom = QgsGeometry.fromWkt(\\\"\\\"\\\"POLYGON ((-88.82 34.99,\\n -88.09 34.89,\\n -88.39 30.34,\\n -89.57 30.18,\\n -89.73 31,\\n -91.63 30.99,\\n -90.87 32.37,\\n -91.23 33.44,\\n -90.93 34.23,\\n -90.30 34.99,\\n -88.82 34.99))\\\"\\\"\\\")\\n poly.setGeometry(geom)\\n pr.addFeatures([poly])\\n layer.updateExtents()\\n QgsMapLayerRegistry.instance().addMapLayers([layer])\",\n \"def home(request):\\n gefs_layers,geoserver_wms_url,geoserver_workspace = listLayers()\\n\\n context = {\\n 'gefs_layers':json.dumps(gefs_layers),\\n 'geoserver_wms_url':geoserver_wms_url,\\n 'geoserver_workspace':geoserver_workspace\\n }\\n\\n return render(request, 'gefs/home.html', context)\",\n \"def test_api_msa_endpoint(self):\\n params = {'lender': '90000451965', 'metro': '49180'}\\n url = reverse(msa)\\n resp = self.client.get(url, params)\\n result_dict = json.loads(resp.content)\\n self.assertTrue(isinstance(result_dict, dict))\\n self.assertContains(resp, 'features')\",\n \"def testGetLayerInfo(self):\\n container_obj = self.explorer_object.GetContainer(\\n 'de44dd97cfd1c8d1c1aad7f75a435603991a7a39fa4f6b20a69bf4458809209c')\\n layer_info = container_obj.GetLayerInfo(\\n '1cee97b18f87b5fa91633db35f587e2c65c093facfa2cbbe83d5ebe06e1d9125')\\n self.assertEqual('2018-12-26T08:20:42.831353376Z', layer_info['created'])\\n self.assertEqual(['/bin/sh', '-c', '#(nop) ', 'CMD [\\\"sh\\\"]'],\\n layer_info['container_config']['Cmd'])\",\n \"def get_test_ODs() -> List[dict]:\\n ods = gpd.read_file('data/tests/test_OD_lines.geojson')\\n ods['orig_point'] = [geom.interpolate(0, normalized=True) for geom in ods['geometry']]\\n ods['dest_point'] = [geom.interpolate(1, normalized=True) for geom in ods['geometry']]\\n ods['orig_latLon'] = [get_lat_lon_from_geom(geom) for geom in ods['orig_point']]\\n ods['dest_latLon'] = [get_lat_lon_from_geom(geom) for geom in ods['dest_point']]\\n od_dicts = ods.to_dict(orient='records')\\n od_dict = {}\\n for od in od_dicts:\\n od_dict[int(od['OD'])] = od\\n return od_dict\",\n \"def test_get_work_from_edition_data(self):\\n data = {\\\"works\\\": [{\\\"key\\\": \\\"/work/OL1234W\\\"}]}\\n responses.add(\\n responses.GET,\\n \\\"https://openlibrary.org/work/OL1234W\\\",\\n json={\\\"hi\\\": \\\"there\\\"},\\n status=200,\\n )\\n result = self.connector.get_work_from_edition_data(data)\\n self.assertEqual(result, {\\\"hi\\\": \\\"there\\\"})\",\n \"def test_get_clouds(self):\\n pass\",\n \"def zonal_stats(src_poly, src_raster, operator=['mean'], features=None):\\n assert src_raster.geo_transform is not None, \\\"src_raster.geo_transform should not be None\\\"\\n assert isinstance(operator, list), \\\"operator should be a list of string. ex: ['mean']\\\"\\n features = list(range(src_raster.bands)) if features is None else features\\n assert len(features) == src_raster.bands, \\\"length of features should equals number of bands of the raster\\\"\\n df_shp = src_poly.copy()\\n df_shp['poly_idx'] = list(range(len(df_shp)))\\n df_shp['poly_idx'] = df_shp['poly_idx'].astype('float')\\n poly_rst = tgp.ShapeGrid.rasterize_layer(df_shp, src_raster.rows, src_raster.cols, src_raster.geo_transform, 'poly_idx', all_touched=True, no_data_value=np.nan)\\n X_combine = np.concatenate([poly_rst.data, src_raster.data], axis=-1)\\n X_combine_df = pd.DataFrame(X_combine.reshape(-1, src_raster.bands))\\n X_groupby = X_combine_df.groupby(0, as_index=False)\\n for op in operator:\\n columns = {0:'poly_idx'}\\n for f_idx, f in enumerate(features):\\n columns[f_idx+1] = f'zonal_{op}_{f}'\\n if op == 'mean':\\n df_shp = df_shp.merge(X_groupby.mean().rename(columns=columns), on='poly_idx', how='left')\\n elif op == 'max':\\n df_shp = df_shp.merge(X_groupby.max().rename(columns=columns), on='poly_idx', how='left')\\n elif op == 'min':\\n df_shp = df_shp.merge(X_groupby.min().rename(columns=columns), on='poly_idx', how='left')\\n elif op == 'median':\\n df_shp = df_shp.merge(X_groupby.median().rename(columns=columns), on='poly_idx', how='left')\\n elif op == 'sum':\\n df_shp = df_shp.merge(X_groupby.sum().rename(columns=columns), on='poly_idx', how='left')\\n elif op == 'std':\\n df_shp = df_shp.merge(X_groupby.std().rename(columns=columns), on='poly_idx', how='left')\\n elif op == 'count':\\n df_shp = df_shp.merge(X_groupby.count().rename(columns=columns), on='poly_idx', how='left')\\n else:\\n assert False, \\\"no this operator\\\"\\n return df_shp\",\n \"def test_simple_pass():\\n m = view(nybb)\\n m = view(world)\\n m = view(cities)\\n m = view(world.geometry)\",\n \"def maya_useNewAPI():\\n\\n pass\",\n \"def SetUpLayerManager(self):\\n pass\",\n \"def define_map(window=False, toolbar=False, config=None):\\n\\n if not config:\\n config = gis.get_config()\\n\\n if not deployment_settings.get_security_map() or s3_has_role(\\\"MapAdmin\\\"):\\n catalogue_toolbar = True\\n else:\\n catalogue_toolbar = False\\n\\n # @ToDo: Make these configurable\\n search = True\\n catalogue_overlays = True\\n\\n if config.wmsbrowser_url:\\n wms_browser = {\\\"name\\\" : config.wmsbrowser_name,\\n \\\"url\\\" : config.wmsbrowser_url}\\n else:\\n wms_browser = None\\n\\n # 'normal', 'mgrs' or 'off'\\n mouse_position = deployment_settings.get_gis_mouse_position()\\n\\n # http://eden.sahanafoundation.org/wiki/BluePrintGISPrinting\\n print_service = deployment_settings.get_gis_print_service()\\n if print_service:\\n print_tool = {\\\"url\\\": print_service}\\n else:\\n print_tool = {}\\n\\n # Internal Feature Layers\\n feature_queries = []\\n feature_layers = db(db.gis_layer_feature.enabled == True).select()\\n for layer in feature_layers:\\n if layer.role_required and not auth.s3_has_role(layer.role_required):\\n # Skip layer is it i srestricted & we don't have the required role\\n continue\\n if layer.filter_field and layer.filter_value:\\n table = db[\\\"%s_%s\\\" % (layer.module, layer.resource)]\\n # Check for multiples\\n filter_values = layer.filter_value.split(\\\"/\\\")\\n if len(filter_values) == 1:\\n _filter = (table[layer.filter_field] == filter_values[0])\\n else:\\n null = False\\n for i in range(len(filter_values)):\\n if filter_values[i] == \\\"\\\":\\n # Catch NULLs\\n null = True\\n if null:\\n _filter = ((table[layer.filter_field].belongs(filter_values)) | \\\\\\n (table[layer.filter_field] == None))\\n else:\\n _filter = (table[layer.filter_field].belongs(filter_values))\\n\\n else:\\n _filter = None\\n _layer = gis.get_feature_layer(layer.module,\\n layer.resource,\\n layer.name,\\n layer.popup_label,\\n config=config,\\n marker_id=layer.marker_id,\\n _filter=_filter,\\n active=layer.visible,\\n polygons=layer.polygons,\\n opacity=layer.opacity)\\n if _layer:\\n feature_queries.append(_layer)\\n\\n map = gis.show_map(\\n window=window,\\n catalogue_toolbar=catalogue_toolbar,\\n wms_browser = wms_browser,\\n toolbar=toolbar,\\n search=search,\\n catalogue_overlays=catalogue_overlays,\\n feature_queries=feature_queries,\\n mouse_position = mouse_position,\\n print_tool = print_tool\\n )\\n\\n return map\",\n \"def get_feature_layers_collection(project_name):\\r\\n feature_layers_collection = get_portal_item(\\r\\n portal_connection=PORTAL_CONNECTION,\\r\\n item_name=\\\"{}_Map\\\".format(project_name),\\r\\n item_type=\\\"Feature Layer\\\"\\r\\n )\\r\\n\\r\\n return feature_layers_collection\",\n \"def test_path_layer_cache(self):\\n cache = caches[settings.MAPENTITY_CONFIG['GEOJSON_LAYERS_CACHE_BACKEND']]\\n\\n obj = self.modelfactory(draft=False)\\n self.modelfactory(draft=True)\\n\\n # There are 7 queries to get layer without drafts\\n with self.assertNumQueries(5):\\n response = self.client.get(obj.get_layer_url())\\n self.assertEqual(len(response.json()['features']), 2)\\n\\n # We check the content was created and cached without no_draft key\\n # We check that any cached content can be found without no_draft (we still didn't ask for it)\\n last_update_no_draft = Path.no_draft_latest_updated()\\n last_update = Path.latest_updated()\\n geojson_lookup_no_draft = 'en_path_%s_nodraft_json_layer' % last_update_no_draft.strftime('%y%m%d%H%M%S%f')\\n geojson_lookup = 'en_path_%s_json_layer' % last_update.strftime('%y%m%d%H%M%S%f')\\n content_no_draft = cache.get(geojson_lookup_no_draft)\\n content = cache.get(geojson_lookup)\\n\\n self.assertIsNone(content_no_draft)\\n self.assertEqual(response.content, content.content)\\n\\n # We have 1 less query because the generation of paths was cached\\n with self.assertNumQueries(3):\\n self.client.get(obj.get_layer_url())\\n\\n self.modelfactory(draft=True)\\n\\n # Cache is updated when we add a draft path\\n with self.assertNumQueries(5):\\n self.client.get(obj.get_layer_url())\\n\\n self.modelfactory(draft=False)\\n\\n # Cache is updated when we add a path\\n with self.assertNumQueries(5):\\n self.client.get(obj.get_layer_url())\",\n \"def add_geojson(map, geojson, style_function, name='states' ):\\n\\n folium.GeoJson(\\n geojson,\\n name=name,\\n style_function=style_function\\n ).add_to(map)\",\n \"def maya_useNewAPI():\\r\\n\\r\\n pass\",\n \"def test_render_world_map():\\n gdpinfo = gdpinfo_dict()\\n codeinfo = codeinfo_dict()\\n pygal_countries = pygal_country_dict()\\n\\n # 1960\\n render_world_map(gdpinfo, codeinfo, pygal_countries, \\\"1960\\\", \\\"isp_gdp_world_code_1960.svg\\\")\\n\\n # 1980\\n render_world_map(gdpinfo, codeinfo, pygal_countries, \\\"1980\\\", \\\"isp_gdp_world_code_1980.svg\\\")\\n\\n # 2000\\n render_world_map(gdpinfo, codeinfo, pygal_countries, \\\"2000\\\", \\\"isp_gdp_world_code_2000.svg\\\")\\n\\n # 2010\\n render_world_map(gdpinfo, codeinfo, pygal_countries, \\\"2010\\\", \\\"isp_gdp_world_code_2010.svg\\\")\",\n \"def testGetLayerInfo(self):\\n container_obj = self.explorer_object.GetContainer(\\n '7b02fb3e8a665a63e32b909af5babb7d6ba0b64e10003b2d9534c7d5f2af8966')\\n layer_info = container_obj.GetLayerInfo(\\n 'sha256:'\\n '7968321274dc6b6171697c33df7815310468e694ac5be0ec03ff053bb135e768')\\n self.assertEqual('2017-01-13T22:13:54.401355854Z', layer_info['created'])\\n self.assertEqual(['/bin/sh', '-c', '#(nop) ', 'CMD [\\\"sh\\\"]'],\\n layer_info['container_config']['Cmd'])\",\n \"def test_ExtractOverlaysSmoke(self):\\n stage = self.ConstructStage()\\n self.assertEqual(stage._ExtractOverlays(), ([], []))\",\n \"def test_incomplete_polygons():\\n assert not query_row(db_conf, 'osm_landusages', 30004)\\n assert not query_row(db_conf, 'osm_landusages', 30006)\",\n \"def folium_map(geojson_to_overlay, layer_name, location, style_function=None, tiles='Stamen Terrain', zoom_start=16,\\n show_layer_control=True, width='100%', height='75%', attr=None, map_zoom=18, max_zoom=20, tms=False,\\n zoom_beyond_max=None, base_tiles='OpenStreetMap', opacity=1):\\n\\n m = folium.Map(location=location, zoom_start=zoom_start, width=width, height=height, max_zoom=map_zoom,\\n tiles=base_tiles)\\n tiles = folium.TileLayer(tiles=tiles, attr=attr, name=attr, max_zoom=max_zoom)\\n if tms is True:\\n options = json.loads(tiles.options)\\n options.update({'tms': True})\\n tiles.options = json.dumps(options, sort_keys=True, indent=2)\\n tiles._template = jinja2.Template(u\\\"\\\"\\\"\\n {% macro script(this, kwargs) %}\\n var {{this.get_name()}} = L.tileLayer(\\n '{{this.tiles}}',\\n {{ this.options }}\\n ).addTo({{this._parent.get_name()}});\\n {% endmacro %}\\n \\\"\\\"\\\")\\n if zoom_beyond_max is not None:\\n options = json.loads(tiles.options)\\n options.update({'maxNativeZoom': zoom_beyond_max, 'maxZoom': max_zoom})\\n tiles.options = json.dumps(options, sort_keys=True, indent=2)\\n tiles._template = jinja2.Template(u\\\"\\\"\\\"\\n {% macro script(this, kwargs) %}\\n var {{this.get_name()}} = L.tileLayer(\\n '{{this.tiles}}',\\n {{ this.options }}\\n ).addTo({{this._parent.get_name()}});\\n {% endmacro %}\\n \\\"\\\"\\\")\\n if opacity < 1:\\n options = json.loads(tiles.options)\\n options.update({'opacity': opacity})\\n tiles.options = json.dumps(options, sort_keys=True, indent=2)\\n tiles._template = jinja2.Template(u\\\"\\\"\\\"\\n {% macro script(this, kwargs) %}\\n var {{this.get_name()}} = L.tileLayer(\\n '{{this.tiles}}',\\n {{ this.options }}\\n ).addTo({{this._parent.get_name()}});\\n {% endmacro %}\\n \\\"\\\"\\\")\\n\\n tiles.add_to(m)\\n if style_function is not None:\\n gj = folium.GeoJson(geojson_to_overlay, overlay=True, name=layer_name, style_function=style_function)\\n else:\\n gj = folium.GeoJson(geojson_to_overlay, overlay=True, name=layer_name)\\n gj.add_to(m)\\n\\n if show_layer_control is True:\\n folium.LayerControl().add_to(m)\\n\\n return m\",\n \"def test_viewset_list_filter(self):\\n # valid coordinate within a zone\\n data = {\\\"coords\\\": \\\"55.710663495702725/9.52840811021021\\\"}\\n response = self.client.get(reverse(\\\"servicearea-list\\\"), data, format='json')\\n\\n # we should get a http 200 and the zone\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(len(response.json()['features']), 1)\\n\\n # valid coordinate but outside the zone\\n data = {\\\"coords\\\": \\\"55.71/22.52\\\"}\\n response = self.client.get(reverse(\\\"servicearea-list\\\"), data, format='json')\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(len(response.json()['features']), 0)\\n\\n # invalid coordinate format\\n data = {\\\"coords\\\": \\\"test\\\"}\\n response = self.client.get(reverse(\\\"servicearea-list\\\"), data, format='json')\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(len(response.json()['features']), 0)\\n\\n # invalid coordinate format\\n data = {\\\"coords\\\": \\\"lng/lat\\\"}\\n response = self.client.get(reverse(\\\"servicearea-list\\\"), data, format='json')\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(len(response.json()['features']), 0)\\n\\n\\n # invalid coordinate format\\n data = {\\\"coords\\\": 1}\\n response = self.client.get(reverse(\\\"servicearea-list\\\"), data, format='json')\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(len(response.json()['features']), 0)\",\n \"def test_request_twms_legacy_nodate_from_year_layer(self):\\n ref_hash = 'fd81999878be17f66c28b18c3cce3179'\\n req_url = r'http://localhost/reproject/test/twms/twms.cgi?request=GetMap&layers=test_legacy_subdaily_jpg&srs=EPSG:3857&format=image%2Fjpeg&styles=&width=256&height=256&bbox=-20037508.34278925,-20037508.34278925,20037508.34278925,20037508.34278925'\\n if DEBUG:\\n print('\\\\nERROR!!! Testing: Request tile with no date and time (legacy sub-daily) from \\\"year\\\" layer via TWMS')\\n print('URL: ' + req_url)\\n check_result = check_tile_request(req_url, ref_hash)\\n self.assertTrue(check_result, 'TWMS legacy no date and time subdaily request does not match what\\\\'s expected. URL: ' + req_url)\\n\\n# def test_request_wmts_nodate_year_zlevel(self):\\n \\\"\\\"\\\"\\n 17. Request tile with no date and time (z-level) from \\\"year\\\" layer via WMTS\\n \\\"\\\"\\\"\\n# ref_hash = '36bb79a33dbbe6173990103a8d6b67cb'\\n# req_url = r'http://localhost/reproject/test/wmts/wmts.cgi?layer=test_zindex_jpg&tilematrixset=GoogleMapsCompatible_Level3&Service=WMTS&Request=GetTile&Version=1.0.0&Format=image%2Fjpeg&TileMatrix=0&TileCol=0&TileRow=0'\\n# check_result = check_tile_request(req_url, ref_hash)\\n# self.assertTrue(check_result, 'WMTS Z-Level JPG Tile Request does not match what\\\\'s expected. URL: ' + req_url)\\n\\n# def test_request_wmts_rest_nodate_year_zlevel(self):\\n \\\"\\\"\\\"\\n 17B. Request tile with no date and time (z-level) from \\\"year\\\" layer via WMTS (REST)\\n \\\"\\\"\\\"\\n# ref_hash = '36bb79a33dbbe6173990103a8d6b67cb'\\n# req_url = r'http://localhost/reproject/test/wmts/test_zindex_jpg/default/GoogleMapsCompatible_Level3/0/0/0.jpeg'\\n# check_result = check_tile_request(req_url, ref_hash)\\n# self.assertTrue(check_result, 'WMTS (REST) Z-Level JPG Tile Request does not match what\\\\'s expected. URL: ' + req_url)\\n\\n# def test_request_twms_nodate_year_zlevel(self):\\n \\\"\\\"\\\"\\n 17C. Request tile with no date and time (z-level) from \\\"year\\\" layer via TWMS\\n \\\"\\\"\\\"\",\n \"def maya_useNewAPI():\\n pass\",\n \"def maya_useNewAPI():\\n pass\",\n \"def maya_useNewAPI():\\n pass\",\n \"def maya_useNewAPI():\\n pass\",\n \"def maya_useNewAPI():\\n pass\",\n \"def get_geojson_potholes(active=True, date=None):\\n potholes = VwPothole.objects.all() if date is None \\\\\\n else VwPothole.objects.raw(vw_pothole_by_date, {'datetime': '{} 23:59:59'.format(date)})\\n\\n pothole_features = [Feature(\\n geometry=Point((float(pothole.lon), float(pothole.lat)), precision=8),\\n id=pothole.id,\\n properties={\\\"pothole_reports\\\": int(pothole.pothole_reports),\\n \\\"fixed_reports\\\": int(pothole.fixed_reports),\\n \\\"create_date\\\": str(pothole.create_date),\\n \\\"effective_date\\\": str(pothole.effective_date),\\n \\\"active\\\": pothole.effective_date is not None\\n and convert_timestamp(pothole.effective_date) < datetime.utcnow()\\n and convert_timestamp(pothole.fixed_date) > datetime.utcnow(),\\n \\\"fixed_date\\\": str(pothole.fixed_date),\\n \\\"fixed\\\": pothole.fixed_date and convert_timestamp(pothole.fixed_date) < datetime.utcnow(),\\n \\\"severity\\\": str(('%f' % round(pothole.avg_severity, 2)).rstrip('.0')),\\n \\\"utcnow\\\": str(datetime.utcnow())\\n })\\n for pothole in potholes\\n # filter according to whether active is true\\n if (active\\n and pothole.effective_date is not None\\n and convert_timestamp(pothole.fixed_date) > datetime.utcnow()\\n and convert_timestamp(pothole.effective_date) < datetime.utcnow())\\n or not active]\\n\\n pothole_collection = FeatureCollection(pothole_features)\\n return dumps(pothole_collection)\",\n \"def create_map(model1, model2=None, bbox=None, crs=None, filename=None,\\n subset=None, return_data=False):\\n\\n import geojson\\n from geojson import Point, LineString, Feature, GeometryCollection, FeatureCollection\\n try: import pyproj\\n except ImportError:\\n raise ImportError('pyproj module needed. get this package here: ',\\n 'https://pypi.python.org/pypi/pyproj')\\n\\n\\n if model2 is not None:\\n changes = INPDiff(model1, model2, section='[CONDUITS]')\\n df = pd.concat([changes.added, changes.altered])\\n subset = df.index.tolist()\\n\\n # else:\\n # model2 = model1 #stupid, for file path\\n\\n\\n if crs is None:\\n #default coordinate system (http://spatialreference.org/ref/epsg/2272/):\\n #NAD_1983_StatePlane_Pennsylvania_South_FIPS_3702_Feet\\n crs = {\\\"type\\\": \\\"name\\\",\\\"properties\\\": {\\\"name\\\": \\\"EPSG:2272\\\"}}\\n\\n pa_plane = pyproj.Proj(init='epsg:2272', preserve_units=True)\\n wgs = pyproj.Proj(proj='latlong', datum='WGS84', ellps='WGS84') #google maps, etc\\n\\n\\n geometries = [] #array of features\\n #collect the links\\n for k,v in list(model2.list_objects('conduit', bbox, subset=subset).items()):\\n props = {\\n 'MaxQPercent':v.maxQpercent,\\n 'id':v.id,\\n 'lifecycle':v.lifecycle,\\n 'geom1':v.geom1,\\n 'geom2':v.geom2,\\n }\\n\\n latlngs = [pyproj.transform(pa_plane, wgs, *xy) for xy in v.coordinates]\\n geometry = LineString(latlngs, properties=props)\\n geometries.append(geometry)\\n\\n\\n if return_data is True:\\n return FeatureCollection(geometries, crs=crs)\\n\\n if filename is None:\\n filename = os.path.join(model2.inp.dir,\\n REPORT_DIR_NAME,\\n model2.name + '.html')\\n\\n #start writing that thing\\n with open(BASEMAP_PATH, 'r') as bm:\\n with open(filename, 'wb') as newmap:\\n for line in bm:\\n if 'SWMMIO DUMP JSON DATA HERE' in line:\\n newmap.write('data = ')\\n newmap.write(geojson.dumps(FeatureCollection(geometries, crs=crs)))\\n else:\\n newmap.write(line)\",\n \"def test_build(self):\\n mapdatas = self.grid.maps_from_module(\\\"evennia.contrib.grid.xyzgrid.example\\\")\\n self.assertEqual(len(mapdatas), 2)\\n\\n self.grid.add_maps(*mapdatas)\\n self.grid.spawn()\\n\\n # testing\\n room1a = xyzroom.XYZRoom.objects.get_xyz(xyz=(3, 0, \\\"the large tree\\\"))\\n room1b = xyzroom.XYZRoom.objects.get_xyz(xyz=(10, 8, \\\"the large tree\\\"))\\n room2a = xyzroom.XYZRoom.objects.get_xyz(xyz=(1, 0, \\\"the small cave\\\"))\\n room2b = xyzroom.XYZRoom.objects.get_xyz(xyz=(1, 3, \\\"the small cave\\\"))\\n\\n self.assertEqual(room1a.key, \\\"Dungeon Entrance\\\")\\n self.assertTrue(room1a.db.desc.startswith(\\\"To the east\\\"))\\n self.assertEqual(room1b.key, \\\"A gorgeous view\\\")\\n self.assertTrue(room1b.db.desc.startswith(\\\"The view from here is breathtaking,\\\"))\\n self.assertEqual(room2a.key, \\\"The entrance\\\")\\n self.assertTrue(room2a.db.desc.startswith(\\\"This is the entrance to\\\"))\\n self.assertEqual(room2b.key, \\\"North-west corner of the atrium\\\")\\n self.assertTrue(room2b.db.desc.startswith(\\\"Sunlight sifts down\\\"))\",\n \"def check_feature(feature, expected_name='Adriatic Sea',\\n expected_type='Polygon'):\\n assert feature['properties']['name'] == expected_name\\n assert feature['properties']['component'] == 'ocean'\\n assert feature['geometry']['type'] == expected_type\",\n \"def test_reading_and_writing_of_vector_polygon_data(self):\\n\\n # Read and verify test data\\n vectorname = 'kecamatan_jakarta_osm.shp'\\n\\n filename = '%s/%s' % (TESTDATA, vectorname)\\n layer = read_layer(filename)\\n geometry = layer.get_geometry()\\n attributes = layer.get_data()\\n\\n assert layer.is_polygon_data\\n\\n # Check basic data integrity\\n N = len(layer)\\n\\n assert len(geometry) == N\\n assert len(attributes) == N\\n assert len(attributes[0]) == 2\\n\\n assert FEATURE_COUNTS[vectorname] == N\\n assert isinstance(layer.get_name(), basestring)\\n\\n # Check projection\\n wkt = layer.get_projection(proj4=False)\\n assert wkt.startswith('GEOGCS')\\n\\n assert layer.projection == Projection(DEFAULT_PROJECTION)\\n\\n # Check each polygon\\n for i in range(N):\\n geom = geometry[i]\\n n = geom.shape[0]\\n assert n >= 2\\n assert geom.shape[1] == 2\\n\\n # Check that polygon is closed\\n assert numpy.allclose(geom[0], geom[-1], rtol=0)\\n\\n # But that not all points are the same\\n max_dist = 0\\n for j in range(n):\\n d = numpy.sum((geom[j] - geom[0]) ** 2) / n\\n if d > max_dist:\\n max_dist = d\\n assert max_dist > 0\\n\\n # Check integrity of each feature\\n expected_features = {13: {'KAB_NAME': 'JAKARTA PUSAT',\\n 'KEC_NAME': 'SAWAH BESAR'},\\n 20: {'KAB_NAME': 'JAKARTA SELATAN',\\n 'KEC_NAME': 'MAMPANG PRAPATAN'}}\\n\\n for i in range(N):\\n # Consistency with attributes read manually with qgis\\n\\n if i in expected_features:\\n att = attributes[i]\\n exp = expected_features[i]\\n\\n for key in exp:\\n msg = ('Expected attribute %s was not found in feature %i'\\n % (key, i))\\n assert key in att, msg\\n\\n a = att[key]\\n e = exp[key]\\n msg = 'Got %s: \\\"%s\\\" but expected \\\"%s\\\"' % (key, a, e)\\n assert a == e, msg\\n\\n # Write data back to file\\n # FIXME (Ole): I would like to use gml here, but OGR does not\\n # store the spatial reference! Ticket #18\\n out_filename = unique_filename(suffix='.shp')\\n Vector(geometry=geometry, data=attributes, projection=wkt,\\n geometry_type='polygon').write_to_file(out_filename)\\n\\n # Read again and check\\n layer = read_layer(out_filename)\\n assert layer.is_polygon_data\\n geometry_new = layer.get_geometry()\\n attributes_new = layer.get_data()\\n\\n N = len(layer)\\n assert len(geometry_new) == N\\n assert len(attributes_new) == N\\n\\n for i in range(N):\\n assert numpy.allclose(geometry[i],\\n geometry_new[i],\\n rtol=1.0e-6) # OGR works in single precision\\n\\n assert len(attributes_new[i]) == 2\\n for key in attributes_new[i]:\\n assert attributes_new[i][key] == attributes[i][key]\",\n \"def run(self):\\n if self.is_complete:\\n LOG.debug(\\\"Skipping Geopackage, file exists\\\")\\n return\\n keys_points = self.feature_selection.key_union('points')\\n keys_lines = self.feature_selection.key_union('lines')\\n keys_polygons = self.feature_selection.key_union('polygons')\\n osmconf = OSMConfig(self.stage_dir,points=keys_points,lines=keys_lines,polygons=keys_polygons)\\n conf = osmconf.create_osm_conf()\\n ogr_cmd = self.ogr_cmd.safe_substitute({'gpkg': self.output_gpkg,\\n 'osm': self.input_pbf, 'osmconf': conf})\\n LOG.debug('Running: %s' % ogr_cmd)\\n subprocess.check_call(ogr_cmd, shell=True, executable='/bin/bash')\\n\\n \\\"\\\"\\\"\\n Create the default osm gpkg schema\\n \\\"\\\"\\\"\\n conn = sqlite3.connect(self.output_gpkg)\\n conn.enable_load_extension(True)\\n cur = conn.cursor()\\n cur.execute(\\\"select load_extension('mod_spatialite')\\\")\\n cur.execute(\\\"CREATE TABLE boundary (id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, geom GEOMETRY)\\\");\\n cur.execute(\\\"INSERT INTO boundary (geom) VALUES (GeomFromWKB(?,4326));\\\",(self.aoi_geom.wkb,))\\n cur.executescript(SPATIAL_SQL)\\n self.update_zindexes(cur,self.feature_selection)\\n\\n # add themes\\n create_sqls, index_sqls = self.feature_selection.sqls\\n for query in create_sqls:\\n cur.executescript(query)\\n for query in index_sqls:\\n cur.executescript(query)\\n conn.commit()\\n conn.close()\\n\\n if self.per_theme:\\n # this creates per-theme GPKGs\\n for theme in self.feature_selection.themes:\\n conn = sqlite3.connect(self.stage_dir + slugify(theme) + \\\".gpkg\\\")\\n conn.enable_load_extension(True)\\n cur = conn.cursor()\\n cur.execute(\\\"attach database ? as 'geopackage'\\\",(self.output_gpkg,))\\n cur.execute(\\\"create table gpkg_spatial_ref_sys as select * from geopackage.gpkg_spatial_ref_sys\\\")\\n cur.execute(\\\"create table gpkg_contents as select * from geopackage.gpkg_contents where 0\\\")\\n cur.execute(\\\"create table gpkg_geometry_columns as select * from geopackage.gpkg_geometry_columns where 0\\\")\\n for geom_type in self.feature_selection.geom_types(theme):\\n for stmt in self.feature_selection.create_sql(theme,geom_type):\\n cur.executescript(stmt)\\n conn.commit()\\n conn.close()\",\n \"def testGetLayerInfo(self):\\n container_obj = self.explorer_object.GetContainer(\\n '5dc287aa80b460652a5584e80a5c8c1233b0c0691972d75424cf5250b917600a')\\n layer_info = container_obj.GetLayerInfo(\\n 'sha256:'\\n '5b0d59026729b68570d99bc4f3f7c31a2e4f2a5736435641565d93e7c25bd2c3')\\n self.assertEqual('2018-01-24T04:29:35.590938514Z', layer_info['created'])\\n self.assertEqual(['/bin/sh', '-c', '#(nop) ', 'CMD [\\\"sh\\\"]'],\\n layer_info['container_config']['Cmd'])\",\n \"def testGetLayerInfo(self):\\n container_obj = self.explorer_object.GetContainer(\\n '8e8b7f23eb7cbd4dfe7e91646ddd0e0f524218e25d50113559f078dfb2690206')\\n layer_info = container_obj.GetLayerInfo(\\n 'sha256:'\\n '8ac48589692a53a9b8c2d1ceaa6b402665aa7fe667ba51ccc03002300856d8c7')\\n self.assertEqual('2018-04-05T10:41:28.876407948Z', layer_info['created'])\\n self.assertEqual(['/bin/sh', '-c', '#(nop) ', 'CMD [\\\"sh\\\"]'],\\n layer_info['container_config']['Cmd'])\",\n \"def crossWalkGeoBlacklight(data):\\n\\n dataJsonObj=deep_get(data,\\\"xml.fgdc\\\",[])\\n if len (dataJsonObj)>0:\\n dataJsonObj=deep_get(dataJsonObj[0],\\\"data\\\",{})\\n else:\\n dataJsonObj={}\\n layername=os.path.splitext(os.path.basename(data['file']))[0]\\n geoserver_layername = data['geoserverStoreName']\\n gblight = assignMetaDataComponents(dataJsonObj,layername,geoserver_layername,data[\\\"resource_type\\\"])\\n gblight['solr_geom']=data['bounds']\\n data['geoblacklightschema']=gblight\\n return data\",\n \"def testGetPointsGeodesic(self):\\n\\n for i in range(10):\\n self.basicGetPointsGeodesic()\",\n \"def run(layers):\",\n \"def test_reading_and_writing_of_vector_point_data(self):\\n\\n # First test that some error conditions are caught\\n filename = unique_filename(suffix='nshoe66u')\\n try:\\n read_layer(filename)\\n except ReadLayerError:\\n pass\\n else:\\n msg = 'Exception for unknown extension should have been raised'\\n raise Exception(msg)\\n\\n filename = unique_filename(suffix='.gml')\\n try:\\n read_layer(filename)\\n except ReadLayerError:\\n pass\\n else:\\n msg = 'Exception for non-existing file should have been raised'\\n raise Exception(msg)\\n\\n # Read and verify test data\\n for vectorname in ['test_buildings.shp',\\n 'tsunami_building_exposure.shp',\\n 'Padang_WGS84.shp',\\n ]:\\n\\n filename = '%s/%s' % (TESTDATA, vectorname)\\n layer = read_layer(filename)\\n coords = numpy.array(layer.get_geometry())\\n attributes = layer.get_data()\\n\\n # Check basic data integrity\\n N = len(layer)\\n assert coords.shape[0] == N\\n assert coords.shape[1] == 2\\n\\n assert FEATURE_COUNTS[vectorname] == N\\n\\n assert isinstance(layer.get_name(), basestring)\\n\\n # Check projection\\n wkt = layer.get_projection(proj4=False)\\n assert wkt.startswith('GEOGCS')\\n\\n assert layer.projection == Projection(DEFAULT_PROJECTION)\\n\\n # Check integrity of each feature\\n field_names = None\\n for i in range(N):\\n # Consistency between of geometry and fields\\n\\n x1 = coords[i, 0]\\n x2 = attributes[i]['LONGITUDE']\\n assert x2 is not None\\n msg = 'Inconsistent longitudes: %f != %f' % (x1, x2)\\n assert numpy.allclose(x1, x2), msg\\n\\n x1 = coords[i, 1]\\n x2 = attributes[i]['LATITUDE']\\n assert x2 is not None\\n msg = 'Inconsistent longitudes: %f != %f' % (x1, x2)\\n assert numpy.allclose(x1, x2), msg\\n\\n # Verify that each feature has the same fields\\n if field_names is None:\\n field_names = attributes[i].keys()\\n else:\\n assert len(field_names) == len(attributes[i].keys())\\n assert field_names == attributes[i].keys()\\n\\n # Write data back to file\\n # FIXME (Ole): I would like to use gml here, but OGR does not\\n # store the spatial reference! Ticket #18\\n out_filename = unique_filename(suffix='.shp')\\n Vector(geometry=coords, data=attributes, projection=wkt,\\n geometry_type='point').write_to_file(out_filename)\\n\\n # Read again and check\\n layer = read_layer(out_filename)\\n assert layer.is_point_data\\n coords = numpy.array(layer.get_geometry())\\n attributes = layer.get_data()\\n\\n # Check basic data integrity\\n N = len(layer)\\n assert coords.shape[0] == N\\n assert coords.shape[1] == 2\\n\\n # Check projection\\n assert layer.projection == Projection(DEFAULT_PROJECTION)\\n\\n # Check integrity of each feature\\n field_names = None\\n for i in range(N):\\n\\n # Consistency between of geometry and fields\\n x1 = coords[i, 0]\\n x2 = attributes[i]['LONGITUDE']\\n assert x2 is not None\\n msg = 'Inconsistent longitudes: %f != %f' % (x1, x2)\\n assert numpy.allclose(x1, x2), msg\\n\\n x1 = coords[i, 1]\\n x2 = attributes[i]['LATITUDE']\\n assert x2 is not None\\n msg = 'Inconsistent longitudes: %f != %f' % (x1, x2)\\n assert numpy.allclose(x1, x2), msg\\n\\n # Verify that each feature has the same fields\\n if field_names is None:\\n field_names = attributes[i].keys()\\n else:\\n assert len(field_names) == len(attributes[i].keys())\\n assert field_names == attributes[i].keys()\\n\\n # Test individual extraction\\n lon = layer.get_data(attribute='LONGITUDE')\\n assert numpy.allclose(lon, coords[:, 0])\",\n \"def test_request_twms_legacy_datetime_from_year_layer(self):\\n ref_hash = 'fd4fe96d84e4f10e61029890293fa3c8'\\n req_url = r'http://localhost/reproject/test/twms/twms.cgi?request=GetMap&layers=test_legacy_subdaily_jpg&srs=EPSG:3857&format=image%2Fjpeg&styles=&width=256&height=256&bbox=-20037508.34278925,-20037508.34278925,20037508.34278925,20037508.34278925&TIME=2012-02-29T12:00:00Z'\\n if DEBUG:\\n print('\\\\nTesting: Request tile with date and time (legacy sub-daily) from \\\"year\\\" layer via TWMS')\\n print('URL: ' + req_url)\\n check_result = check_tile_request(req_url, ref_hash)\\n self.assertTrue(check_result, 'TWMS legacy subdaily request does not match what\\\\'s expected. URL: ' + req_url)\\n\\n# def test_request_wmts_year_zlevel(self):\\n \\\"\\\"\\\"\\n 13. Request tile with date and time (z-level) from \\\"year\\\" layer via WMTS\\n \\\"\\\"\\\"\\n# ref_hash = '36bb79a33dbbe6173990103a8d6b67cb'\\n# req_url = r'http://localhost/reproject/test/wmts/wmts.cgi?layer=test_zindex_jpg&tilematrixset=GoogleMapsCompatible_Level3&Service=WMTS&Request=GetTile&Version=1.0.0&Format=image%2Fjpeg&TileMatrix=0&TileCol=0&TileRow=0&TIME=2012-02-29T16:00:00Z'\\n# check_result = check_tile_request(req_url, ref_hash)\\n# self.assertTrue(check_result, 'WMTS Z-Level JPG Tile Request does not match what\\\\'s expected. URL: ' + req_url)\\n\\n# def test_request_wmts_rest_year_zlevel(self):\\n \\\"\\\"\\\"\\n 13B. Request tile with date and time (z-level) from \\\"year\\\" layer via WMTS (REST)\\n \\\"\\\"\\\"\\n# ref_hash = '36bb79a33dbbe6173990103a8d6b67cb'\\n# req_url = r'http://localhost/reproject/test/wmts/test_zindex_jpg/default/2012-02-29T16:00:00Z/GoogleMapsCompatible_Level3/0/0/0.jpeg'\\n# check_result = check_tile_request(req_url, ref_hash)\\n# self.assertTrue(check_result, 'WMTS (REST) Z-Level JPG Tile Request does not match what\\\\'s expected. URL: ' + req_url)\\n\\n# def test_request_twms_year_zlevel(self):\\n \\\"\\\"\\\"\\n 13C. Request tile with date and time (z-level) from \\\"year\\\" layer via TWMS\\n \\\"\\\"\\\"\",\n \"def test_query(config):\\n\\n p = PostgreSQLProvider(config)\\n feature_collection = p.query()\\n assert feature_collection.get('type', None) == 'FeatureCollection'\\n features = feature_collection.get('features', None)\\n assert features is not None\\n feature = features[0]\\n properties = feature.get('properties', None)\\n assert properties is not None\\n geometry = feature.get('geometry', None)\\n assert geometry is not None\",\n \"def testGetOrderedLayers(self):\\n container_obj = self.explorer_object.GetContainer(\\n 'de44dd97cfd1c8d1c1aad7f75a435603991a7a39fa4f6b20a69bf4458809209c')\\n layers = container_obj.GetOrderedLayers()\\n self.assertEqual(2, len(layers))\\n self.assertEqual(\\n '1cee97b18f87b5fa91633db35f587e2c65c093facfa2cbbe83d5ebe06e1d9125',\\n layers[0])\",\n \"def get_house_est(api_key, year = str(), map = bool()):\\n try:\\n house_url = f'http://api.census.gov/data/{year}/pep/housing?get=HUEST&for=state:*&key={api_key}'\\n r = requests.get(house_url)\\n data = json.loads(r.content) \\n house_df = pd.DataFrame(data[1:], columns=data[0]).\\\\\\n rename(columns={\\\"HUEST\\\": \\\"Housing_Estimates\\\", \\\"state\\\": \\\"STATEFP\\\"})\\n house_df['Housing_Estimates'] = house_df['Housing_Estimates'].astype(str).astype(int)\\n geodata_url = f\\\"https://raw.githubusercontent.com/uscensusbureau/citysdk/master/v2/GeoJSON/20m/{year}/state.json\\\"\\n geo_df = gpd.read_file(geodata_url)\\n geo_df = geo_df.merge(house_df, on = 'STATEFP')\\n if map == True:\\n return geo_df.plot(column = 'Housing_Estimates')\\n else:\\n return geo_df\\n r.raise_for_status()\\n except HTTPError as http_err:\\n print(f'HTTP error occurred: {http_err}')\\n except Exception as err:\\n print(f'An error occured. All parameters must exist in the Census GeoJSON database and API. Please check https://github.com/uscensusbureau/citysdk/tree/master/v2/GeoJSON: {err}')\",\n \"def test_open_api(self):\\n response = self.client.get(self.initiatives_url)\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\",\n \"def test_format_coordinates():\\n # GIVEN\\n bpolys = geojson.FeatureCollection([{\\\"type\\\": \\\"Feature\\\",\\n \\\"geometry\\\": {\\\"coordinates\\\": [[[[13,51], [13,51.1], [13.1,51.1], [13.1,51], [13,51]],\\n [[13,51], [14,51.1], [14.1,51.1], [14.1,51], [14,51]]]],\\n \\\"type\\\": \\\"MultiPolygon\\\"}}])\\n time = \\\"2018-01-01\\\"\\n keys = [\\\"landuse\\\"]\\n values = [\\\"grass\\\"]\\n\\n # WHEN\\n client = ohsome.OhsomeClient()\\n response = client.elements.geometry.post(bpolys=ohsome.format_coordinates(bpolys), time=time, keys=keys, values=values)\\n result = response.as_geodataframe()\\n del client\\n\\n # THEN\\n assert len(result.geometry) == 74\",\n \"def test_loading_layer_with_complex_linetype(self, sdoc):\\n tdoc = ezdxf.new()\\n loader = xref.Loader(sdoc, tdoc)\\n loader.load_layers([\\\"second\\\"])\\n loader.execute()\\n assert document_has_no_errors(tdoc) is True\\n\\n layer = tdoc.layers.get(\\\"second\\\")\\n assert layer.dxf.name == \\\"SECOND\\\", \\\"expected the original layer name\\\"\\n\\n # Test if required resources are loaded:\\n ltype = tdoc.linetypes.get(layer.dxf.linetype)\\n assert ltype.dxf.name == \\\"SQUARE\\\", \\\"expected linetype SQUARE in target doc\\\"\\n assert tdoc.styles.find_shx(\\\"ltypeshp.shx\\\") is not None\",\n \"def test_02_get_geometry_collection_details(self):\\n geometry_collection = GeometryCollection(**self.test_data)\\n geometry_collection.save()\\n response = self.client.get('/api/v1/collection/%s/' % geometry_collection.pk)\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\",\n \"def main():\\n # IMPORTANT: Specify a path to the new shapefile!\\n data_dir = os.path.join(\\\"C:\\\\\\\\\\\",\\\"Users\\\",\\\"janni\\\",\\\"OneDrive\\\",\\\"Desktop\\\",\\\"data\\\")\\n\\n #Store route identification codes in to a list\\n L_tracks=['\\\"tag_ident\\\"=72413','\\\"tag_ident\\\"=72417','\\\"tag_ident\\\"=73053','\\\"tag_ident\\\"=72364',\\\\\\n '\\\"tag_ident\\\"=73054','\\\"tag_ident\\\"=79694','\\\"tag_ident\\\"=79698']\\n\\n if(os.path.isdir(data_dir)):\\n print(\\\"Very good! You have chosen a valid directory!\\\")\\n # load the point shapefile of the white-fronted goose manually!\\n # access the active layer\\n point_layer = iface.activeLayer()\\n if not point_layer:\\n print(\\\"Shape file failed to load!\\\")\\n else:\\n # 1\\n addTimeAndDateObs(point_layer)\\n print(\\\"-----------Created Date and Time objects-------------\\\")\\n # 2\\n addDistance(point_layer, L_tracks)\\n print(\\\"-----------Distances calculation finished-------------\\\")\\n # 3\\n extractPoints(point_layer,Statistics(point_layer),data_dir)\\n print(\\\"-----------Low distance points extracted and save to a new shapefile-------------\\\")\\n print('Done')\\n\\n raster_fn = os.path.join(data_dir,\\\"Eurasia_Landcover.tif\\\")\\n landuse_legend_fn = os.path.join(data_dir,'Eurasia_Landcover_Legend.csv')\\n in_shape_fn = os.path.join(data_dir,\\\"lowDistance.shp\\\")\\n out_shape_fn = os.path.join(data_dir,\\\"lowDistanceLanduseID.shp\\\")\\n\\n\\n if(QgsProject.instance().mapLayersByName('lowDistanceLanduseID')==[]):\\n processing.run(\\\"qgis:rastersampling\\\",\\n {'COLUMN_PREFIX' : 'LanduseNr_',\\n 'INPUT' : in_shape_fn,\\n 'OUTPUT' : out_shape_fn,\\n 'RASTERCOPY' : raster_fn})\\n updated_shapefile = iface.addVectorLayer(out_shape_fn, '', 'ogr')\\n else:\\n updated_shapefile = QgsProject.instance().mapLayersByName('lowDistanceLanduseID')[0]\\n #2\\n convertIdFloatToInt(updated_shapefile)\\n #3\\n legend = preProcessLegend(landuse_legend_fn)\\n #4\\n convertIdToName(legend,updated_shapefile)\\n #5\\n plotLandUse(updated_shapefile,\\\"Pie\\\")\\n print(\\\"-----------finished!-------------\\\")\\n print(\\\"DONE! :)\\\")\\n else:\\n iface.messageBar().pushMessage(\\\"Error\\\", \\\"The directory does not exist. Please change data_dir in the code\\\",level = 1)\\n print(\\\"Please specify a valid directory in the main function of Code_Distance.py!\\\")\",\n \"def test_addon_layer(self):\\n from spirit.plone.theming.interfaces import ISpiritPloneThemingLayer\\n self.assertIn(ISpiritPloneThemingLayer, registered_layers())\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.654739","0.6299019","0.6127946","0.58873796","0.57860696","0.5783082","0.5711746","0.56842566","0.5647381","0.56204945","0.559212","0.55821013","0.5580289","0.55746514","0.557363","0.5571923","0.553894","0.55071616","0.5482145","0.5464055","0.54393184","0.54247993","0.5389104","0.534668","0.53415775","0.5325999","0.53134406","0.5311206","0.5308899","0.5304657","0.5303724","0.5292257","0.5291717","0.52876925","0.5285477","0.5284218","0.5283701","0.5283701","0.5278216","0.5277388","0.5269205","0.5266559","0.5263657","0.5254015","0.5249422","0.52413815","0.52267665","0.52267045","0.5223976","0.52207834","0.5219358","0.5215849","0.52139276","0.5210034","0.5205609","0.51912445","0.51883614","0.5188266","0.5187763","0.51683766","0.516751","0.51585907","0.5152288","0.5151463","0.51414984","0.5134874","0.5134403","0.5129965","0.5128821","0.5122162","0.5121881","0.5118942","0.5115528","0.5111834","0.5111834","0.5111834","0.5111834","0.5111834","0.51102656","0.5109576","0.5109354","0.51089036","0.51077676","0.5106754","0.50984865","0.50981754","0.50968254","0.5095957","0.5093045","0.5088386","0.50796425","0.507926","0.5079114","0.5076923","0.5070308","0.50663745","0.50662535","0.5063467","0.5057221","0.5056654"],"string":"[\n \"0.654739\",\n \"0.6299019\",\n \"0.6127946\",\n \"0.58873796\",\n \"0.57860696\",\n \"0.5783082\",\n \"0.5711746\",\n \"0.56842566\",\n \"0.5647381\",\n \"0.56204945\",\n \"0.559212\",\n \"0.55821013\",\n \"0.5580289\",\n \"0.55746514\",\n \"0.557363\",\n \"0.5571923\",\n \"0.553894\",\n \"0.55071616\",\n \"0.5482145\",\n \"0.5464055\",\n \"0.54393184\",\n \"0.54247993\",\n \"0.5389104\",\n \"0.534668\",\n \"0.53415775\",\n \"0.5325999\",\n \"0.53134406\",\n \"0.5311206\",\n \"0.5308899\",\n \"0.5304657\",\n \"0.5303724\",\n \"0.5292257\",\n \"0.5291717\",\n \"0.52876925\",\n \"0.5285477\",\n \"0.5284218\",\n \"0.5283701\",\n \"0.5283701\",\n \"0.5278216\",\n \"0.5277388\",\n \"0.5269205\",\n \"0.5266559\",\n \"0.5263657\",\n \"0.5254015\",\n \"0.5249422\",\n \"0.52413815\",\n \"0.52267665\",\n \"0.52267045\",\n \"0.5223976\",\n \"0.52207834\",\n \"0.5219358\",\n \"0.5215849\",\n \"0.52139276\",\n \"0.5210034\",\n \"0.5205609\",\n \"0.51912445\",\n \"0.51883614\",\n \"0.5188266\",\n \"0.5187763\",\n \"0.51683766\",\n \"0.516751\",\n \"0.51585907\",\n \"0.5152288\",\n \"0.5151463\",\n \"0.51414984\",\n \"0.5134874\",\n \"0.5134403\",\n \"0.5129965\",\n \"0.5128821\",\n \"0.5122162\",\n \"0.5121881\",\n \"0.5118942\",\n \"0.5115528\",\n \"0.5111834\",\n \"0.5111834\",\n \"0.5111834\",\n \"0.5111834\",\n \"0.5111834\",\n \"0.51102656\",\n \"0.5109576\",\n \"0.5109354\",\n \"0.51089036\",\n \"0.51077676\",\n \"0.5106754\",\n \"0.50984865\",\n \"0.50981754\",\n \"0.50968254\",\n \"0.5095957\",\n \"0.5093045\",\n \"0.5088386\",\n \"0.50796425\",\n \"0.507926\",\n \"0.5079114\",\n \"0.5076923\",\n \"0.5070308\",\n \"0.50663745\",\n \"0.50662535\",\n \"0.5063467\",\n \"0.5057221\",\n \"0.5056654\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7514468"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":79079,"cells":{"query":{"kind":"string","value":"Asigna el valor v al elemento kveces anterior."},"document":{"kind":"string","value":"def __setitem__(self, k, v):\n\n self.valores[( zero - k )%self.longitud] = v"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def actualizar_velocidad(self):\r\n pass","def find_prev(self, v):\n if v - 1 < self.values[0] or v - 1 > self.values[-1]:\n raise IndexError('element not found')\n\n index = self._bin_search_recursive(v, 0, len(self.values) - 1)\n\n if index > 0:\n return self.values[index - 1]\n else:\n raise IndexError('element not found')","def val(self):\n return self.v","def v(self, v):\n self._v = v","def order_v(self):\n return self._degree_v + 1","def update_varga(self, varga):\n\t\tself.subvarga = ''\n\t\tself.subvargaNum = 1\n\t\tself.varga = varga\n\t\tself.vargaNum += 1","def get_V(self):\n return self.V","def update_vie(self):\n self.essais_restant[\"text\"] = \"Vous disposez de {} vies\".format(self.jeu.get_nb_vie())","def obtener_adyacente_aleatorio (self,v):\n return choice(list(self.vertices[v].keys()))","def set_Curv(self,curv):\n #n0=self.n0\n self.C=(curv+1.E-40)","def v(self):\n return self._properties['v']","def v(self, v):\n\n self._v = v","def v(self, v):\n\n self._v = v","def v(self, v) :\n\t\ttry :\n\t\t\tself._v = v\n\t\texcept Exception as e:\n\t\t\traise e","def actualizar_velocidad(self, event):\r\n if event == 4:\r\n self.vel_elegida.setText(\"VELOCIDAD MAXIMA\")\r\n elif event == 3:\r\n self.vel_elegida.setText(\"VELOCIDAD RAPIDA\")\r\n elif event == 2:\r\n self.vel_elegida.setText(\"VELOCIDAD MEDIA\")\r\n elif event == 1:\r\n self.vel_elegida.setText(\"VELOCIDAD BAJA\")","def v(self):\n return self._v","def v(self):\n return self._v","def atualizaVertice(self, v = []):\r\n\r\n #reseta as arestas para d0\r\n #for a in self.arestas:\r\n # a.peso = a.d0\r\n\r\n for vertice in v:\r\n for a in self.arestas:\r\n if (vertice.id == a.v1.id):\r\n #print (\"atualiza aresta\", a.id)\r\n if (a.v2.atualizado):\r\n a.peso = a.d2\r\n else:\r\n a.peso = a.d1\r\n\r\n\r\n if (vertice.id == a.v2.id):\r\n #print (\"atualiza aresta\", a.id)\r\n if (a.v1.atualizado):\r\n a.peso = a.d2\r\n else:\r\n a.peso = a.d1\r\n \r\n vertice.atualizado = True\r\n \r\n for vertice in v:\r\n vertice.atualizado = False","def valeur(self) -> int:\r\n if self.signe == '0':\r\n return super().valeur()\r\n if self == self.Minimum:\r\n return -2 ** (len(self) - 1)\r\n return - abs(self).valeur()","def V(self):\n return self._V","def V(self):\n return self._V","def V(self):\n return self._V","def update_kanda(self, kanda):\n\t\tself.subvarga = ''\n\t\tself.subvargaNum = 1\n\t\tself.varga = ''\n\t\tself.vargaNum = 1\n\t\tself.kanda = kanda\n\t\tself.kandaNum += 1","def muestraPunto(v, posicionInicial):\n\ttmp = v + posicionInicial\n\tbpy.ops.object.add(type='EMPTY', location=tmp)","def v(self) :\n\t\ttry :\n\t\t\treturn self._v\n\t\texcept Exception as e:\n\t\t\traise e","def supprimer():\n\t\tif self.gch == None:\n\t\t\tself.val = self.dte\n\t\telif self.dte == None:\n\t\t\tself.val = self.gch\n\t\telse:\n\t\t\tself.val = self.gch.max()","def limits_va(self, v):\n # acceleration limit\n if self._accel_max is not None:\n if (v - self._v_prev) / self._dt > self._accel_max:\n v = self._v_prev + self._accelmax * self._dt;\n elif (v - self._v_prev) / self._dt < -self._accel_max:\n v = self._v_prev - self._accel_max * self._dt;\n self._v_prev = v\n \n # speed limit\n if self._speed_max is not None:\n v = np.clip(v, -self._speed_max, self._speed_max)\n return v","def atender(self):\n\n if self.enfila>0: #Para que atiendan solamente si e que hay alguien en la fila\n\n self.enfila-=1\n self.fila.pop(0) #Saco primer elemento de la fila (Atienden al primer cliente)","def previous(self, _event):\n self.set_val(self.val - 1)","def choix_vitesse():\n\n global vitesse_serpent\n global variable_vitesse\n\n if (vit.get()==0):\n vitesse_serpent=700\n variable_vitesse=1\n valeur_vitesse['text'] = str(vitesse_serpent) +' ms/mvt'\n elif (vit.get()==1):\n vitesse_serpent=450\n variable_vitesse=2\n valeur_vitesse['text'] = str(vitesse_serpent) +' ms/mvt'\n elif (vit.get()==2):\n vitesse_serpent=200\n variable_vitesse=3\n valeur_vitesse['text'] = str(vitesse_serpent) +' ms/mvt'","def vvalue(self) -> Qval:\n return self.get(self.greedy())","def vencimento(self):\n\n return self.__vencimento","def getActaVotacion(self):\n return None","def vel_inicial(x): #Velocidad inicial como un vector de ceros\r\n return np.zeros_like(x)","def removeItem(self, valor):\n if not self.esta_vazia():\n ## Os dois ponteiros apontam pro primeiro elemento da lista\n elementoAnterior = self._cabeca\n elementoAtual = self._cabeca\n while True:\n ## Se o elemento for encontrado\n if elementoAtual._inteiro == valor:\n while elementoAtual._inteiro == valor:\n if elementoAtual == elementoAnterior:\n ## Se o elemento a ser removido é o primeiro\n self.removeInicio()\n elementoAnterior = self._cabeca\n elementoAtual = self._cabeca\n else:\n elementoAnterior._proximo = elementoAtual._proximo\n elementoAnterior._proximo._anterior = elementoAnterior\n elementoAtual = elementoAnterior._proximo\n if elementoAtual == self._cabeca:\n break\n break\n else:\n ## se o elemento não foi encontrado ainda\n if elementoAnterior != elementoAtual:\n ## Avança o ponteiro que marca o nó anterior apenas quando não é a primeira passagem\n ## do Loop (os dois ponteiros já estão diferentes)\n elementoAnterior = elementoAnterior._proximo\n ## de qualquer forma avança o ponteiro para o atual\n elementoAtual = elementoAtual._proximo\n ## Testar se o elemento buscado não existe\n if elementoAtual == self._cabeca:\n break\n return None","def BVC(self, value):\n if not self.reg.V:\n self.reg.PC += value","def knotvector_v(self):\n return self._knot_vector_v","def __set_V(self, V):\n self.V = int(V)\n if self.V < 1:\n raise ValueError('Empty graphs cannot be created')","def entrer(self):\n valeur = getattr(self.objet, self.attribut, None)\n if valeur is None:\n setattr(self.objet, self.attribut, [])","def IngVelocidad(frm):\r\n #se le pide al usuario que ingrese la velocidad inicial\r\n vel=float(frm.txtvel.GetValue())\r\n #vel=raw_input(\"Ingrese la velocidad inicial (m/s): \")\r\n #se asigna el valor de error\r\n \r\n #se condione para que solo se pueden ingresar valores numericos positvios\r\n \r\n vel=float(vel)\r\n #se condiona que sea positivo\r\n if vel>0:\r\n #se regresa el valor de vel\r\n return vel","def restar(self):\n self.resultado = self.valor_1 - self.valor_2","def set_novu_komponentu(self, naziv, komponenta):\n if naziv not in self.komponente.keys():\n self.komponente[naziv] = komponenta","def C(self, u, v):\n pass","def cobroEfectivo(self):\n if self.total_a_pagar == 0:\n QtGui.QMessageBox.information(self,\"Aviso\",\"El saldo restante a pagar es cero\")\n else:\n self.rbtnEfectivo.setChecked(True)\n monto_a_pagar, ok = QtGui.QInputDialog.getDouble(self,\"Cobro Efectivo\",\"Ingrese monto a pagar\",0,0,2000,2)\n\n if ok:\n if monto_a_pagar >= self.total_a_pagar:\n QtGui.QMessageBox.information(self,\"Cobro Efectivo\",\"Su vuelto es:%.2f\" % (monto_a_pagar - self.total_a_pagar))\n temp = [\"Efectivo\",monto_a_pagar]\n self.detalles_cobro[self.tablePagos.rowCount()] = temp\n self.total_a_pagar = 0\n elif monto_a_pagar == 0:\n QtGui.QMessageBox.information(self,\"Aviso\",\"El monto ingresado no puede ser cero\")\n else:\n temp = [\"Efectivo\",monto_a_pagar]\n self.detalles_cobro[self.tablePagos.rowCount()] = temp\n self.total_a_pagar -= monto_a_pagar\n\n self.actualizar_total()\n self.actualizar_tabla()","def retroceder(self):\n\t\tif self.pila_anteriores.esta_vacia(): \n\t\t\traise StopIteration(\"Esta al principio.\")\n\t\tself.actual = self.anterior\n\t\tself.anterior = self.pila_anteriores.desapilar()\n\t\tself.posicion -= 1\n\t\treturn self.actual.dato","def actualizarLInv(produ,datInv,cant): # Esta sección fue hecha por Valeria \n datInv[produ][2] += cant\n return datInv","def setValveCoeff(self, Kv = -1.0):\n vv = zeros(1,'d')\n vv[0] = Kv\n if self._verbose:\n print\n print self._name+': setting valve coefficient to '+`Kv`+' kg/Pa-s'\n self._setParameters(vv)","def meuMetodo2(self, valor):\n self.outroAtributo = valor\n print(self.outroAtributo)","def valor(self):\n try:\n objeto = self.objeto\n except AttributeError:\n objeto = None\n return objeto","def valor(self):\n if self._inteiro != None:\n return str(self._inteiro)\n else:\n return \"Sem Valor\"","def update(self, v_input):\n\n self.v = v_input","def vf(gravedad, tiempo):\r\n #se realiza un multiplicacion y el valor se le asigna a la variable vf\r\n vf=gravedad*tiempo\r\n #se regresa vf\r\n return vf","def extraer(self):\n valor=self.queue.pop(0)\n print (f\"Se ha extraido exitosamente el primer valor que es: {valor}\")","def set_val(self, k, a):\n k += self.n - 1\n self.dat[k] = a\n while k > 0:\n k = (k - 1) // 2 # parent\n self.dat[k] = self.op(self.dat[k * 2 + 1], self.dat[k * 2 + 2])","def update_V(self, Vs, Vs_next, reward, alpha, gamma):\r\n return Vs + alpha * (reward + gamma * Vs_next - Vs)","def update(self, v, r):\n pass","def prebaci_dan_nazad(self):\r\n value = int(self.brojDanaCombo.currentText()) #integer broj dana\r\n self.emit(QtCore.SIGNAL('promjeni_datum(PyQt_PyObject)'), -value)\r\n msg = 'request pomak {0} dana unazad'.format(value)\r\n logging.info(msg)","def morir(self):\n self.energia = 0\n self.vivo = False","def acc_b_v(self):\r\n return self._acc_b_v","def perde_velocidade(self, limite, limite_re):\n if self.velocidade_carro > limite:\n self.velocidade_carro-= 50\n elif -600 < self.velocidade_carro < limite_re:\n self.velocidade_carro+= 35","def degree_v(self):\n return self._degree_v","def set_total_annee_precedente_lui(self, valeurs):\r\n \r\n self._total_annee_precedente_lui = valeurs","def desplazamientox(tiempo,velocidad):\r\n #se realiza un operacion para encontrar el el desplzamiento horizaontal\r\n x=tiempo*velocidad\r\n #se regresa el valor de x\r\n return x","def __init__(self,initial_v,v_select=0,max_dev_semitones=1):\n self.v=initial_v\n self.v_select=v_select\n self.max_dev_semitones=max_dev_semitones","def dodaj_novu_zs_ref_vrijednost(self):\r\n logging.info('Request za dodavanjem nove zero/span referentne vrijednosti')\r\n self.emit(QtCore.SIGNAL('dodaj_novu_referentnu_vrijednost'))","def position(self, u, v):\n raise NotImplementedError","def vlnext(self, v: int) -> int:\n result = self._read_inline(f\"vlnext({v})\")\n return int(result)","def cria_carro_volks(self):\n\n self.total_de_carros_volks += 1\n print(\"Carro Volks #\", self.total_de_carros_volks, \" criado\")","def busca(self, k):\n x = self.getRaiz()\n while x is not None and k != x.getChave():\n if k < x.getChave():\n x = x.getEsquerdo()\n else:\n x = x.getDireito()\n return x","def bouton_commencer(event):\n\n global vitesse_serpent\n\n vitesse_serpent = 200\n variable_vitesse = 3\n deselectionner()\n valeur_vitesse['text'] = str(vitesse_serpent) +' ms/mvt'\n commencer()","def Ingresar(frm):\r\n #se asigna el valor de la variable seguir\r\n \r\n #se le pide al usuario que ingresa la altura\r\n posinicial=float(frm.txtposinicial.GetValue())\r\n #posinicial=raw_input(\"Ingrese la altura desde donde se va dejar caer (en metros): \")\r\n #se condiona para que solo permite ingresar numero positivos \r\n \r\n posinicial=float(posinicial)\r\n if posinicial>0:\r\n posinicial=posinicial+2\r\n return posinicial","def cr_v(self, v, k):\n\n return self.cr(v[:, 0], v[:, 1], v[:, 2], k).T","def BVS(self, value):\n if self.reg.V:\n self.reg.PC += value","def save(self, *args, **kwargs):\r\n super(Vertex, self).save(*args, **kwargs)\r\n params = self.as_save_params()\r\n params['element_type'] = self.get_element_type()\r\n result = self._save_vertex(params)[0]\r\n self.eid = result.eid\r\n for k,v in self._values.items():\r\n v.previous_value = result._values[k].previous_value\r\n return result","def getVelocity(self):\n return self.v","def actualizarLBI(produ,datInv,cant): # Esta sección fue hecha por Valeria \n datInv[produ][2] -= cant\n return datInv","def uvozi_vloge(cur):\n cur.execute(\"DELETE FROM nastopa;\")\n cur.execute(\"DELETE FROM vloga;\")\n vloge = {}\n with open('podatki/vloge.csv') as datoteka:\n podatki = csv.reader(datoteka)\n stolpci = next(podatki)\n v = stolpci.index('vloga')\n poizvedba = \"\"\"\n INSERT INTO nastopa VALUES ({})\n \"\"\".format(', '.join([\"?\"] * len(stolpci)))\n poizvedba_vloga = \"INSERT INTO vloga (naziv) VALUES (?);\"\n for vrstica in podatki:\n vloga = vrstica[v]\n if vloga not in vloge:\n cur.execute(poizvedba_vloga, [vloga])\n vloge[vloga] = cur.lastrowid\n vrstica[v] = vloge[vloga]\n cur.execute(poizvedba, vrstica)","def disminuir_vidas(self,cantidad=2):\n self.vidas -= cantidad","def setPrev(self, prev):\n\t\t\tself.prev = prev","def last_value(self):\n return 0","def set_total_annee_precedente_elle(self, valeurs):\r\n \r\n self._total_annee_precedente_elle = valeurs","def GetPagado(vj, idVenta, Mnd):\n\n pagado = 0.0\n for idPago in vj.PagosVenta.get(idVenta,[]): # Recorre todos los pagos para la venta\n rowPago = vj.tbPagos.rows[idPago]\n\n pagado += vj.Cnv( rowPago.cuc, MD.Cuc, Mnd )\n pagado += vj.Cnv( rowPago.cup, MD.Cup, Mnd )\n return pagado","def V(self, point = -1):\n return self.solution('V', point)","def VotoNo(request, id_solicitud):\n #tipoItemExistente = TipoItem.objects.get(id=id_tipoitem)\n #tipoItemNuevo = TipoItem.objects.get(id=id_tipoitem)\n solicitud = SolicitudItem.objects.get(id=id_solicitud)\n solicitud.votos = solicitud.votos + 1\n solicitud.votosno = solicitud.votosno + 1\n solicitud.save()\n messages.info(request, \"Su voto se registro correctamente.\")\n if solicitud.completo:\n return HttpResponseRedirect('/admin/todo/item/')\n else:\n return HttpResponseRedirect('/admin/todo/solicituditem/')","def sibling(self, v):\n # method here","def extraer(self):\n valor=self.stack.pop()\n print (f\"Se ha extraido exitosamente el ultimo valor que es: {valor}\")","def unkV(self):\n if self._unkV is None:\n self._unkV = self.V.mean(0)\n return self._unkV","def __init__(self, v, p):\n self.val = v\n self.priority = p","def getRevuelto(self):\r\n\t\treturn self.__revuelto","def on_spinBox_valueChanged(self, p0):\n self.nbr_pts_caracterisation = self.spinBox.value()","def limpiarVentana(self):\n self.limpiarTabla(self.tableFactura)\n self.lineNumero.setEnabled(True)\n self.lineNumero.clear()\n self.limpiarTabla(self.tableNC)","def on_pushButton_precedent_clicked(self):\n \n if self.lineEdit_temperature.text() !=\"\":\n num_pt =int(self.label_pt.text())\n if num_pt - 1 < 1:\n pass\n else:\n \n #effacement\n for ligne in range(11):\n for colonne in range(8):\n if colonne !=6:\n \n self.tableWidget_mesures.setItem(ligne, colonne, QtGui.QTableWidgetItem(None))\n self.lineEdit_temperature.clear()\n self.lineEdit_stab_max.clear()\n self.lineEdit_u_stab_max.clear() \n self.lineEdit_hom_max_2.clear()\n self.lineEdit_u_hom_max.clear()\n \n else:\n pass\n #reafctation des donnees \n self.reaffectation_table_widget_mesures(str(int(self.label_pt.text())-1)) \n \n #presentation textEdit n°pt de la mesure\n self.label_pt.setText(str(num_pt -1))","def getPrev(self):\n\t\t\treturn self.prev","def get_value(self):\r\n return 0","def limpiarVentana(self):\n\n self.productosAgregados=0\n self.lotesVentas={}\n self.facturaCobrada=False\n self.obraSocialSeleccionada=None\n self.formapago = None\n self.factura = None\n self.data = {}\n self.detallesTabla = {}\n self.lineObra.clear()\n self.lineObra.setEnabled(True)\n self.lineCuit.clear()\n self.lineCuit.setEnabled(True)\n self.tableObra.setVisible(False)\n self.rbtnObra.setChecked(False)\n self.limpiarTabla(self.tableProductos)\n self.limpiarTabla(self.tableFactura)\n self.cargarProductosSinObra()","def insertar(self, dato):\n\t\tif self.posicion == 0:\n\t\t\tself.lista.insertar_primero(dato) \n\t\t\tself.actual = self.lista.prim \n\t\t\treturn self.actual.dato\n\t\tnodo = _Nodo(dato)\n\t\tself.anterior.prox = nodo\n\t\tnodo.prox = self.actual\n\t\tself.actual = nodo\n\t\tself.lista.len += 1\n\t\treturn self.actual.dato","def avanzar(self):\n\t\tif (not len(self.lista)) or (self.esta_al_final()): \n\t\t\traise StopIteration(\"Esta al final.\")\n\t\tself.pila_anteriores.apilar(self.anterior)\n\t\tself.anterior = self.actual\n\t\tself.actual = self.actual.prox\n\t\tself.posicion += 1\n\t\treturn self.actual.dato","def actualizar_puntaje(self):\r\n pass","def on_VDepositValue_editingFinished(self):\n # TODO: not implemented yet\n # raise NotImplementedError\n value = self.VDepositValue.text()\n if JudgeStr2Float(value):\n self.depositValue = float(value)\n print(f\"Validator Deposit with {value} MAN\")\n else:\n self.vdepositValue = 0\n self.VDepositValue.clear()\n # self.VDepositValue.setFocus()","def rokadaV(self, color):\n if(color == 'w'):\n self.data[7][3] = 'wr'\n self.data[7][2] = 'wk'\n self.data[7][4] = '.'\n self.data[7][0] = '.'\n self.kralj_beli_koriscen = True\n self.previous_positions = [7, 2]\n\n else:\n self.data[0][3] = 'br'\n self.data[0][2] = 'bk'\n self.data[0][4] = '.'\n self.data[0][0] = '.'\n self.kralj_crni_koriscen = True\n self.previous_positions = [0, 2]"],"string":"[\n \"def actualizar_velocidad(self):\\r\\n pass\",\n \"def find_prev(self, v):\\n if v - 1 < self.values[0] or v - 1 > self.values[-1]:\\n raise IndexError('element not found')\\n\\n index = self._bin_search_recursive(v, 0, len(self.values) - 1)\\n\\n if index > 0:\\n return self.values[index - 1]\\n else:\\n raise IndexError('element not found')\",\n \"def val(self):\\n return self.v\",\n \"def v(self, v):\\n self._v = v\",\n \"def order_v(self):\\n return self._degree_v + 1\",\n \"def update_varga(self, varga):\\n\\t\\tself.subvarga = ''\\n\\t\\tself.subvargaNum = 1\\n\\t\\tself.varga = varga\\n\\t\\tself.vargaNum += 1\",\n \"def get_V(self):\\n return self.V\",\n \"def update_vie(self):\\n self.essais_restant[\\\"text\\\"] = \\\"Vous disposez de {} vies\\\".format(self.jeu.get_nb_vie())\",\n \"def obtener_adyacente_aleatorio (self,v):\\n return choice(list(self.vertices[v].keys()))\",\n \"def set_Curv(self,curv):\\n #n0=self.n0\\n self.C=(curv+1.E-40)\",\n \"def v(self):\\n return self._properties['v']\",\n \"def v(self, v):\\n\\n self._v = v\",\n \"def v(self, v):\\n\\n self._v = v\",\n \"def v(self, v) :\\n\\t\\ttry :\\n\\t\\t\\tself._v = v\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise e\",\n \"def actualizar_velocidad(self, event):\\r\\n if event == 4:\\r\\n self.vel_elegida.setText(\\\"VELOCIDAD MAXIMA\\\")\\r\\n elif event == 3:\\r\\n self.vel_elegida.setText(\\\"VELOCIDAD RAPIDA\\\")\\r\\n elif event == 2:\\r\\n self.vel_elegida.setText(\\\"VELOCIDAD MEDIA\\\")\\r\\n elif event == 1:\\r\\n self.vel_elegida.setText(\\\"VELOCIDAD BAJA\\\")\",\n \"def v(self):\\n return self._v\",\n \"def v(self):\\n return self._v\",\n \"def atualizaVertice(self, v = []):\\r\\n\\r\\n #reseta as arestas para d0\\r\\n #for a in self.arestas:\\r\\n # a.peso = a.d0\\r\\n\\r\\n for vertice in v:\\r\\n for a in self.arestas:\\r\\n if (vertice.id == a.v1.id):\\r\\n #print (\\\"atualiza aresta\\\", a.id)\\r\\n if (a.v2.atualizado):\\r\\n a.peso = a.d2\\r\\n else:\\r\\n a.peso = a.d1\\r\\n\\r\\n\\r\\n if (vertice.id == a.v2.id):\\r\\n #print (\\\"atualiza aresta\\\", a.id)\\r\\n if (a.v1.atualizado):\\r\\n a.peso = a.d2\\r\\n else:\\r\\n a.peso = a.d1\\r\\n \\r\\n vertice.atualizado = True\\r\\n \\r\\n for vertice in v:\\r\\n vertice.atualizado = False\",\n \"def valeur(self) -> int:\\r\\n if self.signe == '0':\\r\\n return super().valeur()\\r\\n if self == self.Minimum:\\r\\n return -2 ** (len(self) - 1)\\r\\n return - abs(self).valeur()\",\n \"def V(self):\\n return self._V\",\n \"def V(self):\\n return self._V\",\n \"def V(self):\\n return self._V\",\n \"def update_kanda(self, kanda):\\n\\t\\tself.subvarga = ''\\n\\t\\tself.subvargaNum = 1\\n\\t\\tself.varga = ''\\n\\t\\tself.vargaNum = 1\\n\\t\\tself.kanda = kanda\\n\\t\\tself.kandaNum += 1\",\n \"def muestraPunto(v, posicionInicial):\\n\\ttmp = v + posicionInicial\\n\\tbpy.ops.object.add(type='EMPTY', location=tmp)\",\n \"def v(self) :\\n\\t\\ttry :\\n\\t\\t\\treturn self._v\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise e\",\n \"def supprimer():\\n\\t\\tif self.gch == None:\\n\\t\\t\\tself.val = self.dte\\n\\t\\telif self.dte == None:\\n\\t\\t\\tself.val = self.gch\\n\\t\\telse:\\n\\t\\t\\tself.val = self.gch.max()\",\n \"def limits_va(self, v):\\n # acceleration limit\\n if self._accel_max is not None:\\n if (v - self._v_prev) / self._dt > self._accel_max:\\n v = self._v_prev + self._accelmax * self._dt;\\n elif (v - self._v_prev) / self._dt < -self._accel_max:\\n v = self._v_prev - self._accel_max * self._dt;\\n self._v_prev = v\\n \\n # speed limit\\n if self._speed_max is not None:\\n v = np.clip(v, -self._speed_max, self._speed_max)\\n return v\",\n \"def atender(self):\\n\\n if self.enfila>0: #Para que atiendan solamente si e que hay alguien en la fila\\n\\n self.enfila-=1\\n self.fila.pop(0) #Saco primer elemento de la fila (Atienden al primer cliente)\",\n \"def previous(self, _event):\\n self.set_val(self.val - 1)\",\n \"def choix_vitesse():\\n\\n global vitesse_serpent\\n global variable_vitesse\\n\\n if (vit.get()==0):\\n vitesse_serpent=700\\n variable_vitesse=1\\n valeur_vitesse['text'] = str(vitesse_serpent) +' ms/mvt'\\n elif (vit.get()==1):\\n vitesse_serpent=450\\n variable_vitesse=2\\n valeur_vitesse['text'] = str(vitesse_serpent) +' ms/mvt'\\n elif (vit.get()==2):\\n vitesse_serpent=200\\n variable_vitesse=3\\n valeur_vitesse['text'] = str(vitesse_serpent) +' ms/mvt'\",\n \"def vvalue(self) -> Qval:\\n return self.get(self.greedy())\",\n \"def vencimento(self):\\n\\n return self.__vencimento\",\n \"def getActaVotacion(self):\\n return None\",\n \"def vel_inicial(x): #Velocidad inicial como un vector de ceros\\r\\n return np.zeros_like(x)\",\n \"def removeItem(self, valor):\\n if not self.esta_vazia():\\n ## Os dois ponteiros apontam pro primeiro elemento da lista\\n elementoAnterior = self._cabeca\\n elementoAtual = self._cabeca\\n while True:\\n ## Se o elemento for encontrado\\n if elementoAtual._inteiro == valor:\\n while elementoAtual._inteiro == valor:\\n if elementoAtual == elementoAnterior:\\n ## Se o elemento a ser removido é o primeiro\\n self.removeInicio()\\n elementoAnterior = self._cabeca\\n elementoAtual = self._cabeca\\n else:\\n elementoAnterior._proximo = elementoAtual._proximo\\n elementoAnterior._proximo._anterior = elementoAnterior\\n elementoAtual = elementoAnterior._proximo\\n if elementoAtual == self._cabeca:\\n break\\n break\\n else:\\n ## se o elemento não foi encontrado ainda\\n if elementoAnterior != elementoAtual:\\n ## Avança o ponteiro que marca o nó anterior apenas quando não é a primeira passagem\\n ## do Loop (os dois ponteiros já estão diferentes)\\n elementoAnterior = elementoAnterior._proximo\\n ## de qualquer forma avança o ponteiro para o atual\\n elementoAtual = elementoAtual._proximo\\n ## Testar se o elemento buscado não existe\\n if elementoAtual == self._cabeca:\\n break\\n return None\",\n \"def BVC(self, value):\\n if not self.reg.V:\\n self.reg.PC += value\",\n \"def knotvector_v(self):\\n return self._knot_vector_v\",\n \"def __set_V(self, V):\\n self.V = int(V)\\n if self.V < 1:\\n raise ValueError('Empty graphs cannot be created')\",\n \"def entrer(self):\\n valeur = getattr(self.objet, self.attribut, None)\\n if valeur is None:\\n setattr(self.objet, self.attribut, [])\",\n \"def IngVelocidad(frm):\\r\\n #se le pide al usuario que ingrese la velocidad inicial\\r\\n vel=float(frm.txtvel.GetValue())\\r\\n #vel=raw_input(\\\"Ingrese la velocidad inicial (m/s): \\\")\\r\\n #se asigna el valor de error\\r\\n \\r\\n #se condione para que solo se pueden ingresar valores numericos positvios\\r\\n \\r\\n vel=float(vel)\\r\\n #se condiona que sea positivo\\r\\n if vel>0:\\r\\n #se regresa el valor de vel\\r\\n return vel\",\n \"def restar(self):\\n self.resultado = self.valor_1 - self.valor_2\",\n \"def set_novu_komponentu(self, naziv, komponenta):\\n if naziv not in self.komponente.keys():\\n self.komponente[naziv] = komponenta\",\n \"def C(self, u, v):\\n pass\",\n \"def cobroEfectivo(self):\\n if self.total_a_pagar == 0:\\n QtGui.QMessageBox.information(self,\\\"Aviso\\\",\\\"El saldo restante a pagar es cero\\\")\\n else:\\n self.rbtnEfectivo.setChecked(True)\\n monto_a_pagar, ok = QtGui.QInputDialog.getDouble(self,\\\"Cobro Efectivo\\\",\\\"Ingrese monto a pagar\\\",0,0,2000,2)\\n\\n if ok:\\n if monto_a_pagar >= self.total_a_pagar:\\n QtGui.QMessageBox.information(self,\\\"Cobro Efectivo\\\",\\\"Su vuelto es:%.2f\\\" % (monto_a_pagar - self.total_a_pagar))\\n temp = [\\\"Efectivo\\\",monto_a_pagar]\\n self.detalles_cobro[self.tablePagos.rowCount()] = temp\\n self.total_a_pagar = 0\\n elif monto_a_pagar == 0:\\n QtGui.QMessageBox.information(self,\\\"Aviso\\\",\\\"El monto ingresado no puede ser cero\\\")\\n else:\\n temp = [\\\"Efectivo\\\",monto_a_pagar]\\n self.detalles_cobro[self.tablePagos.rowCount()] = temp\\n self.total_a_pagar -= monto_a_pagar\\n\\n self.actualizar_total()\\n self.actualizar_tabla()\",\n \"def retroceder(self):\\n\\t\\tif self.pila_anteriores.esta_vacia(): \\n\\t\\t\\traise StopIteration(\\\"Esta al principio.\\\")\\n\\t\\tself.actual = self.anterior\\n\\t\\tself.anterior = self.pila_anteriores.desapilar()\\n\\t\\tself.posicion -= 1\\n\\t\\treturn self.actual.dato\",\n \"def actualizarLInv(produ,datInv,cant): # Esta sección fue hecha por Valeria \\n datInv[produ][2] += cant\\n return datInv\",\n \"def setValveCoeff(self, Kv = -1.0):\\n vv = zeros(1,'d')\\n vv[0] = Kv\\n if self._verbose:\\n print\\n print self._name+': setting valve coefficient to '+`Kv`+' kg/Pa-s'\\n self._setParameters(vv)\",\n \"def meuMetodo2(self, valor):\\n self.outroAtributo = valor\\n print(self.outroAtributo)\",\n \"def valor(self):\\n try:\\n objeto = self.objeto\\n except AttributeError:\\n objeto = None\\n return objeto\",\n \"def valor(self):\\n if self._inteiro != None:\\n return str(self._inteiro)\\n else:\\n return \\\"Sem Valor\\\"\",\n \"def update(self, v_input):\\n\\n self.v = v_input\",\n \"def vf(gravedad, tiempo):\\r\\n #se realiza un multiplicacion y el valor se le asigna a la variable vf\\r\\n vf=gravedad*tiempo\\r\\n #se regresa vf\\r\\n return vf\",\n \"def extraer(self):\\n valor=self.queue.pop(0)\\n print (f\\\"Se ha extraido exitosamente el primer valor que es: {valor}\\\")\",\n \"def set_val(self, k, a):\\n k += self.n - 1\\n self.dat[k] = a\\n while k > 0:\\n k = (k - 1) // 2 # parent\\n self.dat[k] = self.op(self.dat[k * 2 + 1], self.dat[k * 2 + 2])\",\n \"def update_V(self, Vs, Vs_next, reward, alpha, gamma):\\r\\n return Vs + alpha * (reward + gamma * Vs_next - Vs)\",\n \"def update(self, v, r):\\n pass\",\n \"def prebaci_dan_nazad(self):\\r\\n value = int(self.brojDanaCombo.currentText()) #integer broj dana\\r\\n self.emit(QtCore.SIGNAL('promjeni_datum(PyQt_PyObject)'), -value)\\r\\n msg = 'request pomak {0} dana unazad'.format(value)\\r\\n logging.info(msg)\",\n \"def morir(self):\\n self.energia = 0\\n self.vivo = False\",\n \"def acc_b_v(self):\\r\\n return self._acc_b_v\",\n \"def perde_velocidade(self, limite, limite_re):\\n if self.velocidade_carro > limite:\\n self.velocidade_carro-= 50\\n elif -600 < self.velocidade_carro < limite_re:\\n self.velocidade_carro+= 35\",\n \"def degree_v(self):\\n return self._degree_v\",\n \"def set_total_annee_precedente_lui(self, valeurs):\\r\\n \\r\\n self._total_annee_precedente_lui = valeurs\",\n \"def desplazamientox(tiempo,velocidad):\\r\\n #se realiza un operacion para encontrar el el desplzamiento horizaontal\\r\\n x=tiempo*velocidad\\r\\n #se regresa el valor de x\\r\\n return x\",\n \"def __init__(self,initial_v,v_select=0,max_dev_semitones=1):\\n self.v=initial_v\\n self.v_select=v_select\\n self.max_dev_semitones=max_dev_semitones\",\n \"def dodaj_novu_zs_ref_vrijednost(self):\\r\\n logging.info('Request za dodavanjem nove zero/span referentne vrijednosti')\\r\\n self.emit(QtCore.SIGNAL('dodaj_novu_referentnu_vrijednost'))\",\n \"def position(self, u, v):\\n raise NotImplementedError\",\n \"def vlnext(self, v: int) -> int:\\n result = self._read_inline(f\\\"vlnext({v})\\\")\\n return int(result)\",\n \"def cria_carro_volks(self):\\n\\n self.total_de_carros_volks += 1\\n print(\\\"Carro Volks #\\\", self.total_de_carros_volks, \\\" criado\\\")\",\n \"def busca(self, k):\\n x = self.getRaiz()\\n while x is not None and k != x.getChave():\\n if k < x.getChave():\\n x = x.getEsquerdo()\\n else:\\n x = x.getDireito()\\n return x\",\n \"def bouton_commencer(event):\\n\\n global vitesse_serpent\\n\\n vitesse_serpent = 200\\n variable_vitesse = 3\\n deselectionner()\\n valeur_vitesse['text'] = str(vitesse_serpent) +' ms/mvt'\\n commencer()\",\n \"def Ingresar(frm):\\r\\n #se asigna el valor de la variable seguir\\r\\n \\r\\n #se le pide al usuario que ingresa la altura\\r\\n posinicial=float(frm.txtposinicial.GetValue())\\r\\n #posinicial=raw_input(\\\"Ingrese la altura desde donde se va dejar caer (en metros): \\\")\\r\\n #se condiona para que solo permite ingresar numero positivos \\r\\n \\r\\n posinicial=float(posinicial)\\r\\n if posinicial>0:\\r\\n posinicial=posinicial+2\\r\\n return posinicial\",\n \"def cr_v(self, v, k):\\n\\n return self.cr(v[:, 0], v[:, 1], v[:, 2], k).T\",\n \"def BVS(self, value):\\n if self.reg.V:\\n self.reg.PC += value\",\n \"def save(self, *args, **kwargs):\\r\\n super(Vertex, self).save(*args, **kwargs)\\r\\n params = self.as_save_params()\\r\\n params['element_type'] = self.get_element_type()\\r\\n result = self._save_vertex(params)[0]\\r\\n self.eid = result.eid\\r\\n for k,v in self._values.items():\\r\\n v.previous_value = result._values[k].previous_value\\r\\n return result\",\n \"def getVelocity(self):\\n return self.v\",\n \"def actualizarLBI(produ,datInv,cant): # Esta sección fue hecha por Valeria \\n datInv[produ][2] -= cant\\n return datInv\",\n \"def uvozi_vloge(cur):\\n cur.execute(\\\"DELETE FROM nastopa;\\\")\\n cur.execute(\\\"DELETE FROM vloga;\\\")\\n vloge = {}\\n with open('podatki/vloge.csv') as datoteka:\\n podatki = csv.reader(datoteka)\\n stolpci = next(podatki)\\n v = stolpci.index('vloga')\\n poizvedba = \\\"\\\"\\\"\\n INSERT INTO nastopa VALUES ({})\\n \\\"\\\"\\\".format(', '.join([\\\"?\\\"] * len(stolpci)))\\n poizvedba_vloga = \\\"INSERT INTO vloga (naziv) VALUES (?);\\\"\\n for vrstica in podatki:\\n vloga = vrstica[v]\\n if vloga not in vloge:\\n cur.execute(poizvedba_vloga, [vloga])\\n vloge[vloga] = cur.lastrowid\\n vrstica[v] = vloge[vloga]\\n cur.execute(poizvedba, vrstica)\",\n \"def disminuir_vidas(self,cantidad=2):\\n self.vidas -= cantidad\",\n \"def setPrev(self, prev):\\n\\t\\t\\tself.prev = prev\",\n \"def last_value(self):\\n return 0\",\n \"def set_total_annee_precedente_elle(self, valeurs):\\r\\n \\r\\n self._total_annee_precedente_elle = valeurs\",\n \"def GetPagado(vj, idVenta, Mnd):\\n\\n pagado = 0.0\\n for idPago in vj.PagosVenta.get(idVenta,[]): # Recorre todos los pagos para la venta\\n rowPago = vj.tbPagos.rows[idPago]\\n\\n pagado += vj.Cnv( rowPago.cuc, MD.Cuc, Mnd )\\n pagado += vj.Cnv( rowPago.cup, MD.Cup, Mnd )\\n return pagado\",\n \"def V(self, point = -1):\\n return self.solution('V', point)\",\n \"def VotoNo(request, id_solicitud):\\n #tipoItemExistente = TipoItem.objects.get(id=id_tipoitem)\\n #tipoItemNuevo = TipoItem.objects.get(id=id_tipoitem)\\n solicitud = SolicitudItem.objects.get(id=id_solicitud)\\n solicitud.votos = solicitud.votos + 1\\n solicitud.votosno = solicitud.votosno + 1\\n solicitud.save()\\n messages.info(request, \\\"Su voto se registro correctamente.\\\")\\n if solicitud.completo:\\n return HttpResponseRedirect('/admin/todo/item/')\\n else:\\n return HttpResponseRedirect('/admin/todo/solicituditem/')\",\n \"def sibling(self, v):\\n # method here\",\n \"def extraer(self):\\n valor=self.stack.pop()\\n print (f\\\"Se ha extraido exitosamente el ultimo valor que es: {valor}\\\")\",\n \"def unkV(self):\\n if self._unkV is None:\\n self._unkV = self.V.mean(0)\\n return self._unkV\",\n \"def __init__(self, v, p):\\n self.val = v\\n self.priority = p\",\n \"def getRevuelto(self):\\r\\n\\t\\treturn self.__revuelto\",\n \"def on_spinBox_valueChanged(self, p0):\\n self.nbr_pts_caracterisation = self.spinBox.value()\",\n \"def limpiarVentana(self):\\n self.limpiarTabla(self.tableFactura)\\n self.lineNumero.setEnabled(True)\\n self.lineNumero.clear()\\n self.limpiarTabla(self.tableNC)\",\n \"def on_pushButton_precedent_clicked(self):\\n \\n if self.lineEdit_temperature.text() !=\\\"\\\":\\n num_pt =int(self.label_pt.text())\\n if num_pt - 1 < 1:\\n pass\\n else:\\n \\n #effacement\\n for ligne in range(11):\\n for colonne in range(8):\\n if colonne !=6:\\n \\n self.tableWidget_mesures.setItem(ligne, colonne, QtGui.QTableWidgetItem(None))\\n self.lineEdit_temperature.clear()\\n self.lineEdit_stab_max.clear()\\n self.lineEdit_u_stab_max.clear() \\n self.lineEdit_hom_max_2.clear()\\n self.lineEdit_u_hom_max.clear()\\n \\n else:\\n pass\\n #reafctation des donnees \\n self.reaffectation_table_widget_mesures(str(int(self.label_pt.text())-1)) \\n \\n #presentation textEdit n°pt de la mesure\\n self.label_pt.setText(str(num_pt -1))\",\n \"def getPrev(self):\\n\\t\\t\\treturn self.prev\",\n \"def get_value(self):\\r\\n return 0\",\n \"def limpiarVentana(self):\\n\\n self.productosAgregados=0\\n self.lotesVentas={}\\n self.facturaCobrada=False\\n self.obraSocialSeleccionada=None\\n self.formapago = None\\n self.factura = None\\n self.data = {}\\n self.detallesTabla = {}\\n self.lineObra.clear()\\n self.lineObra.setEnabled(True)\\n self.lineCuit.clear()\\n self.lineCuit.setEnabled(True)\\n self.tableObra.setVisible(False)\\n self.rbtnObra.setChecked(False)\\n self.limpiarTabla(self.tableProductos)\\n self.limpiarTabla(self.tableFactura)\\n self.cargarProductosSinObra()\",\n \"def insertar(self, dato):\\n\\t\\tif self.posicion == 0:\\n\\t\\t\\tself.lista.insertar_primero(dato) \\n\\t\\t\\tself.actual = self.lista.prim \\n\\t\\t\\treturn self.actual.dato\\n\\t\\tnodo = _Nodo(dato)\\n\\t\\tself.anterior.prox = nodo\\n\\t\\tnodo.prox = self.actual\\n\\t\\tself.actual = nodo\\n\\t\\tself.lista.len += 1\\n\\t\\treturn self.actual.dato\",\n \"def avanzar(self):\\n\\t\\tif (not len(self.lista)) or (self.esta_al_final()): \\n\\t\\t\\traise StopIteration(\\\"Esta al final.\\\")\\n\\t\\tself.pila_anteriores.apilar(self.anterior)\\n\\t\\tself.anterior = self.actual\\n\\t\\tself.actual = self.actual.prox\\n\\t\\tself.posicion += 1\\n\\t\\treturn self.actual.dato\",\n \"def actualizar_puntaje(self):\\r\\n pass\",\n \"def on_VDepositValue_editingFinished(self):\\n # TODO: not implemented yet\\n # raise NotImplementedError\\n value = self.VDepositValue.text()\\n if JudgeStr2Float(value):\\n self.depositValue = float(value)\\n print(f\\\"Validator Deposit with {value} MAN\\\")\\n else:\\n self.vdepositValue = 0\\n self.VDepositValue.clear()\\n # self.VDepositValue.setFocus()\",\n \"def rokadaV(self, color):\\n if(color == 'w'):\\n self.data[7][3] = 'wr'\\n self.data[7][2] = 'wk'\\n self.data[7][4] = '.'\\n self.data[7][0] = '.'\\n self.kralj_beli_koriscen = True\\n self.previous_positions = [7, 2]\\n\\n else:\\n self.data[0][3] = 'br'\\n self.data[0][2] = 'bk'\\n self.data[0][4] = '.'\\n self.data[0][0] = '.'\\n self.kralj_crni_koriscen = True\\n self.previous_positions = [0, 2]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5935664","0.58318734","0.57799566","0.573883","0.56817716","0.56737953","0.56477207","0.5641579","0.5633477","0.56009114","0.55635613","0.5553526","0.5553526","0.55367154","0.5518482","0.54913104","0.54913104","0.54346764","0.5428058","0.5373884","0.5373884","0.5373884","0.53549194","0.53037804","0.527357","0.52722114","0.52557033","0.5234049","0.52286774","0.52257794","0.52231365","0.5218102","0.52045524","0.5199618","0.5164519","0.51413095","0.51301277","0.51161355","0.5104271","0.5098293","0.50906795","0.508137","0.50545","0.504929","0.5035996","0.5035983","0.49761257","0.49679527","0.4952925","0.49383262","0.49331388","0.4930223","0.49277988","0.49128458","0.49107465","0.4910704","0.49043012","0.4894583","0.48872674","0.48841605","0.48832285","0.48807645","0.48655352","0.48574972","0.48511896","0.48411357","0.4839108","0.4822741","0.48220086","0.48013985","0.47979823","0.47941443","0.4791198","0.47881657","0.47872838","0.47748235","0.47710824","0.4770583","0.47643498","0.47629482","0.47595724","0.47547865","0.4752008","0.47487307","0.47461322","0.47458085","0.4737928","0.4736754","0.4735773","0.47236446","0.47225288","0.47103357","0.47036338","0.47029197","0.46951282","0.46879417","0.46797362","0.46795428","0.46754873","0.46692556"],"string":"[\n \"0.5935664\",\n \"0.58318734\",\n \"0.57799566\",\n \"0.573883\",\n \"0.56817716\",\n \"0.56737953\",\n \"0.56477207\",\n \"0.5641579\",\n \"0.5633477\",\n \"0.56009114\",\n \"0.55635613\",\n \"0.5553526\",\n \"0.5553526\",\n \"0.55367154\",\n \"0.5518482\",\n \"0.54913104\",\n \"0.54913104\",\n \"0.54346764\",\n \"0.5428058\",\n \"0.5373884\",\n \"0.5373884\",\n \"0.5373884\",\n \"0.53549194\",\n \"0.53037804\",\n \"0.527357\",\n \"0.52722114\",\n \"0.52557033\",\n \"0.5234049\",\n \"0.52286774\",\n \"0.52257794\",\n \"0.52231365\",\n \"0.5218102\",\n \"0.52045524\",\n \"0.5199618\",\n \"0.5164519\",\n \"0.51413095\",\n \"0.51301277\",\n \"0.51161355\",\n \"0.5104271\",\n \"0.5098293\",\n \"0.50906795\",\n \"0.508137\",\n \"0.50545\",\n \"0.504929\",\n \"0.5035996\",\n \"0.5035983\",\n \"0.49761257\",\n \"0.49679527\",\n \"0.4952925\",\n \"0.49383262\",\n \"0.49331388\",\n \"0.4930223\",\n \"0.49277988\",\n \"0.49128458\",\n \"0.49107465\",\n \"0.4910704\",\n \"0.49043012\",\n \"0.4894583\",\n \"0.48872674\",\n \"0.48841605\",\n \"0.48832285\",\n \"0.48807645\",\n \"0.48655352\",\n \"0.48574972\",\n \"0.48511896\",\n \"0.48411357\",\n \"0.4839108\",\n \"0.4822741\",\n \"0.48220086\",\n \"0.48013985\",\n \"0.47979823\",\n \"0.47941443\",\n \"0.4791198\",\n \"0.47881657\",\n \"0.47872838\",\n \"0.47748235\",\n \"0.47710824\",\n \"0.4770583\",\n \"0.47643498\",\n \"0.47629482\",\n \"0.47595724\",\n \"0.47547865\",\n \"0.4752008\",\n \"0.47487307\",\n \"0.47461322\",\n \"0.47458085\",\n \"0.4737928\",\n \"0.4736754\",\n \"0.4735773\",\n \"0.47236446\",\n \"0.47225288\",\n \"0.47103357\",\n \"0.47036338\",\n \"0.47029197\",\n \"0.46951282\",\n \"0.46879417\",\n \"0.46797362\",\n \"0.46795428\",\n \"0.46754873\",\n \"0.46692556\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5369091"},"document_rank":{"kind":"string","value":"22"}}},{"rowIdx":79080,"cells":{"query":{"kind":"string","value":"Obtiene el valor del kesimo elemento."},"document":{"kind":"string","value":"def __getitem__(self, k):\n\n it = Historial.__getitem__(self, k)\n if it != None:\n return it[1]\n else:\n return it"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def valor(self):\n try:\n objeto = self.objeto\n except AttributeError:\n objeto = None\n return objeto","def valor(self):\n if self._inteiro != None:\n return str(self._inteiro)\n else:\n return \"Sem Valor\"","def getval(self):\r\n return self.value","def value(self):\n return self.element.get_attribute('value')","def value(self):\n return self.element.get_attribute('value')","def value(self):\n return self.element.get_attribute('value')","def get_value(self):","def value(self) -> str:\n logging.info(f\"get element value. {self.desc}\")\n js = f\"\"\"return document.querySelectorAll(\"{self.css}\")[{self.index}].value;\"\"\"\n return self._execute_javascript(js)","def get_val(self):\n return","def value(self):\n return self.get_attribute(\"value\", str(self.children))","def get_value(self):\n pass","def get_value(self):\r\n return 0","def get_val(self):\n return self.value","def get_value(self):\n return self.value","def get_value(self):\n return self.value","def get_value(self):\n return self.value","def __int__(self):\n\n return self.value","def value(self):\n\n return self.element().get_attribute('value') if self.exists() else ''","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n\n\t\treturn self.__value","def elemento_actual(self):\n\t\tif not self.actual:\n\t\t\treturn None\n\t\treturn self.actual.dato","def get_value(self):\n return None","def getvalue(self):\n ...","def getvalue(self):\n ...","def get_value(self):\n return self._value","def get_value(self):\n return self._value","def get_value(self):\n return self._value","def getValue(self):\n return self.value","def value(self):\n return self.get_data(\"value\")","def value(self):\n return self.node_value","def value(self):\n return self.value()._value","def value(self):\n return self.__value","def value(self):\n return self.__value","def _get_value(self):\n return self.__value","def getValue(self, o: ghidra.util.graph.KeyedObject) -> int:\n ...","def value (self):\r\n return self.entry.get()","def value(self):","def value(self):\n return self._val","def _value(self):\n return self.device.value(*self._id[1:])","def get_value(self):\n return self._val","def getValue(self) -> int:\n ...","def value(self) -> str:\n return pulumi.get(self, \"value\")","def value(self) -> str:\n return pulumi.get(self, \"value\")","def value(self) -> str:\n return pulumi.get(self, \"value\")","def value(self) -> str:\n return pulumi.get(self, \"value\")","def value(self) -> str:\n return pulumi.get(self, \"value\")","def value(self) -> str:\n return pulumi.get(self, \"value\")","def value(self) -> str:\n return pulumi.get(self, \"value\")","def value(self) -> str:\n return pulumi.get(self, \"value\")","def value(self) -> str:\n return pulumi.get(self, \"value\")","def value(self) -> str:\n return pulumi.get(self, \"value\")","def value(self) -> str:\n return pulumi.get(self, \"value\")","def value(self) -> str:\n return pulumi.get(self, \"value\")","def value(self) -> str:\n return pulumi.get(self, \"value\")","def value(self) -> str:\n return pulumi.get(self, \"value\")","def get_value(self):\n return self._value","def get_value(self):\n return self._value","def get_value(self):\n return self._value","def getValue(self):\n return self.text()","def getValue(self):\n return self.value","def value(self):\n return self.__n","def value(self):\n return self._","def value (self) :\n\n return self.__value__","def value(self):\n return int(self.input.text())","def Value(self) -> _n_0_t_14:","def val(self):\n return self.v","def Value(self) -> str:","def value(self) -> str:\n return self[\"Value\"]","def Get(self):\n value=0\n return value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def value(self):\n return self._value","def GetValue(self):\n return self._value","def GetValue(self):\n return self._value","def _get_value(self):\n \n return self._value"],"string":"[\n \"def valor(self):\\n try:\\n objeto = self.objeto\\n except AttributeError:\\n objeto = None\\n return objeto\",\n \"def valor(self):\\n if self._inteiro != None:\\n return str(self._inteiro)\\n else:\\n return \\\"Sem Valor\\\"\",\n \"def getval(self):\\r\\n return self.value\",\n \"def value(self):\\n return self.element.get_attribute('value')\",\n \"def value(self):\\n return self.element.get_attribute('value')\",\n \"def value(self):\\n return self.element.get_attribute('value')\",\n \"def get_value(self):\",\n \"def value(self) -> str:\\n logging.info(f\\\"get element value. {self.desc}\\\")\\n js = f\\\"\\\"\\\"return document.querySelectorAll(\\\"{self.css}\\\")[{self.index}].value;\\\"\\\"\\\"\\n return self._execute_javascript(js)\",\n \"def get_val(self):\\n return\",\n \"def value(self):\\n return self.get_attribute(\\\"value\\\", str(self.children))\",\n \"def get_value(self):\\n pass\",\n \"def get_value(self):\\r\\n return 0\",\n \"def get_val(self):\\n return self.value\",\n \"def get_value(self):\\n return self.value\",\n \"def get_value(self):\\n return self.value\",\n \"def get_value(self):\\n return self.value\",\n \"def __int__(self):\\n\\n return self.value\",\n \"def value(self):\\n\\n return self.element().get_attribute('value') if self.exists() else ''\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n\\n\\t\\treturn self.__value\",\n \"def elemento_actual(self):\\n\\t\\tif not self.actual:\\n\\t\\t\\treturn None\\n\\t\\treturn self.actual.dato\",\n \"def get_value(self):\\n return None\",\n \"def getvalue(self):\\n ...\",\n \"def getvalue(self):\\n ...\",\n \"def get_value(self):\\n return self._value\",\n \"def get_value(self):\\n return self._value\",\n \"def get_value(self):\\n return self._value\",\n \"def getValue(self):\\n return self.value\",\n \"def value(self):\\n return self.get_data(\\\"value\\\")\",\n \"def value(self):\\n return self.node_value\",\n \"def value(self):\\n return self.value()._value\",\n \"def value(self):\\n return self.__value\",\n \"def value(self):\\n return self.__value\",\n \"def _get_value(self):\\n return self.__value\",\n \"def getValue(self, o: ghidra.util.graph.KeyedObject) -> int:\\n ...\",\n \"def value (self):\\r\\n return self.entry.get()\",\n \"def value(self):\",\n \"def value(self):\\n return self._val\",\n \"def _value(self):\\n return self.device.value(*self._id[1:])\",\n \"def get_value(self):\\n return self._val\",\n \"def getValue(self) -> int:\\n ...\",\n \"def value(self) -> str:\\n return pulumi.get(self, \\\"value\\\")\",\n \"def value(self) -> str:\\n return pulumi.get(self, \\\"value\\\")\",\n \"def value(self) -> str:\\n return pulumi.get(self, \\\"value\\\")\",\n \"def value(self) -> str:\\n return pulumi.get(self, \\\"value\\\")\",\n \"def value(self) -> str:\\n return pulumi.get(self, \\\"value\\\")\",\n \"def value(self) -> str:\\n return pulumi.get(self, \\\"value\\\")\",\n \"def value(self) -> str:\\n return pulumi.get(self, \\\"value\\\")\",\n \"def value(self) -> str:\\n return pulumi.get(self, \\\"value\\\")\",\n \"def value(self) -> str:\\n return pulumi.get(self, \\\"value\\\")\",\n \"def value(self) -> str:\\n return pulumi.get(self, \\\"value\\\")\",\n \"def value(self) -> str:\\n return pulumi.get(self, \\\"value\\\")\",\n \"def value(self) -> str:\\n return pulumi.get(self, \\\"value\\\")\",\n \"def value(self) -> str:\\n return pulumi.get(self, \\\"value\\\")\",\n \"def value(self) -> str:\\n return pulumi.get(self, \\\"value\\\")\",\n \"def get_value(self):\\n return self._value\",\n \"def get_value(self):\\n return self._value\",\n \"def get_value(self):\\n return self._value\",\n \"def getValue(self):\\n return self.text()\",\n \"def getValue(self):\\n return self.value\",\n \"def value(self):\\n return self.__n\",\n \"def value(self):\\n return self._\",\n \"def value (self) :\\n\\n return self.__value__\",\n \"def value(self):\\n return int(self.input.text())\",\n \"def Value(self) -> _n_0_t_14:\",\n \"def val(self):\\n return self.v\",\n \"def Value(self) -> str:\",\n \"def value(self) -> str:\\n return self[\\\"Value\\\"]\",\n \"def Get(self):\\n value=0\\n return value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def value(self):\\n return self._value\",\n \"def GetValue(self):\\n return self._value\",\n \"def GetValue(self):\\n return self._value\",\n \"def _get_value(self):\\n \\n return self._value\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7187529","0.71030325","0.65446925","0.6502201","0.6502201","0.6502201","0.6472011","0.6464514","0.6441088","0.6440774","0.64297825","0.64091015","0.6393591","0.6393024","0.6393024","0.6393024","0.6356786","0.6339224","0.6331197","0.6331197","0.6327495","0.6318455","0.6315065","0.6313969","0.6313969","0.6290449","0.6290449","0.62824726","0.6268449","0.62567323","0.6254912","0.625218","0.6245634","0.6245634","0.62344384","0.6232697","0.6230665","0.6224657","0.6211458","0.6194329","0.6183511","0.6180424","0.6175478","0.6175478","0.6175478","0.6175478","0.6175478","0.6175478","0.6175478","0.6175478","0.6175478","0.6175478","0.6175478","0.6175478","0.6175478","0.6175478","0.6166397","0.6166397","0.6166397","0.6163792","0.6151492","0.6143967","0.6136297","0.6125346","0.61236453","0.6119623","0.61124545","0.61038715","0.6099147","0.60946023","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.6092947","0.60838866","0.60838866","0.6075742"],"string":"[\n \"0.7187529\",\n \"0.71030325\",\n \"0.65446925\",\n \"0.6502201\",\n \"0.6502201\",\n \"0.6502201\",\n \"0.6472011\",\n \"0.6464514\",\n \"0.6441088\",\n \"0.6440774\",\n \"0.64297825\",\n \"0.64091015\",\n \"0.6393591\",\n \"0.6393024\",\n \"0.6393024\",\n \"0.6393024\",\n \"0.6356786\",\n \"0.6339224\",\n \"0.6331197\",\n \"0.6331197\",\n \"0.6327495\",\n \"0.6318455\",\n \"0.6315065\",\n \"0.6313969\",\n \"0.6313969\",\n \"0.6290449\",\n \"0.6290449\",\n \"0.62824726\",\n \"0.6268449\",\n \"0.62567323\",\n \"0.6254912\",\n \"0.625218\",\n \"0.6245634\",\n \"0.6245634\",\n \"0.62344384\",\n \"0.6232697\",\n \"0.6230665\",\n \"0.6224657\",\n \"0.6211458\",\n \"0.6194329\",\n \"0.6183511\",\n \"0.6180424\",\n \"0.6175478\",\n \"0.6175478\",\n \"0.6175478\",\n \"0.6175478\",\n \"0.6175478\",\n \"0.6175478\",\n \"0.6175478\",\n \"0.6175478\",\n \"0.6175478\",\n \"0.6175478\",\n \"0.6175478\",\n \"0.6175478\",\n \"0.6175478\",\n \"0.6175478\",\n \"0.6166397\",\n \"0.6166397\",\n \"0.6166397\",\n \"0.6163792\",\n \"0.6151492\",\n \"0.6143967\",\n \"0.6136297\",\n \"0.6125346\",\n \"0.61236453\",\n \"0.6119623\",\n \"0.61124545\",\n \"0.61038715\",\n \"0.6099147\",\n \"0.60946023\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.6092947\",\n \"0.60838866\",\n \"0.60838866\",\n \"0.6075742\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":79081,"cells":{"query":{"kind":"string","value":"Obtiene el tiempo del kesimo elemento (por el final)."},"document":{"kind":"string","value":"def time(self, k):\n \n it = Historial.__getitem__(self, k)\n if it != None:\n return it[0]\n else:\n return None"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def letra_tiempo(self):\n return self.letra, self.tiempo","def get_t(self):\n return self.t","def get_tin(self):\n return self.tin[:]","def Temp(t):\n return 20 # Need to link to data","def _get_max_t(self):\n \"\"\"\n if hasattr(self,'k_of_t'):\n return max([ \n self.s_of_t[-1][0],\n self.i_of_t[-1][0],\n self.r_of_t[-1][0],\n self.k_of_t[-1][0],\n ])\n else:\n return max([ \n self.s_of_t[-1][0],\n self.i_of_t[-1][0],\n self.r_of_t[-1][0],\n ])\n \"\"\"\n return self.t_max","def longitud_traza(self):\n ret = 0\n for p in range(len(self.trazado) - 1):\n ret += self.trazado[p].distancia(self.trazado[p + 1])\n return ret","def calcular_traspuesta(self):\n # supongo que el nodo de mayor indice en je es el maximo nodo que hay\n n1 = np.max(self.je) + 1 # el +1 es por la base-0 de python\n # ahora para cada elem1, recorro los elem0 para ver las conexiones\n # notar que supondre que los elems0 son range(self.num) y los elems1 son range(n1)\n jeT = []\n len_jeT = 0\n neT = np.zeros(n1, dtype=int)\n for i1 in range(n1): # aca supongo que los elems1 son range(n1), o sea una lista de indices\n for i0 in range(self.num): # idem para elems0, son una lista de indices\n elem0 = self.get_con_elem0(i0)\n if i1 in elem0:\n jeT.append(i0)\n len_jeT += 1\n neT[i1] += 1\n # convierto el jeT a numpy\n jeT = np.array(jeT, dtype=int)\n # ensamblo el ieT\n ieT = np.zeros(n1+1, dtype=int)\n ieT[n1] = len_jeT # empiezo con el indice de un elemento extra que no existe\n for i1 in range(n1-1, -1, -1):\n ieT[i1] = ieT[i1+1] - neT[i1] # de ahi calculo el indice donde empieza cada elemento\n return n1, len_jeT, neT, ieT, jeT","def total_te(self):\r\n return sum(map(lambda x: self.times[x]['te'], self.times))","def t(self):\n return self._t","def t(self):\n return self._t","def _get_tb(I, nu, beam):\n from astropy import units as u\n return (1222.0*I/(nu**2*(beam.minor/1.0).to(u.arcsecond)*(beam.major/1.0).to(u.arcsecond))).value","def ti_func(self):\n return self.ti.val - self.calc_ti()","def t0(self):\n return self._t0","def elemento_actual(self):\n\t\tif not self.actual:\n\t\t\treturn None\n\t\treturn self.actual.dato","def oldest_txo(self) -> int:","def tempo(self):\n text = self._get_menu_item_text('Edit->Tempo')\n return float(re.search(r'\\[([0-9.,]+)\\]$', text).group(1))","def tt(self):\n return self.MJD + self.tt_ut1 + 2400000.5","def getTempo():\r\n global dauer\r\n \r\n dauer = 0.0\r\n counter = 1\r\n\r\n for x in midi_data.get_tempo_changes(): #pretty_midi saves the tempo of a midi-file in nested-arrays, therefore a few for-loops and if statements are necessary\r\n for e in x:\r\n if e > 0:\r\n if counter > 0:\r\n tempi.append(round(e))\r\n counter = 0\r\n break\r\n \r\n dauer = 60000/(e/4)","def f_columnas_tiempos(param_data):\n\n # convertir columna de 'closetime' y 'opentime' utilizando pd.to_datetime\n param_data['closetime'] = pd.to_datetime(param_data['closetime'])\n param_data['opentime'] = pd.to_datetime(param_data['opentime'])\n\n # tiempo transcurrido de una operacion\n param_data['tiempo'] = [(param_data.loc[i, 'closetime'] - param_data.loc[i, 'opentime']).delta / 1e9\n for i in param_data.index]\n\n return param_data","def get_tim(self):\n return self.sum(axis=0)","def T_i(self) -> u.K:\n return self._T_i","def T_i(self) -> u.K:\n return self._T_i","def get_t_value(self):\n return float(self.data[2]) / 10","def T(self):\n return self.__T","def reemplaza_tildes(palabra):","def __call__(self):\n \n if self.funciona:\n t = self.timeFunc() - self.t0 - self.retraso\n elif self.t0!=None:\n t = self.parada - self.t0 - self.retraso\n else:\n t = None\n return t","def tic(self):\n return self._timestamp","def tetrakis(self):\n return self.nlegomena(4)","def tau_ruptura_prem( largo_falla, prof_media, prof_prem, vs_prem ):\n\n dif_profs = np.abs( prof_prem - prof_media )\n idx_prof_media = np.where( dif_profs == dif_profs.min() )\n vs_prof_media = vs_prem[idx_prof_media]\n\n # puede que la profundidad media de la falla se encuentre justo entre 2 valores del modelo\n # si esto sucede, se calcula el promedio de las velocidades de ambos\n if len(vs_prof_media) > 1:\n vs_prof_media = vs_prof_media.mean()\n else:\n vs_prof_media = vs_prof_media\n\n tau = largo_falla/( 0.8 * vs_prof_media )\n\n return tau","def _get_max_t(self):\n\n return max([\n self.s_of_t[-1][0],\n self.i_of_t[-1][0],\n self.r_of_t[-1][0],\n ])","def table(self):\n return self.t","def T(self, point = -1):\n return self.solution('T', point)","def _Mn_Tubo(perfil, data=False):\n\n Mrd_dados = namedtuple(\"Mrd_dados\", \"Mn elp elr\")\n\n elp = 0.07 * perfil.mat.E / perfil.mat.fy\n elr = 0.31 * perfil.mat.E / perfil.mat.fy\n\n if perfil.esb <= elp:\n Mn = perfil.Mplx\n return Mn if not data else (Mn, Mrd_dados(Mn, elp, elr))\n\n elif elp < perfil.esb <= elr:\n Mn = 0.021 * (perfil.mat.E / perfil.esb + perfil.mat.fy) * perfil.W\n return Mn if not data else (Mn, Mrd_dados(Mn, elp, elr))\n else:\n Fcr = 0.33 * perfil.mat.E / perfil.esb\n Mn = Fcr * perfil.W\n return Mn if not data else (Mn, Mrd_dados(Mn, elp, elr))","def MINET(self):","def total_tr(self):\r\n return sum(map(lambda x: self.times[x]['tr'], self.times))","def ticket_salida(self):\n total = 0.0\n for x in self.mi_parqueo:\n total=x.cobro=total\n\n print(\"El costo total es de :\",total)","def tauPoint(numDeps, tauRos, tau):\r\n\r\n #int index;\r\n\r\n help = [0.0 for i in range(numDeps)]\r\n\r\n for i in range(0, numDeps):\r\n\r\n help[i] = tauRos[0][i] - tau\r\n help[i] = abs(help[i])\r\n\r\n \r\n index = 0\r\n min = help[index]\r\n\r\n for i in range(1, numDeps):\r\n\r\n if (help[i] < min): \r\n min = help[i]\r\n index = i\r\n \r\n\r\n return index","def mostrar_ultimo(self):\n participantes = self.__puntuacion_total()\n podio = self.__armar_podio(participantes)\n print(\n f\"\"\"\n ===================================\n ========== ULTIMO PUESTO ==========\n ===================================\n id disparo: {podio[0]['idDisparo']},\n Disparos: {podio[0]['disparos']},\n Numero participante: {podio[0]['nroParticipante']},\n Nombre: {podio[0]['nombre']},\n Apellido: {podio[0]['apellido']},\n Edad: {podio[0]['edad']},\n sexo: {podio[0]['sexo']},\n Puntaje: {podio[0]['puntaje_total']}\n ===================================\n ===================================\n \"\"\"\n )","def max_temp(self):\n return 99","def prueba_temple_simulado(problema=ProblemaNreinas(8),calendarizacion=None):\n start = time.time()\n solucion = blocales.temple_simulado(problema,calendarizacion)\n #print(\"\\n\\nTemple simulado con calendarización To/(1 + i).\")\n print(\"Costo de la solución: \", problema.costo(solucion))\n print(\"Y la solución es: \")\n print(solucion)\n end = time.time()\n print(\"Tiempo que tarda: Segundos..: \" + str(end - start))","def calc_ti(self):\n m = 0\n for i in self.inl:\n m += i.m.val_SI * i.fluid.val[self.fuel_alias.val]\n\n for o in self.outl:\n m -= o.m.val_SI * o.fluid.val[self.fuel_alias.val]\n\n return m * self.lhv","def get_tema(data):\n if data is None:\n raise EmptyDataError('[!] Invalid data value')\n\n result = TA.TEMA(data)\n if result is None:\n raise IndicatorException\n return result","def getWeightTime(self, index):\r\n\t\treturn None","def getTime(self) -> float:\n return self.t","def item_t(data_alt, item, min_t):\n for t in data_alt[item]:\n if t >= min_t:\n return t\n return None","def time_list(self):\n return (self.N_T * (np.arange(self.N_itr) + 1) /\n self.N_itr * 1000 * self.DT)","def get_t_vec(self):\n t_vec = np.arange(0, self.get_T(), self.get_dt())\n\n # Shape checks.\n if 'ser' in self.keys() and 'spktrains' in self['ser'].keys():\n assert self.ser_spktrains.shape[2] == len(\n t_vec\n ), 'Bad t_vec length ({})'.format(len(t_vec))\n if 'gaba' in self.keys() and 'spktrains' in self['gaba'].keys():\n assert self.gaba_spktrains.shape[2] == len(\n t_vec\n ), 'Bad t_vec length ({})'.format(len(t_vec))\n\n return t_vec","def _self_time(self):\r\n return self.duration() - sum([child.duration() for child in self.children])","def __call__(self, t):\n \n c = c1 = c2 = 0\n d = d1 = d2 = None\n while d1==None or d2==None or d<=d2:\n _t = self.time(c)\n if _t == None:\n break\n else:\n d = abs(t - _t)\n if d1 == None or d<d1:\n c1, d1 = c, d\n elif d2 == None or d<d2:\n c2, d2 = c, d\n c += 1\n t1, t2 = map(self.time, [c1, c2])\n v1, v2 = map(self.__getitem__, [c1, c2])\n # a lo mejor la lista solo contiene un elemento\n if t1 == t2:\n return v1\n else:\n # si contiene por lo menos dos, pues interpolacion lineal\n return (v2*(t - t1) - v1*(t - t2))/(t2 - t1)","def compute_iactT(data):\n\t# get only the timestamps\n\ttime = data[0]\n\tprevT = time[0]\n\n\ttotalT = len(time)*0.1\n\n\treturn totalT","def timenow(self):\n return (datetime.now().strftime(\"%H:%M:%S\"))","def tam_relativo(self, code):\n return len(self.compartimentos[code]) / float(self.n)","def precio_descuento(self):\n descount_price = self.html.xpath(self.xpath_descount_price)\n precio_descuento = map(self.limpieza_precio, descount_price)\n return precio_descuento","def heeftTemperatuurmeting(self):\n return self._heeftTemperatuurmeting.get_waarde()","def contamination_heterozygote(self, mere):\n hauteur_allele_contaminant = 99999999999999999.0\n hauteur_allele_different = None\n taux_contamination = 0\n for allele in range(3):\n if self.hauteur[allele] < hauteur_allele_contaminant:\n hauteur_allele_contaminant = self.hauteur[allele]\n for alleles in range(3):\n if self.allele[alleles] not in mere.allele:\n hauteur_allele_different = self.hauteur[alleles]\n taux_contamination = ((hauteur_allele_contaminant) / (\n hauteur_allele_different + hauteur_allele_contaminant)) * 100\n self.taux = round(taux_contamination, 2)","def valorEsperado(obs,ket):\n cal=Calculadora()\n obsSobreket=cal.accion(obs,ket)\n bra=cal.matrizConjugada(obsSobreket)\n ket1=cal.transpuesta([ket])\n bra1=cal.transpuesta(bra)\n car=cal.multiplicacionMatrizMatriz(bra1,ket1)[0][0]\n return car","def getETA():","def getETA():","def suffixe(self, autre):\n if autre.tete is None: # liste vide\n return\n\n partage = False # boolean qui indique si la liste partage au moins une cellule ou pas\n for cel in self.cellules():\n if cel.utilisation > 1: # dès qu'on trouve une cellule partagée\n partage = True\n break\n\n if partage: # si la liste partage des cellules\n vu_premiere = True\n doublage = False\n premiere = True\n prec = self.tete\n for cel in self.cellules():\n if vu_premiere and cel.utilisation > 1: # dès qu'on trouve une cel partagée (1 fois)\n vu_premiere = False\n doublage = True\n cel.utilisation -= 1\n if doublage: # si on commence à doubler la partie partagée\n cel_double = Cellule(cel.valeur)\n if premiere: # cas initial (1 fois)\n premiere = False\n if cel == self.tete: # si c'est la première cellule qu'on supprime\n self.tete = cel_double\n else: # cas général\n prec.suivant = cel_double\n else: # cas itératif\n prec.suivant = cel_double\n prec = cel_double\n else:\n prec = cel\n prec.suivant = autre.tete\n autre.tete.utilisation += 1\n\n else: # sinon, si la liste ne partage aucune cellule\n if partage is False:\n for cel in self.cellules():\n if cel.suivant is None:\n cel.suivant = autre.tete\n autre.tete.utilisation += 1\n\n self.taille += autre.taille","def homozygote_contamine(self, echantillon):\n seuil = echantillon.get_seuil_hauteur()\n if self.hauteur[1] < self.hauteur[0] * seuil:\n allele_contaminant = 1\n taux = ((2 * self.hauteur[allele_contaminant]) / (self.hauteur[allele_contaminant] + self.hauteur[0])) * 100\n else:\n allele_contaminant = 0\n taux = ((2 * self.hauteur[allele_contaminant]) / (self.hauteur[allele_contaminant] + self.hauteur[1])) * 100\n self.taux = round(taux, 2)","def teid(self):\n return self._teid","def t0(self):\n return self._time_axis.start","def get_tetromino(self):\n tetromino = random.randint(1, 8)\n if tetromino == self.previous_tetromino or tetromino == 8:\n tetromino = random.randint(1, 7)\n self.previous_tetromino = tetromino\n return Tetromino(tetromino, 5, 2, 0, TETROMINOES[tetromino - 1])","def tabelaOrareve():\n \n linja = 1\n kpm = \"3\"\n\n #print(f\"linja {oraret['linja1']} mberrin ne {kpm} minuta\")\n print(f\"Oraret per linjen 1 :\\n {oraret['linja1']}\\n, {oraret['linja2']}\\n, {oraret['linja3']}\\n\")","def calculer_energie_cinetique_tnt(energie_cinetique):\n return energie_cinetique / 4184","def tt_ut1(self):\n # return the delta time for the input date converted to days\n return interpolate_delta_time(_delta_file, self.tide)","def ottieni_ultimi(astaid, Oggetto, numero=0):\n queryS = Oggetto.objects.filter(asta__id=astaid).order_by('-id')\n if(int(numero)==0):\n ultimi = queryS.all()\n else:\n ultimi = queryS[:numero]\n return ultimi","def valg(self):\n\n lengde_mtrekk = len(self.motstander_trekk)\n\n if (lengde_mtrekk == 0) or (self.husk ==\n 0):\n return self._random_trekk()\n\n elif lengde_mtrekk <= self.husk:\n\n \"\"\"sekvens skal inneholde like mange elementer som husk\"\"\"\n if len(self.sekvens) < self.husk:\n self.sekvens.append(self.motstander_trekk[-1])\n\n return self._random_trekk()\n\n else:\n self.sekvens = self.motstander_trekk[-self.husk:]\n\n print(self.motstander_trekk)\n print(self.sekvens)\n\n self.kopi_trekk = self.motstander_trekk.copy()\n\n \"\"\"trekkene uten siste sekvens\"\"\"\n self.kopi_trekk = self.kopi_trekk[:len(\n self.kopi_trekk) - self.husk]\n print(self.kopi_trekk)\n\n \"\"\"rangerer trekkene som oftest SLÅR det motstanderen spiller etter sekvensen\"\"\"\n self.trekk_mot = {\"stein\": 0, \"saks\": 0, \"papir\": 0}\n\n \"\"\"sjekker så lenge starten på sekvensen er med i motstanderens trekk fjerner\"\"\"\n while (self.sekvens[0] in self.kopi_trekk) and (\n len(self.kopi_trekk) > self.husk):\n\n index_start = self.kopi_trekk.index(self.sekvens[0])\n\n if self.sekvens == self.kopi_trekk[index_start: (\n index_start + len(self.sekvens))]:\n print(\"den er med!\")\n print(index_start)\n index_slutt = index_start + len(self.sekvens)\n\n \"\"\"hvis index_slutt er utenfor kopi_trekk, så skal while løkken stoppes\"\"\"\n if index_slutt >= len(self.kopi_trekk):\n break\n\n print(index_slutt)\n \"\"\"ser på neste trekk etter sekvensen\"\"\"\n forventet_trekk = self.kopi_trekk[index_slutt]\n \"\"\"setter slutten som den nye starten\"\"\"\n self.kopi_trekk = self.kopi_trekk[index_slutt:]\n print(self.kopi_trekk)\n\n temp = Sammenlikning(forventet_trekk)\n print(\"1\" + forventet_trekk)\n vinner_trekk = temp.taper_mot\n print(\"2\" + vinner_trekk)\n\n self.trekk_mot[vinner_trekk] += 1\n\n for key, value in self.trekk_mot.items():\n print(key, \"->\", value)\n\n else:\n print(\"ikke i trekkene\")\n if index_start < len(self.kopi_trekk):\n self.kopi_trekk = self.kopi_trekk[index_start + 1:]\n else:\n break\n\n \"\"\"dersom sekvensen aldri har vært utført tidligere\"\"\"\n if all(value == 0 for value in self.trekk_mot.values()):\n return self._random_trekk()\n\n else:\n\n antall = 0\n flest = \"\"\n\n for trekk in self.trekk_mot:\n\n if self.trekk_mot[trekk] >= antall:\n antall = self.trekk_mot[trekk]\n flest = trekk\n\n return flest","def min_temp(self):\n return 1","def nze(self) -> int:","def nze(self) -> int:","def setTi(self, Ti):\r\n\t\tself.Ti = Ti\r\n\t\tself.label = \"standard_PID_Controller/Kp=%f, Ti=%f, Td=%f\" % (self.Kp, self.Ti, self.Td)","def get_traspuesta(self):\n # creo una conectividad vacia\n cotr = Conectividad()\n # calculo los arrays de la conectividad traspuesta\n n1, len_jeT, neT, ieT, jeT = self.calcular_traspuesta()\n cotr.num = n1\n cotr.len_je = len_jeT\n cotr.ne = neT\n cotr.ie = ieT\n cotr.je = jeT\n return cotr","def factor_carga(self):\r\n return self.nelementos() / self.n","def get_delta_t(self):\n return self.gv.t_queue[self.gv.filter_max_bound - 1] \\\n - self.gv.t_queue[self.gv.filter_min_bound]","def max_temp(self):\n return 30","def getTau(self) -> float:\n return self.tau","def retroceder(self):\n\t\tif self.pila_anteriores.esta_vacia(): \n\t\t\traise StopIteration(\"Esta al principio.\")\n\t\tself.actual = self.anterior\n\t\tself.anterior = self.pila_anteriores.desapilar()\n\t\tself.posicion -= 1\n\t\treturn self.actual.dato","def TVOC(self) -> int:\n return self.iaq_measure()[1]","def tsize(self) -> Tuple[int, int]:\n return (self.twidth, self.theight)","def HZm(self,i):\n\t\tv=self.deltai_minus(i)\n\t\treturn v[len(v)-1][0]","def t(self: Q) -> np.array:\n\n return np.array([self.t])","def kurtosis(self):\n self._finalize()\n return self.vkurtosis","def _calc_T(self, name):\n raise NotImplementedError(\"_calc_T function not implemented\")","def back(self):\n try:\n self.tiempos.anterior()\n except StopIteration:\n return","def last_value(self):\n return 0","def __get_emptiest (self, person):\n doubles = []\n for scheduling_unit in person.get_scheduling_units ( ):\n doubles.append ((scheduling_unit, self.__calculate_emptiness (scheduling_unit)))\n \n doubles.sort (key=lambda trio: trio[1])\n \n scheduling_units = []\n for double in doubles:\n scheduling_units.append (double[0])\n \n return scheduling_units","def get_tmid(l):\n return Time(l['date-obs'], format='fits') + l['exptime']/2*u.s","def Tt(s_c, point, system):\n Tx = tra(s_c, point, system)\n Tx.get_time()\n return Tx.time","def temperature(self):\n value = float(self._parent.query('R{}'.format(self._idx))[1:])\n return pq.Quantity(value, pq.Kelvin)","def calc_T_sys(nu_obs):\n return 100 * u.K + 120 * (nu_obs / (150 * u.MHz))**(-2.55) * u.K","def med_t_changed(self):\n\t\tprint \"medianus t changed\"\n\t\tmed_t_cbox = self.ui.findChild(QWidget, \"med_t_cbox\")\t\n\t\tnew_med_t = med_t_cbox.currentText()\n\t\t# todo: calculate new values","def computeTm(self):\n #first step is finding the derivative series of the well\n x = self.temperatures\n if self.fluorescence == None:\n self.Tm = None\n return\n y = self.fluorescence\n \n xdiff = np.diff(x)\n dydx = -np.diff(y)/xdiff\n #the derivative series, has one less index since there is one fewer differences than points\n seriesDeriv = pandas.Series(dydx, x[:-1])\n \n #now that we have the derivative series, we can find the Tm\n lowestPoint = 0\n lowestPointIndex = None\n \n #gets number of signchanges between max and min of the curve, used to determin if the curve\n #is complex or not\n lowestPoint2 = 1\n lowestIndex2 = None\n highestPoint = 0\n highestIndex = None\n previous = None\n for i, value in enumerate(self.fluorescence[:-1]):\n if value > highestPoint:\n highestPoint = value\n highestIndex = i\n if highestIndex == 0 :\n highestPoint = 0\n highestIndex = None\n for i, value in enumerate(self.fluorescence[:-1]):\n if value<lowestPoint2:\n lowestPoint2 = value\n lowestIndex2 = i\n for i, value in enumerate(self.fluorescence[:-1]):\n if i < lowestIndex2:\n continue\n if value > highestPoint:\n highestPoint = value\n highestIndex = i\n else:\n for i, value in enumerate(self.fluorescence[:-1]):\n if i > highestIndex:\n break\n if value<lowestPoint2:\n lowestPoint2 = value\n lowestIndex2 = i\n signChange = False\n for ind in seriesDeriv.index[lowestIndex2+1:highestIndex]:\n \n if previous:\n if seriesDeriv[ind] + SIGN_CHANGE_THRESH < 0 and previous - SIGN_CHANGE_THRESH > 0:\n signChange = True\n if seriesDeriv[ind] - SIGN_CHANGE_THRESH > 0 and previous + SIGN_CHANGE_THRESH < 0:\n signChange = True\n # if seriesDeriv[ind] == 0:\n # signChangeCount += 1\n previous = seriesDeriv[ind]\n\n \n #finding the lowest point and its index on the derivative series\n #only search for Tm up to 90degrees, since last part is hard to predict\n #and often gives false positives\n ignoreNum = int(len(seriesDeriv.index)*0.125)\n for ind in seriesDeriv.index[:-ignoreNum]:\n if seriesDeriv[ind]<lowestPoint:\n lowestPoint = seriesDeriv[ind]\n lowestPointIndex = ind\n \n #TODO working, tms not steep enough added to complex\n #if the slope is not steep enough, tm remains saved, but curve is grouped with the\n #complex curves (now known as the unreliable group)\n #if lowestPoint > -0.000001 / (normalisationFactor / saturation max point of all curves thing):\n # print self.name, 'lowestpoint too small', lowestPoint\n # self.complex = True\n\n #if lowest point is the first index, then no curve fit is required\n if lowestPointIndex == seriesDeriv.index[0]:\n tm = lowestPointIndex\n self.Tm = tm\n \n #set complex to true if curve was complex\n if signChange:\n self.complex = True\n return\n \n #could not find any Tm\n if lowestPointIndex == None:\n self.Tm = None\n \n #if no tm, the curve hopefully be picked up as a monotonic/in the noise/saturated/outlier\n #however, if this does not happen, the curve remains as complex\n self.complex = True\n return \n \n #the indices in the series either side of the lowest index\n #note the first list is indexed e.g. list[i] where i is the section using .index\n leftIndex = [ind for ind in seriesDeriv.index][[ind for ind in seriesDeriv.index].index(lowestPointIndex)-1]\n rightIndex = [ind for ind in seriesDeriv.index][[ind for ind in seriesDeriv.index].index(lowestPointIndex)+1]\n \n \n #matrices used to fit a parabola to the 3 points\n Y=[seriesDeriv[leftIndex],\n seriesDeriv[lowestPointIndex],\n seriesDeriv[rightIndex]]\n \n A=[[leftIndex**2, leftIndex, 1],\n [lowestPointIndex**2, lowestPointIndex, 1],\n [rightIndex**2, rightIndex, 1]]\n \n #solve for b, in the form Y=Ab\n (a,b,c) = np.linalg.solve(A,Y)\n \n #initialise tm to left most point of relevant curve\n tm=seriesDeriv[leftIndex]\n tmValue=0\n #make tm the lowest point on the fitted parabola rounded to nearest 0.01\n for x in np.arange(leftIndex,rightIndex,0.01):\n point = (a*(x**2) + b*x + c)\n if tmValue > point:\n tmValue = point\n tm = x\n self.Tm = tm\n \n #again check for complex shape before returning\n if signChange:\n self.complex = True\n\n\n averagePoint = (lowestPoint2 +highestPoint) / 2\n i = lowestIndex2\n while self.fluorescence[i]<averagePoint:\n i += 1;\n\n # estimates tm by another method and if the difference is too large the curve is considred complex\n if (self.temperatures[i] -self.Tm)**2 > 5**2:\n self.complex=True\n return","def N_TE_TB(self, L):\n if L>2.*min(self.CMB.lMaxT, self.CMB.lMaxP):\n return 0.\n # integrand\n def integrand(x):\n theta = x[1]\n l1 = np.exp(x[0])\n l2 = self.l2(L, l1, theta)\n if l2<self.CMB.lMin or l2>min(self.CMB.lMaxT, self.CMB.lMaxP):\n return 0.\n phi = self.phi(L, l1, theta)\n result = 0. #self.F_TB(l1, l2, phi)*self.CMB.ftotalTT(l1)*self.CMB.ftotalEB(l2)\n result += 0. #self.F_TB(l2, l1, -phi)*self.CMB.ftotalTB(l1)*self.CMB.ftotalTE(l2)\n result *= self.F_TE(l1, l2, phi)\n result *= l1**2\n result /= (2.*np.pi)**2\n result *= 2.\n return result\n \n # if first time, initialize integrator\n if not hasattr(self.N_TE_TB.__func__, \"integ\"):\n self.N_TE_TB.__func__.integ = vegas.Integrator([[np.log(self.CMB.lMin), np.log(min(self.CMB.lMaxT, self.CMB.lMaxP))], [0., np.pi]])\n self.N_TE_TB.integ(integrand, nitn=8, neval=1000)\n result = self.N_TE_TB.integ(integrand, nitn=1, neval=5000)\n return result.mean","def arranca(self):\n \n if self.t0 == None:\n self.t0 = self.timeFunc()\n self.funciona = True\n if not self.funciona:\n self.retraso += self.timeFunc() - self.parada\n self.funciona = True","def set_t_FAST(self):\n\t\n\tself.N = 2**7\n\tdt = self.Orbit.Tobs/self.N\n\tself.t = np.linspace(0, self.N-1, self.N)*self.Orbit.Tobs/self.N\n\t\n\treturn","def calculateTrafoIndex(self):\n if self.S <= TRAFO_LIMIT:\n # trafoIndex = (-1 / 24200) * self.S + 5\n trafoIndex = (-10 / 403333) * self.S + 3\n if (trafoIndex >= 0.0) & (trafoIndex <= 1.0):\n return trafoIndex\n elif trafoIndex > 1:\n return 1.0\n return 0.0","def get_lengte(self):","def get_taum(cm, rm):\n return cm * rm","def _getnt(simulation, t=None):\n nt_sim = simulation.nt()\n \n if t is not None:\n \n dummy = np.zeros(nt_sim)\n nt = len2(dummy[t])\n \n else:\n \n nt = nt_sim\n \n return nt"],"string":"[\n \"def letra_tiempo(self):\\n return self.letra, self.tiempo\",\n \"def get_t(self):\\n return self.t\",\n \"def get_tin(self):\\n return self.tin[:]\",\n \"def Temp(t):\\n return 20 # Need to link to data\",\n \"def _get_max_t(self):\\n \\\"\\\"\\\"\\n if hasattr(self,'k_of_t'):\\n return max([ \\n self.s_of_t[-1][0],\\n self.i_of_t[-1][0],\\n self.r_of_t[-1][0],\\n self.k_of_t[-1][0],\\n ])\\n else:\\n return max([ \\n self.s_of_t[-1][0],\\n self.i_of_t[-1][0],\\n self.r_of_t[-1][0],\\n ])\\n \\\"\\\"\\\"\\n return self.t_max\",\n \"def longitud_traza(self):\\n ret = 0\\n for p in range(len(self.trazado) - 1):\\n ret += self.trazado[p].distancia(self.trazado[p + 1])\\n return ret\",\n \"def calcular_traspuesta(self):\\n # supongo que el nodo de mayor indice en je es el maximo nodo que hay\\n n1 = np.max(self.je) + 1 # el +1 es por la base-0 de python\\n # ahora para cada elem1, recorro los elem0 para ver las conexiones\\n # notar que supondre que los elems0 son range(self.num) y los elems1 son range(n1)\\n jeT = []\\n len_jeT = 0\\n neT = np.zeros(n1, dtype=int)\\n for i1 in range(n1): # aca supongo que los elems1 son range(n1), o sea una lista de indices\\n for i0 in range(self.num): # idem para elems0, son una lista de indices\\n elem0 = self.get_con_elem0(i0)\\n if i1 in elem0:\\n jeT.append(i0)\\n len_jeT += 1\\n neT[i1] += 1\\n # convierto el jeT a numpy\\n jeT = np.array(jeT, dtype=int)\\n # ensamblo el ieT\\n ieT = np.zeros(n1+1, dtype=int)\\n ieT[n1] = len_jeT # empiezo con el indice de un elemento extra que no existe\\n for i1 in range(n1-1, -1, -1):\\n ieT[i1] = ieT[i1+1] - neT[i1] # de ahi calculo el indice donde empieza cada elemento\\n return n1, len_jeT, neT, ieT, jeT\",\n \"def total_te(self):\\r\\n return sum(map(lambda x: self.times[x]['te'], self.times))\",\n \"def t(self):\\n return self._t\",\n \"def t(self):\\n return self._t\",\n \"def _get_tb(I, nu, beam):\\n from astropy import units as u\\n return (1222.0*I/(nu**2*(beam.minor/1.0).to(u.arcsecond)*(beam.major/1.0).to(u.arcsecond))).value\",\n \"def ti_func(self):\\n return self.ti.val - self.calc_ti()\",\n \"def t0(self):\\n return self._t0\",\n \"def elemento_actual(self):\\n\\t\\tif not self.actual:\\n\\t\\t\\treturn None\\n\\t\\treturn self.actual.dato\",\n \"def oldest_txo(self) -> int:\",\n \"def tempo(self):\\n text = self._get_menu_item_text('Edit->Tempo')\\n return float(re.search(r'\\\\[([0-9.,]+)\\\\]$', text).group(1))\",\n \"def tt(self):\\n return self.MJD + self.tt_ut1 + 2400000.5\",\n \"def getTempo():\\r\\n global dauer\\r\\n \\r\\n dauer = 0.0\\r\\n counter = 1\\r\\n\\r\\n for x in midi_data.get_tempo_changes(): #pretty_midi saves the tempo of a midi-file in nested-arrays, therefore a few for-loops and if statements are necessary\\r\\n for e in x:\\r\\n if e > 0:\\r\\n if counter > 0:\\r\\n tempi.append(round(e))\\r\\n counter = 0\\r\\n break\\r\\n \\r\\n dauer = 60000/(e/4)\",\n \"def f_columnas_tiempos(param_data):\\n\\n # convertir columna de 'closetime' y 'opentime' utilizando pd.to_datetime\\n param_data['closetime'] = pd.to_datetime(param_data['closetime'])\\n param_data['opentime'] = pd.to_datetime(param_data['opentime'])\\n\\n # tiempo transcurrido de una operacion\\n param_data['tiempo'] = [(param_data.loc[i, 'closetime'] - param_data.loc[i, 'opentime']).delta / 1e9\\n for i in param_data.index]\\n\\n return param_data\",\n \"def get_tim(self):\\n return self.sum(axis=0)\",\n \"def T_i(self) -> u.K:\\n return self._T_i\",\n \"def T_i(self) -> u.K:\\n return self._T_i\",\n \"def get_t_value(self):\\n return float(self.data[2]) / 10\",\n \"def T(self):\\n return self.__T\",\n \"def reemplaza_tildes(palabra):\",\n \"def __call__(self):\\n \\n if self.funciona:\\n t = self.timeFunc() - self.t0 - self.retraso\\n elif self.t0!=None:\\n t = self.parada - self.t0 - self.retraso\\n else:\\n t = None\\n return t\",\n \"def tic(self):\\n return self._timestamp\",\n \"def tetrakis(self):\\n return self.nlegomena(4)\",\n \"def tau_ruptura_prem( largo_falla, prof_media, prof_prem, vs_prem ):\\n\\n dif_profs = np.abs( prof_prem - prof_media )\\n idx_prof_media = np.where( dif_profs == dif_profs.min() )\\n vs_prof_media = vs_prem[idx_prof_media]\\n\\n # puede que la profundidad media de la falla se encuentre justo entre 2 valores del modelo\\n # si esto sucede, se calcula el promedio de las velocidades de ambos\\n if len(vs_prof_media) > 1:\\n vs_prof_media = vs_prof_media.mean()\\n else:\\n vs_prof_media = vs_prof_media\\n\\n tau = largo_falla/( 0.8 * vs_prof_media )\\n\\n return tau\",\n \"def _get_max_t(self):\\n\\n return max([\\n self.s_of_t[-1][0],\\n self.i_of_t[-1][0],\\n self.r_of_t[-1][0],\\n ])\",\n \"def table(self):\\n return self.t\",\n \"def T(self, point = -1):\\n return self.solution('T', point)\",\n \"def _Mn_Tubo(perfil, data=False):\\n\\n Mrd_dados = namedtuple(\\\"Mrd_dados\\\", \\\"Mn elp elr\\\")\\n\\n elp = 0.07 * perfil.mat.E / perfil.mat.fy\\n elr = 0.31 * perfil.mat.E / perfil.mat.fy\\n\\n if perfil.esb <= elp:\\n Mn = perfil.Mplx\\n return Mn if not data else (Mn, Mrd_dados(Mn, elp, elr))\\n\\n elif elp < perfil.esb <= elr:\\n Mn = 0.021 * (perfil.mat.E / perfil.esb + perfil.mat.fy) * perfil.W\\n return Mn if not data else (Mn, Mrd_dados(Mn, elp, elr))\\n else:\\n Fcr = 0.33 * perfil.mat.E / perfil.esb\\n Mn = Fcr * perfil.W\\n return Mn if not data else (Mn, Mrd_dados(Mn, elp, elr))\",\n \"def MINET(self):\",\n \"def total_tr(self):\\r\\n return sum(map(lambda x: self.times[x]['tr'], self.times))\",\n \"def ticket_salida(self):\\n total = 0.0\\n for x in self.mi_parqueo:\\n total=x.cobro=total\\n\\n print(\\\"El costo total es de :\\\",total)\",\n \"def tauPoint(numDeps, tauRos, tau):\\r\\n\\r\\n #int index;\\r\\n\\r\\n help = [0.0 for i in range(numDeps)]\\r\\n\\r\\n for i in range(0, numDeps):\\r\\n\\r\\n help[i] = tauRos[0][i] - tau\\r\\n help[i] = abs(help[i])\\r\\n\\r\\n \\r\\n index = 0\\r\\n min = help[index]\\r\\n\\r\\n for i in range(1, numDeps):\\r\\n\\r\\n if (help[i] < min): \\r\\n min = help[i]\\r\\n index = i\\r\\n \\r\\n\\r\\n return index\",\n \"def mostrar_ultimo(self):\\n participantes = self.__puntuacion_total()\\n podio = self.__armar_podio(participantes)\\n print(\\n f\\\"\\\"\\\"\\n ===================================\\n ========== ULTIMO PUESTO ==========\\n ===================================\\n id disparo: {podio[0]['idDisparo']},\\n Disparos: {podio[0]['disparos']},\\n Numero participante: {podio[0]['nroParticipante']},\\n Nombre: {podio[0]['nombre']},\\n Apellido: {podio[0]['apellido']},\\n Edad: {podio[0]['edad']},\\n sexo: {podio[0]['sexo']},\\n Puntaje: {podio[0]['puntaje_total']}\\n ===================================\\n ===================================\\n \\\"\\\"\\\"\\n )\",\n \"def max_temp(self):\\n return 99\",\n \"def prueba_temple_simulado(problema=ProblemaNreinas(8),calendarizacion=None):\\n start = time.time()\\n solucion = blocales.temple_simulado(problema,calendarizacion)\\n #print(\\\"\\\\n\\\\nTemple simulado con calendarización To/(1 + i).\\\")\\n print(\\\"Costo de la solución: \\\", problema.costo(solucion))\\n print(\\\"Y la solución es: \\\")\\n print(solucion)\\n end = time.time()\\n print(\\\"Tiempo que tarda: Segundos..: \\\" + str(end - start))\",\n \"def calc_ti(self):\\n m = 0\\n for i in self.inl:\\n m += i.m.val_SI * i.fluid.val[self.fuel_alias.val]\\n\\n for o in self.outl:\\n m -= o.m.val_SI * o.fluid.val[self.fuel_alias.val]\\n\\n return m * self.lhv\",\n \"def get_tema(data):\\n if data is None:\\n raise EmptyDataError('[!] Invalid data value')\\n\\n result = TA.TEMA(data)\\n if result is None:\\n raise IndicatorException\\n return result\",\n \"def getWeightTime(self, index):\\r\\n\\t\\treturn None\",\n \"def getTime(self) -> float:\\n return self.t\",\n \"def item_t(data_alt, item, min_t):\\n for t in data_alt[item]:\\n if t >= min_t:\\n return t\\n return None\",\n \"def time_list(self):\\n return (self.N_T * (np.arange(self.N_itr) + 1) /\\n self.N_itr * 1000 * self.DT)\",\n \"def get_t_vec(self):\\n t_vec = np.arange(0, self.get_T(), self.get_dt())\\n\\n # Shape checks.\\n if 'ser' in self.keys() and 'spktrains' in self['ser'].keys():\\n assert self.ser_spktrains.shape[2] == len(\\n t_vec\\n ), 'Bad t_vec length ({})'.format(len(t_vec))\\n if 'gaba' in self.keys() and 'spktrains' in self['gaba'].keys():\\n assert self.gaba_spktrains.shape[2] == len(\\n t_vec\\n ), 'Bad t_vec length ({})'.format(len(t_vec))\\n\\n return t_vec\",\n \"def _self_time(self):\\r\\n return self.duration() - sum([child.duration() for child in self.children])\",\n \"def __call__(self, t):\\n \\n c = c1 = c2 = 0\\n d = d1 = d2 = None\\n while d1==None or d2==None or d<=d2:\\n _t = self.time(c)\\n if _t == None:\\n break\\n else:\\n d = abs(t - _t)\\n if d1 == None or d<d1:\\n c1, d1 = c, d\\n elif d2 == None or d<d2:\\n c2, d2 = c, d\\n c += 1\\n t1, t2 = map(self.time, [c1, c2])\\n v1, v2 = map(self.__getitem__, [c1, c2])\\n # a lo mejor la lista solo contiene un elemento\\n if t1 == t2:\\n return v1\\n else:\\n # si contiene por lo menos dos, pues interpolacion lineal\\n return (v2*(t - t1) - v1*(t - t2))/(t2 - t1)\",\n \"def compute_iactT(data):\\n\\t# get only the timestamps\\n\\ttime = data[0]\\n\\tprevT = time[0]\\n\\n\\ttotalT = len(time)*0.1\\n\\n\\treturn totalT\",\n \"def timenow(self):\\n return (datetime.now().strftime(\\\"%H:%M:%S\\\"))\",\n \"def tam_relativo(self, code):\\n return len(self.compartimentos[code]) / float(self.n)\",\n \"def precio_descuento(self):\\n descount_price = self.html.xpath(self.xpath_descount_price)\\n precio_descuento = map(self.limpieza_precio, descount_price)\\n return precio_descuento\",\n \"def heeftTemperatuurmeting(self):\\n return self._heeftTemperatuurmeting.get_waarde()\",\n \"def contamination_heterozygote(self, mere):\\n hauteur_allele_contaminant = 99999999999999999.0\\n hauteur_allele_different = None\\n taux_contamination = 0\\n for allele in range(3):\\n if self.hauteur[allele] < hauteur_allele_contaminant:\\n hauteur_allele_contaminant = self.hauteur[allele]\\n for alleles in range(3):\\n if self.allele[alleles] not in mere.allele:\\n hauteur_allele_different = self.hauteur[alleles]\\n taux_contamination = ((hauteur_allele_contaminant) / (\\n hauteur_allele_different + hauteur_allele_contaminant)) * 100\\n self.taux = round(taux_contamination, 2)\",\n \"def valorEsperado(obs,ket):\\n cal=Calculadora()\\n obsSobreket=cal.accion(obs,ket)\\n bra=cal.matrizConjugada(obsSobreket)\\n ket1=cal.transpuesta([ket])\\n bra1=cal.transpuesta(bra)\\n car=cal.multiplicacionMatrizMatriz(bra1,ket1)[0][0]\\n return car\",\n \"def getETA():\",\n \"def getETA():\",\n \"def suffixe(self, autre):\\n if autre.tete is None: # liste vide\\n return\\n\\n partage = False # boolean qui indique si la liste partage au moins une cellule ou pas\\n for cel in self.cellules():\\n if cel.utilisation > 1: # dès qu'on trouve une cellule partagée\\n partage = True\\n break\\n\\n if partage: # si la liste partage des cellules\\n vu_premiere = True\\n doublage = False\\n premiere = True\\n prec = self.tete\\n for cel in self.cellules():\\n if vu_premiere and cel.utilisation > 1: # dès qu'on trouve une cel partagée (1 fois)\\n vu_premiere = False\\n doublage = True\\n cel.utilisation -= 1\\n if doublage: # si on commence à doubler la partie partagée\\n cel_double = Cellule(cel.valeur)\\n if premiere: # cas initial (1 fois)\\n premiere = False\\n if cel == self.tete: # si c'est la première cellule qu'on supprime\\n self.tete = cel_double\\n else: # cas général\\n prec.suivant = cel_double\\n else: # cas itératif\\n prec.suivant = cel_double\\n prec = cel_double\\n else:\\n prec = cel\\n prec.suivant = autre.tete\\n autre.tete.utilisation += 1\\n\\n else: # sinon, si la liste ne partage aucune cellule\\n if partage is False:\\n for cel in self.cellules():\\n if cel.suivant is None:\\n cel.suivant = autre.tete\\n autre.tete.utilisation += 1\\n\\n self.taille += autre.taille\",\n \"def homozygote_contamine(self, echantillon):\\n seuil = echantillon.get_seuil_hauteur()\\n if self.hauteur[1] < self.hauteur[0] * seuil:\\n allele_contaminant = 1\\n taux = ((2 * self.hauteur[allele_contaminant]) / (self.hauteur[allele_contaminant] + self.hauteur[0])) * 100\\n else:\\n allele_contaminant = 0\\n taux = ((2 * self.hauteur[allele_contaminant]) / (self.hauteur[allele_contaminant] + self.hauteur[1])) * 100\\n self.taux = round(taux, 2)\",\n \"def teid(self):\\n return self._teid\",\n \"def t0(self):\\n return self._time_axis.start\",\n \"def get_tetromino(self):\\n tetromino = random.randint(1, 8)\\n if tetromino == self.previous_tetromino or tetromino == 8:\\n tetromino = random.randint(1, 7)\\n self.previous_tetromino = tetromino\\n return Tetromino(tetromino, 5, 2, 0, TETROMINOES[tetromino - 1])\",\n \"def tabelaOrareve():\\n \\n linja = 1\\n kpm = \\\"3\\\"\\n\\n #print(f\\\"linja {oraret['linja1']} mberrin ne {kpm} minuta\\\")\\n print(f\\\"Oraret per linjen 1 :\\\\n {oraret['linja1']}\\\\n, {oraret['linja2']}\\\\n, {oraret['linja3']}\\\\n\\\")\",\n \"def calculer_energie_cinetique_tnt(energie_cinetique):\\n return energie_cinetique / 4184\",\n \"def tt_ut1(self):\\n # return the delta time for the input date converted to days\\n return interpolate_delta_time(_delta_file, self.tide)\",\n \"def ottieni_ultimi(astaid, Oggetto, numero=0):\\n queryS = Oggetto.objects.filter(asta__id=astaid).order_by('-id')\\n if(int(numero)==0):\\n ultimi = queryS.all()\\n else:\\n ultimi = queryS[:numero]\\n return ultimi\",\n \"def valg(self):\\n\\n lengde_mtrekk = len(self.motstander_trekk)\\n\\n if (lengde_mtrekk == 0) or (self.husk ==\\n 0):\\n return self._random_trekk()\\n\\n elif lengde_mtrekk <= self.husk:\\n\\n \\\"\\\"\\\"sekvens skal inneholde like mange elementer som husk\\\"\\\"\\\"\\n if len(self.sekvens) < self.husk:\\n self.sekvens.append(self.motstander_trekk[-1])\\n\\n return self._random_trekk()\\n\\n else:\\n self.sekvens = self.motstander_trekk[-self.husk:]\\n\\n print(self.motstander_trekk)\\n print(self.sekvens)\\n\\n self.kopi_trekk = self.motstander_trekk.copy()\\n\\n \\\"\\\"\\\"trekkene uten siste sekvens\\\"\\\"\\\"\\n self.kopi_trekk = self.kopi_trekk[:len(\\n self.kopi_trekk) - self.husk]\\n print(self.kopi_trekk)\\n\\n \\\"\\\"\\\"rangerer trekkene som oftest SLÅR det motstanderen spiller etter sekvensen\\\"\\\"\\\"\\n self.trekk_mot = {\\\"stein\\\": 0, \\\"saks\\\": 0, \\\"papir\\\": 0}\\n\\n \\\"\\\"\\\"sjekker så lenge starten på sekvensen er med i motstanderens trekk fjerner\\\"\\\"\\\"\\n while (self.sekvens[0] in self.kopi_trekk) and (\\n len(self.kopi_trekk) > self.husk):\\n\\n index_start = self.kopi_trekk.index(self.sekvens[0])\\n\\n if self.sekvens == self.kopi_trekk[index_start: (\\n index_start + len(self.sekvens))]:\\n print(\\\"den er med!\\\")\\n print(index_start)\\n index_slutt = index_start + len(self.sekvens)\\n\\n \\\"\\\"\\\"hvis index_slutt er utenfor kopi_trekk, så skal while løkken stoppes\\\"\\\"\\\"\\n if index_slutt >= len(self.kopi_trekk):\\n break\\n\\n print(index_slutt)\\n \\\"\\\"\\\"ser på neste trekk etter sekvensen\\\"\\\"\\\"\\n forventet_trekk = self.kopi_trekk[index_slutt]\\n \\\"\\\"\\\"setter slutten som den nye starten\\\"\\\"\\\"\\n self.kopi_trekk = self.kopi_trekk[index_slutt:]\\n print(self.kopi_trekk)\\n\\n temp = Sammenlikning(forventet_trekk)\\n print(\\\"1\\\" + forventet_trekk)\\n vinner_trekk = temp.taper_mot\\n print(\\\"2\\\" + vinner_trekk)\\n\\n self.trekk_mot[vinner_trekk] += 1\\n\\n for key, value in self.trekk_mot.items():\\n print(key, \\\"->\\\", value)\\n\\n else:\\n print(\\\"ikke i trekkene\\\")\\n if index_start < len(self.kopi_trekk):\\n self.kopi_trekk = self.kopi_trekk[index_start + 1:]\\n else:\\n break\\n\\n \\\"\\\"\\\"dersom sekvensen aldri har vært utført tidligere\\\"\\\"\\\"\\n if all(value == 0 for value in self.trekk_mot.values()):\\n return self._random_trekk()\\n\\n else:\\n\\n antall = 0\\n flest = \\\"\\\"\\n\\n for trekk in self.trekk_mot:\\n\\n if self.trekk_mot[trekk] >= antall:\\n antall = self.trekk_mot[trekk]\\n flest = trekk\\n\\n return flest\",\n \"def min_temp(self):\\n return 1\",\n \"def nze(self) -> int:\",\n \"def nze(self) -> int:\",\n \"def setTi(self, Ti):\\r\\n\\t\\tself.Ti = Ti\\r\\n\\t\\tself.label = \\\"standard_PID_Controller/Kp=%f, Ti=%f, Td=%f\\\" % (self.Kp, self.Ti, self.Td)\",\n \"def get_traspuesta(self):\\n # creo una conectividad vacia\\n cotr = Conectividad()\\n # calculo los arrays de la conectividad traspuesta\\n n1, len_jeT, neT, ieT, jeT = self.calcular_traspuesta()\\n cotr.num = n1\\n cotr.len_je = len_jeT\\n cotr.ne = neT\\n cotr.ie = ieT\\n cotr.je = jeT\\n return cotr\",\n \"def factor_carga(self):\\r\\n return self.nelementos() / self.n\",\n \"def get_delta_t(self):\\n return self.gv.t_queue[self.gv.filter_max_bound - 1] \\\\\\n - self.gv.t_queue[self.gv.filter_min_bound]\",\n \"def max_temp(self):\\n return 30\",\n \"def getTau(self) -> float:\\n return self.tau\",\n \"def retroceder(self):\\n\\t\\tif self.pila_anteriores.esta_vacia(): \\n\\t\\t\\traise StopIteration(\\\"Esta al principio.\\\")\\n\\t\\tself.actual = self.anterior\\n\\t\\tself.anterior = self.pila_anteriores.desapilar()\\n\\t\\tself.posicion -= 1\\n\\t\\treturn self.actual.dato\",\n \"def TVOC(self) -> int:\\n return self.iaq_measure()[1]\",\n \"def tsize(self) -> Tuple[int, int]:\\n return (self.twidth, self.theight)\",\n \"def HZm(self,i):\\n\\t\\tv=self.deltai_minus(i)\\n\\t\\treturn v[len(v)-1][0]\",\n \"def t(self: Q) -> np.array:\\n\\n return np.array([self.t])\",\n \"def kurtosis(self):\\n self._finalize()\\n return self.vkurtosis\",\n \"def _calc_T(self, name):\\n raise NotImplementedError(\\\"_calc_T function not implemented\\\")\",\n \"def back(self):\\n try:\\n self.tiempos.anterior()\\n except StopIteration:\\n return\",\n \"def last_value(self):\\n return 0\",\n \"def __get_emptiest (self, person):\\n doubles = []\\n for scheduling_unit in person.get_scheduling_units ( ):\\n doubles.append ((scheduling_unit, self.__calculate_emptiness (scheduling_unit)))\\n \\n doubles.sort (key=lambda trio: trio[1])\\n \\n scheduling_units = []\\n for double in doubles:\\n scheduling_units.append (double[0])\\n \\n return scheduling_units\",\n \"def get_tmid(l):\\n return Time(l['date-obs'], format='fits') + l['exptime']/2*u.s\",\n \"def Tt(s_c, point, system):\\n Tx = tra(s_c, point, system)\\n Tx.get_time()\\n return Tx.time\",\n \"def temperature(self):\\n value = float(self._parent.query('R{}'.format(self._idx))[1:])\\n return pq.Quantity(value, pq.Kelvin)\",\n \"def calc_T_sys(nu_obs):\\n return 100 * u.K + 120 * (nu_obs / (150 * u.MHz))**(-2.55) * u.K\",\n \"def med_t_changed(self):\\n\\t\\tprint \\\"medianus t changed\\\"\\n\\t\\tmed_t_cbox = self.ui.findChild(QWidget, \\\"med_t_cbox\\\")\\t\\n\\t\\tnew_med_t = med_t_cbox.currentText()\\n\\t\\t# todo: calculate new values\",\n \"def computeTm(self):\\n #first step is finding the derivative series of the well\\n x = self.temperatures\\n if self.fluorescence == None:\\n self.Tm = None\\n return\\n y = self.fluorescence\\n \\n xdiff = np.diff(x)\\n dydx = -np.diff(y)/xdiff\\n #the derivative series, has one less index since there is one fewer differences than points\\n seriesDeriv = pandas.Series(dydx, x[:-1])\\n \\n #now that we have the derivative series, we can find the Tm\\n lowestPoint = 0\\n lowestPointIndex = None\\n \\n #gets number of signchanges between max and min of the curve, used to determin if the curve\\n #is complex or not\\n lowestPoint2 = 1\\n lowestIndex2 = None\\n highestPoint = 0\\n highestIndex = None\\n previous = None\\n for i, value in enumerate(self.fluorescence[:-1]):\\n if value > highestPoint:\\n highestPoint = value\\n highestIndex = i\\n if highestIndex == 0 :\\n highestPoint = 0\\n highestIndex = None\\n for i, value in enumerate(self.fluorescence[:-1]):\\n if value<lowestPoint2:\\n lowestPoint2 = value\\n lowestIndex2 = i\\n for i, value in enumerate(self.fluorescence[:-1]):\\n if i < lowestIndex2:\\n continue\\n if value > highestPoint:\\n highestPoint = value\\n highestIndex = i\\n else:\\n for i, value in enumerate(self.fluorescence[:-1]):\\n if i > highestIndex:\\n break\\n if value<lowestPoint2:\\n lowestPoint2 = value\\n lowestIndex2 = i\\n signChange = False\\n for ind in seriesDeriv.index[lowestIndex2+1:highestIndex]:\\n \\n if previous:\\n if seriesDeriv[ind] + SIGN_CHANGE_THRESH < 0 and previous - SIGN_CHANGE_THRESH > 0:\\n signChange = True\\n if seriesDeriv[ind] - SIGN_CHANGE_THRESH > 0 and previous + SIGN_CHANGE_THRESH < 0:\\n signChange = True\\n # if seriesDeriv[ind] == 0:\\n # signChangeCount += 1\\n previous = seriesDeriv[ind]\\n\\n \\n #finding the lowest point and its index on the derivative series\\n #only search for Tm up to 90degrees, since last part is hard to predict\\n #and often gives false positives\\n ignoreNum = int(len(seriesDeriv.index)*0.125)\\n for ind in seriesDeriv.index[:-ignoreNum]:\\n if seriesDeriv[ind]<lowestPoint:\\n lowestPoint = seriesDeriv[ind]\\n lowestPointIndex = ind\\n \\n #TODO working, tms not steep enough added to complex\\n #if the slope is not steep enough, tm remains saved, but curve is grouped with the\\n #complex curves (now known as the unreliable group)\\n #if lowestPoint > -0.000001 / (normalisationFactor / saturation max point of all curves thing):\\n # print self.name, 'lowestpoint too small', lowestPoint\\n # self.complex = True\\n\\n #if lowest point is the first index, then no curve fit is required\\n if lowestPointIndex == seriesDeriv.index[0]:\\n tm = lowestPointIndex\\n self.Tm = tm\\n \\n #set complex to true if curve was complex\\n if signChange:\\n self.complex = True\\n return\\n \\n #could not find any Tm\\n if lowestPointIndex == None:\\n self.Tm = None\\n \\n #if no tm, the curve hopefully be picked up as a monotonic/in the noise/saturated/outlier\\n #however, if this does not happen, the curve remains as complex\\n self.complex = True\\n return \\n \\n #the indices in the series either side of the lowest index\\n #note the first list is indexed e.g. list[i] where i is the section using .index\\n leftIndex = [ind for ind in seriesDeriv.index][[ind for ind in seriesDeriv.index].index(lowestPointIndex)-1]\\n rightIndex = [ind for ind in seriesDeriv.index][[ind for ind in seriesDeriv.index].index(lowestPointIndex)+1]\\n \\n \\n #matrices used to fit a parabola to the 3 points\\n Y=[seriesDeriv[leftIndex],\\n seriesDeriv[lowestPointIndex],\\n seriesDeriv[rightIndex]]\\n \\n A=[[leftIndex**2, leftIndex, 1],\\n [lowestPointIndex**2, lowestPointIndex, 1],\\n [rightIndex**2, rightIndex, 1]]\\n \\n #solve for b, in the form Y=Ab\\n (a,b,c) = np.linalg.solve(A,Y)\\n \\n #initialise tm to left most point of relevant curve\\n tm=seriesDeriv[leftIndex]\\n tmValue=0\\n #make tm the lowest point on the fitted parabola rounded to nearest 0.01\\n for x in np.arange(leftIndex,rightIndex,0.01):\\n point = (a*(x**2) + b*x + c)\\n if tmValue > point:\\n tmValue = point\\n tm = x\\n self.Tm = tm\\n \\n #again check for complex shape before returning\\n if signChange:\\n self.complex = True\\n\\n\\n averagePoint = (lowestPoint2 +highestPoint) / 2\\n i = lowestIndex2\\n while self.fluorescence[i]<averagePoint:\\n i += 1;\\n\\n # estimates tm by another method and if the difference is too large the curve is considred complex\\n if (self.temperatures[i] -self.Tm)**2 > 5**2:\\n self.complex=True\\n return\",\n \"def N_TE_TB(self, L):\\n if L>2.*min(self.CMB.lMaxT, self.CMB.lMaxP):\\n return 0.\\n # integrand\\n def integrand(x):\\n theta = x[1]\\n l1 = np.exp(x[0])\\n l2 = self.l2(L, l1, theta)\\n if l2<self.CMB.lMin or l2>min(self.CMB.lMaxT, self.CMB.lMaxP):\\n return 0.\\n phi = self.phi(L, l1, theta)\\n result = 0. #self.F_TB(l1, l2, phi)*self.CMB.ftotalTT(l1)*self.CMB.ftotalEB(l2)\\n result += 0. #self.F_TB(l2, l1, -phi)*self.CMB.ftotalTB(l1)*self.CMB.ftotalTE(l2)\\n result *= self.F_TE(l1, l2, phi)\\n result *= l1**2\\n result /= (2.*np.pi)**2\\n result *= 2.\\n return result\\n \\n # if first time, initialize integrator\\n if not hasattr(self.N_TE_TB.__func__, \\\"integ\\\"):\\n self.N_TE_TB.__func__.integ = vegas.Integrator([[np.log(self.CMB.lMin), np.log(min(self.CMB.lMaxT, self.CMB.lMaxP))], [0., np.pi]])\\n self.N_TE_TB.integ(integrand, nitn=8, neval=1000)\\n result = self.N_TE_TB.integ(integrand, nitn=1, neval=5000)\\n return result.mean\",\n \"def arranca(self):\\n \\n if self.t0 == None:\\n self.t0 = self.timeFunc()\\n self.funciona = True\\n if not self.funciona:\\n self.retraso += self.timeFunc() - self.parada\\n self.funciona = True\",\n \"def set_t_FAST(self):\\n\\t\\n\\tself.N = 2**7\\n\\tdt = self.Orbit.Tobs/self.N\\n\\tself.t = np.linspace(0, self.N-1, self.N)*self.Orbit.Tobs/self.N\\n\\t\\n\\treturn\",\n \"def calculateTrafoIndex(self):\\n if self.S <= TRAFO_LIMIT:\\n # trafoIndex = (-1 / 24200) * self.S + 5\\n trafoIndex = (-10 / 403333) * self.S + 3\\n if (trafoIndex >= 0.0) & (trafoIndex <= 1.0):\\n return trafoIndex\\n elif trafoIndex > 1:\\n return 1.0\\n return 0.0\",\n \"def get_lengte(self):\",\n \"def get_taum(cm, rm):\\n return cm * rm\",\n \"def _getnt(simulation, t=None):\\n nt_sim = simulation.nt()\\n \\n if t is not None:\\n \\n dummy = np.zeros(nt_sim)\\n nt = len2(dummy[t])\\n \\n else:\\n \\n nt = nt_sim\\n \\n return nt\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.619667","0.59608144","0.59497315","0.5923782","0.5808081","0.5783681","0.5765352","0.5689239","0.56744725","0.56744725","0.5661414","0.56252795","0.5588799","0.55462325","0.5516231","0.5511294","0.5499417","0.54709876","0.5412701","0.54074687","0.5373432","0.5373432","0.53056395","0.52857745","0.5281801","0.5273254","0.5270955","0.5266417","0.52522475","0.5225769","0.52160275","0.5207861","0.5197738","0.5181734","0.5179798","0.5177224","0.51670134","0.5131101","0.5128557","0.5124162","0.5119296","0.5111844","0.5111681","0.5110001","0.5107723","0.5093539","0.50750947","0.50750196","0.5067217","0.5061255","0.50597656","0.50505817","0.5044527","0.50315666","0.50278836","0.50223154","0.50222707","0.50222707","0.50210017","0.50148076","0.50142205","0.50135744","0.50121915","0.50110584","0.5006771","0.5002666","0.5000928","0.49987838","0.49961722","0.49926123","0.49926123","0.49915418","0.49902993","0.49896875","0.4989581","0.49813527","0.49808165","0.49804503","0.4972668","0.49717754","0.4967169","0.4967084","0.49666646","0.49657315","0.49650007","0.4959637","0.49588057","0.49465445","0.4944431","0.49407476","0.49378586","0.49322197","0.49275318","0.49269253","0.49254647","0.49248937","0.49234518","0.4921647","0.49200186","0.49191377"],"string":"[\n \"0.619667\",\n \"0.59608144\",\n \"0.59497315\",\n \"0.5923782\",\n \"0.5808081\",\n \"0.5783681\",\n \"0.5765352\",\n \"0.5689239\",\n \"0.56744725\",\n \"0.56744725\",\n \"0.5661414\",\n \"0.56252795\",\n \"0.5588799\",\n \"0.55462325\",\n \"0.5516231\",\n \"0.5511294\",\n \"0.5499417\",\n \"0.54709876\",\n \"0.5412701\",\n \"0.54074687\",\n \"0.5373432\",\n \"0.5373432\",\n \"0.53056395\",\n \"0.52857745\",\n \"0.5281801\",\n \"0.5273254\",\n \"0.5270955\",\n \"0.5266417\",\n \"0.52522475\",\n \"0.5225769\",\n \"0.52160275\",\n \"0.5207861\",\n \"0.5197738\",\n \"0.5181734\",\n \"0.5179798\",\n \"0.5177224\",\n \"0.51670134\",\n \"0.5131101\",\n \"0.5128557\",\n \"0.5124162\",\n \"0.5119296\",\n \"0.5111844\",\n \"0.5111681\",\n \"0.5110001\",\n \"0.5107723\",\n \"0.5093539\",\n \"0.50750947\",\n \"0.50750196\",\n \"0.5067217\",\n \"0.5061255\",\n \"0.50597656\",\n \"0.50505817\",\n \"0.5044527\",\n \"0.50315666\",\n \"0.50278836\",\n \"0.50223154\",\n \"0.50222707\",\n \"0.50222707\",\n \"0.50210017\",\n \"0.50148076\",\n \"0.50142205\",\n \"0.50135744\",\n \"0.50121915\",\n \"0.50110584\",\n \"0.5006771\",\n \"0.5002666\",\n \"0.5000928\",\n \"0.49987838\",\n \"0.49961722\",\n \"0.49926123\",\n \"0.49926123\",\n \"0.49915418\",\n \"0.49902993\",\n \"0.49896875\",\n \"0.4989581\",\n \"0.49813527\",\n \"0.49808165\",\n \"0.49804503\",\n \"0.4972668\",\n \"0.49717754\",\n \"0.4967169\",\n \"0.4967084\",\n \"0.49666646\",\n \"0.49657315\",\n \"0.49650007\",\n \"0.4959637\",\n \"0.49588057\",\n \"0.49465445\",\n \"0.4944431\",\n \"0.49407476\",\n \"0.49378586\",\n \"0.49322197\",\n \"0.49275318\",\n \"0.49269253\",\n \"0.49254647\",\n \"0.49248937\",\n \"0.49234518\",\n \"0.4921647\",\n \"0.49200186\",\n \"0.49191377\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.4978765"},"document_rank":{"kind":"string","value":"78"}}},{"rowIdx":79082,"cells":{"query":{"kind":"string","value":"Devuelve un iterador por la lista de tiempos."},"document":{"kind":"string","value":"def times(self):\n \n class IterTimes:\n def __init__(self, st):\n self.c = 0\n self.st = st\n \n def __iter__(self):\n return self\n \n def next(self):\n t = self.st.time(self.c)\n if t == None or self.c == self.st.longitud:\n raise StopIteration\n else:\n self.c += 1\n return t\n \n return IterTimes(self)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __iter__(self):\n start_times = (start for start, end in self.tss)\n names = (name.rstrip() for name in self.inps)\n for ind, (c, t) in enumerate(zip(names, start_times)):\n yield (c, t, ind)","def build_tiers(self):\n self.tiers = []\n for size in range(1,len(self.sigma)+1):\n for combo in itertools.combinations(self.sigma, size):\n self.tiers.append(tuple(sorted(list(combo))))","def __iter__(self) -> Iterator[int]:\n return iter(self._tasks)","def time_list(self):\n return (self.N_T * (np.arange(self.N_itr) + 1) /\n self.N_itr * 1000 * self.DT)","def iter_mempool_tips_from_tx_tips(self) -> Iterator[Transaction]:\n assert self.indexes is not None\n tx_tips = self.indexes.tx_tips\n\n for interval in tx_tips[self.latest_timestamp + 1]:\n tx = self.get_transaction(interval.data)\n tx_meta = tx.get_metadata()\n assert isinstance(tx, Transaction) # XXX: tx_tips only has transactions\n # XXX: skip txs that have already been confirmed\n if tx_meta.first_block:\n continue\n yield tx","def _generate_instances(self, single_traj):\n return [single_traj[:2].values]","def generos_existentes(catalog, generos):\n lista_repetidos_total = lt.newList('ARRAY_LIST')\n list_generos = generos.split(\",\")\n for genero in list_generos:\n artistasNoRepetidos = lt.newList('ARRAY_LIST')\n artistasRepetidos = lt.newList('ARRAY_LIST')\n MapGeneros = mp.get(catalog['musicaGenero'], genero)\n RBTgenero = me.getValue(MapGeneros)\n valor_min = om.minKey(RBTgenero)\n valor_max = om.maxKey(RBTgenero)\n lista_listas_musica = om.values(RBTgenero, valor_min, valor_max)\n lista_lista_musica = it.newIterator(lista_listas_musica)\n while it.hasNext(lista_lista_musica): \n lista_musica = it.next(lista_lista_musica)\n musicas = it.newIterator(lista_musica)\n while it.hasNext(musicas):\n musica = it.next(musicas)\n if int(lt.isPresent(artistasNoRepetidos, musica['artist_id'])) == 0:\n lt.addLast(artistasNoRepetidos, musica['artist_id'])\n if int(lt.isPresent(artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id']))) == 0:\n lt.addLast(artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id']))\n #if int(lt.isPresent(lista_repetidos_total, (musica['created_at'] + musica['user_id'] + musica['track_id']))) == 0:\n # lt.addLast(lista_repetidos_total, (musica['created_at'] + musica['user_id'] + musica['track_id']))\n else:\n if int(lt.isPresent(artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id']))) == 0:\n lt.addLast(artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id']))\n #if int(lt.isPresent(lista_repetidos_total, (musica['created_at'] + musica['user_id'] + musica['track_id']))) == 0:\n # lt.addLast(lista_repetidos_total, (musica['created_at'] + musica['user_id'] + musica['track_id']))\n \n print(str(genero) + ' is between ' + str(valor_min) + ' and ' + str(valor_max))\n print('Total of reproduction: ' + str(lt.size(artistasRepetidos)) + ' Total of unique artists: ' + str(lt.size(artistasNoRepetidos))) \n print('--------------- Some artists for ' + str(genero) + ' -----------')\n i = 0\n while i <= 9:\n print('Artist ' + str(i) + ': ' + lt.getElement(artistasNoRepetidos, i))\n i += 1\n print('Total of reproduction is ' + str(lt.size(lista_repetidos_total)))","def __getitem__(self, i):\n return self.__tiers[i]","def iterate(self):","def extraireTemps(self, noeud=\"Turn\", attributs=(\"startTime\", \"endTime\")):\n temps = self.entree.find_all(noeud)\n\n for debut, fin in map(lambda x: (x.get(attributs[0]), x.get(attributs[1])), temps):\n yield debut, fin","def __init__(self, aeropuertos):\n self.iter = iter(aeropuertos)","def _iter_items(data_sequence):\n for time, element in data_sequence:\n for item in element:\n yield time, item","def iterator(self):\n yield","def iter_trajs(self, idxs=False, traj_sel=None):\n\n\n # set the selection of trajectories to iterate over\n if traj_sel is None:\n idx_tups = self.run_traj_idx_tuples()\n else:\n idx_tups = traj_sel\n\n # get each traj for each idx_tup and yield them for the generator\n for run_idx, traj_idx in idx_tups:\n traj = self.traj(run_idx, traj_idx)\n if idxs:\n yield (run_idx, traj_idx), traj\n else:\n yield traj","def enumerate_trajectories(gpGraph, n, source, target, max_iter=1000):\n trajectories = [MonteCarloSimulation.trajectory(gpGraph, source, target, max_iter) for i in range(n)]\n return Counter(trajectories)","def static_trajectory(Tinit, n):\n for i in xrange(n):\n yield Tinit","async def iterate_and_pass(table_sub: pxapi.TableSub) -> None:\n async for _ in table_sub:\n pass","def test_generate_temperature_list(self):\n self.assertEqual(list(self.GenTlist), [450.0, 500.0, 678.0, 700.0])","def __iter__(self):\n return iter(self._tasks)","def items(self):\n for ts in self:\n yield ts, self[ts]","def __iter__(self):\n ids_productos = self.carro.keys()\n #obtiene los objetos producto y los agrega al carro\n productos = Producto.objects.filter(id__in=ids_productos)\n for producto in productos:\n self.carro[str(producto.id)]['producto'] = producto\n\n for item in self.carro.values():\n item['precio']=Decimal(item['precio'])\n item['precio_total'] = item['precio']*item['cantidad']\n yield item","def iter_trios(self):\n for row in self._ped_tab.itertuples():\n if row.father == '0':\n continue\n if row.mother == '0':\n continue\n yield (row.sample_id, row.father, row.mother)","def tzip(iter1, *iter2plus, **tqdm_kwargs):\n kwargs = tqdm_kwargs.copy()\n tqdm_class = kwargs.pop(\"tqdm_class\", tqdm_auto)\n for i in zip(tqdm_class(iter1, **tqdm_kwargs), *iter2plus):\n yield i","def uvozi_podatke(tabele):\n for t in tabele:\n t.uvozi()","def mix_iterator(self):\n self.job = OrderedDict()\n for list_i in self.grid_iterator():\n # Pick the values to be used in this run\n for (k, i) in zip(self.table.keys(), list_i):\n self.job[k] = self.table[k][i]\n # Do the string replace operations on the values themselves\n self.expand_values()\n yield self.job","def vecinos(self, estado):\n x = list(estado)\n for i, j in combinations(range(self.n), 2):\n self.swap(x, i, j)\n yield tuple(x)\n self.swap(x, i, j)","def __iter__(self):\n return self._timeseriesData.__iter__()","def tcvs(self):\n for name in self._tcvs:\n yield name, self._data[name]","def __get_emptiest (self, person):\n doubles = []\n for scheduling_unit in person.get_scheduling_units ( ):\n doubles.append ((scheduling_unit, self.__calculate_emptiness (scheduling_unit)))\n \n doubles.sort (key=lambda trio: trio[1])\n \n scheduling_units = []\n for double in doubles:\n scheduling_units.append (double[0])\n \n return scheduling_units","def __iter__():","def __iter__():","def __iter__():","def __iter__():","def get_all_teas(self):\n self.tView.all_teas_display(self.manyTea)\n self.tView.prompt_display(0)","def iter_mempool_from_tx_tips(self) -> Iterator[Transaction]:\n from hathor.transaction.storage.traversal import BFSTimestampWalk\n\n root = self.iter_mempool_tips_from_tx_tips()\n walk = BFSTimestampWalk(self, is_dag_funds=True, is_dag_verifications=True, is_left_to_right=False)\n for tx in walk.run(root):\n tx_meta = tx.get_metadata()\n # XXX: skip blocks and tx-tips that have already been confirmed\n if tx_meta.first_block is not None or tx.is_block:\n walk.skip_neighbors(tx)\n else:\n assert isinstance(tx, Transaction)\n yield tx","def iter(self):\n return []","def visualizar_fornecedores(self):\r\n for fornecedor in self.fornecedores:\r\n fornecedor.visualizar()","def _multitasking_fake(task_iter, **kwargs):\n time_list = []\n if isinstance(task_iter, dict):\n out_iter = {}\n iter_type = 'dict'\n elif isinstance(task_iter, list):\n out_iter = [None] * len(task_iter)\n iter_type = 'list'\n else:\n raise ValueError('Param `task_iter` must be a list or a dict object.')\n if iter_type == 'dict':\n iter_items = task_iter.items()\n else:\n iter_items = enumerate(task_iter)\n for k, v in iter_items:\n assert len(\n v) <= 3, 'Length of list as the value in dict cant be longer than 3.'\n v = {\n 1: list(v) + [(), {}],\n 2: list(v) + [{}],\n 3: v,\n }.get(len(v))\n func, args, kws = v\n start = datetime.datetime.now()\n out_iter[k] = func(*args, **kws)\n end = datetime.datetime.now()\n time_list.append((k, (end - start).microseconds))\n time_list.sort(key=operator.itemgetter(1), reverse=True)\n all_time = float(sum([_[1] for _ in time_list]))\n print '*' * 10, 'cost:', all_time / 1e6, '(S)', '*' * 10\n for t in time_list:\n print t[0], ':', t[1], '>', str(round(t[1] / all_time * 100, 2)) + '%'\n return out_iter","def keys(self):\n for ts in self:\n yield ts","def __iter__(self):\n from sage.combinat.posets.posets import FinitePosets_n\n n = 0\n while True:\n for P in FinitePosets_n(n):\n yield P\n n += 1","def get_tides(self, table, dates_from_table):\n tides = defaultdict(list)\n trs = table.find_all('tr', attrs={'class': 'tide-table__separator'})\n for tr in trs:\n if not self.has_tide_info(tr, 'low'):\n continue\n\n day = 0\n td_index = 0\n tds = tr.find_all('td')\n\n while True:\n if td_index >= len(tds):\n return tides\n\n td = tds[td_index]\n dt, cols = dates_from_table[day]\n\n if cols == 0:\n tides[dt] = self.get_data(td)\n td_index += 1\n else:\n for _ in range(0, cols):\n td = tds[td_index]\n data = self.get_data(td)\n if data:\n tides[dt].extend(data)\n td_index += 1\n\n day += 1","def __iter__(self):\n for transaction in self.transaction_list:\n yield transaction","def _generate_trajectories(self, velocity, dt, num_trajectories, prediction_time, current_belief):\n\n\n\n\n trajectories = []\n #print(\"len(self._estimated_positions: {}\".format(len(self._estimated_positions)))\n for i in range(num_trajectories):\n # First, sample a position and a goal from the current belief and the estimated positions\n position, goal = self._sample_position(self._estimated_positions, current_belief)\n\n # Generate a full trajectory\n trajectory = self._generate_trajectory(position, velocity, goal, dt, prediction_time)\n\n\n trajectories.append(trajectory)\n return trajectories","def iteridents(self):\n raise NotImplementedError","def buscar_Newgenero(tempomin, tempomax, catalog):\n artistasNoRepetidos = lt.newList('ARRAY_LIST')\n artistasRepetidos = lt.newList('ARRAY_LIST')\n MapGeneros = mp.get(catalog['caraContenido'], 'tempo')\n RBTgenero = me.getValue(MapGeneros)\n lista_listas_musica = om.values(RBTgenero, tempomin, tempomax)\n lista_lista_musica = it.newIterator(lista_listas_musica)\n while it.hasNext(lista_lista_musica): \n lista_musica = it.next(lista_lista_musica)\n musicas = it.newIterator(lista_musica)\n while it.hasNext(musicas):\n musica = it.next(musicas)\n if int(lt.isPresent(artistasNoRepetidos, (musica['artist_id']))) == 0:\n lt.addLast(artistasNoRepetidos, musica['artist_id'])\n if int(lt.isPresent(artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id']))) == 0:\n lt.addLast(artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id']))\n else:\n if int(lt.isPresent(artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id']))) == 0:\n lt.addLast(artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id']))\n \n return artistasRepetidos, artistasNoRepetidos","def imprimi_tweets(lista):\n\n for texto in lista:\n print(texto)","def iter_nodes(self):","def __iter__(self):\n for x in self.innings:\n yield x","def sequence(self):\n for tn in self._testnodes:\n yield tn","def join(self):\n for t in self.created_list:\n t.join()","def backm(self,numero):\n try:\n for x in range(numero):\n self.tiempos.anterior()\n except StopIteration:\n return","def iter(self):\n\t\tfor element in self.elements:\n\t\t\tyield element","def iter(self):\n\t\tfor element in self.elements:\n\t\t\tyield element","def cellules(self): # itérateur rendu safe\n cellule_courante = self.tete\n while cellule_courante is not None:\n cellule_suivante = cellule_courante.suivant # sauvegarde\n yield cellule_courante\n cellule_courante = cellule_suivante # récupération de la sauvegarde","def get_trajectories(self):\n use_timesteps = self.config[\"batch_update\"] == \"timesteps\"\n trajectories = []\n timesteps_total = 0\n i = 0\n while (use_timesteps and timesteps_total < self.config[\"timesteps_per_batch\"]) or (not(use_timesteps) and i < self.config[\"trajectories_per_batch\"]):\n i += 1\n trajectory = self.get_trajectory()\n trajectories.append(trajectory)\n timesteps_total += len(trajectory[\"reward\"])\n return trajectories","def _read_trajectory_files(self):\n dflist = []\n self.Ntimes = {}\n for downD in self.case.downstreamD:\n outputs = self.case.get_outputs(self.method,downD)\n print(outputs['trajectory_file'])\n df = pd.read_csv(outputs['trajectory_file'],\n header=None,\n usecols=[0,1,2])\n df.columns = ['t','y','z']\n df['x'] = downD * self.case.turbine.D\n df['z'] -= self.case.turbine.zhub\n df = df.set_index(['t','x'])[['y','z']]\n self.Ntimes[downD] = len(df.index.levels[0])\n dflist.append(df)\n self.df = pd.concat(dflist).sort_index()","def iter_tads(self, x_name, normed=True):\n if not self.experiments[x_name]['hi-c']:\n raise Exception('No Hi-c data for {} experiment\\n'.format(x_name))\n for tad in self.experiments[x_name]['tads']:\n yield self.get_tad_hic(self.experiments[x_name]['tads'][tad],\n x_name, normed=normed)","def __iter__(self):\n with open(self.fn + \".fai\") as fai:\n for toks in (l.rstrip(\"\\r\\n\").split(\"\\t\") for l in fai):\n yield toks[0], int(toks[1])","def obstacle_iterator(self):\n for obstacle in self.tmx_data.get_layer_by_name(\"obstacles\"):\n yield obstacle","def __iter__(self):\n for run in self.runs:\n yield run","def next(self) -> List[object]:\n ...","def obtenir_joueurs(self, tournoi):\n i = 1\n for x in range(0, NOMBRE_JOUEURS):\n # collect player via view\n infos = self.vue.demander_info_joueur(i)\n joueur = Joueur(infos)\n # add to the list of players\n tournoi.enregistrer_joueur(joueur)\n i += 1","def consultVen(dataNoBs):\n for fila in dataNoBs:\n for elemento in fila:\n print(elemento + \"\\t\")","def __iter__(self):\n for datum in self.data[self.name]:\n yield datum","def timlinucb_parallel_t(\n df_edges,\n df_feats,\n times,\n nodes,\n num_seeds=5,\n sigma=4,\n c=0.1,\n epsilon=0.4,\n num_repeats_oim=10,\n num_repeats_oim_reward=10,\n style=\"additive\",\n process_id=1,\n persist=False,\n):\n if \"tim\" not in os.listdir():\n logger_tlu.warning(\"Couldn't find TIM in the program directory\")\n return False\n\n tim_name = f\"tim_tlu_{process_id}\"\n dir_name = f\"{tim_name}_dir\"\n logger_tlu.debug(f\"Name of the new TIM file: {tim_name}\")\n shutil.copyfile(\"tim\", tim_name)\n\n # Making the new tim file executable\n st = os.stat(tim_name)\n os.chmod(tim_name, st.st_mode | stat.S_IEXEC)\n\n results = []\n\n # For persistent parameters - making the b and M matrices\n if persist:\n b = np.zeros((df_feats.shape[1], 1))\n m_inv = np.eye(df_feats.shape[1], df_feats.shape[1])\n else:\n b = None\n m_inv = None\n\n for t in times:\n if style == \"additive\":\n df_t = df_edges[df_edges[\"day\"] <= t].sort_values(\"source\").reset_index()\n elif style == \"dynamic\":\n df_t = df_edges[df_edges[\"day\"] == t].sort_values(\"source\").reset_index()\n\n df_feats_t = df_t[\"index\"].apply(lambda x: df_feats.loc[x])\n\n result_oim = oim_node2vec(\n df_t,\n df_feats_t,\n nodes,\n num_inf=num_seeds,\n sigma=sigma,\n c=c,\n epsilon=epsilon,\n num_repeats=num_repeats_oim,\n num_repeats_reward=num_repeats_oim_reward,\n oracle=partial(tim_parallel, tim_file=tim_name, temp_dir=dir_name),\n hide_tqdm=True,\n persist=persist,\n m_inv=m_inv,\n b=b,\n )\n\n result_oim[\"time\"] = t\n\n if persist:\n m_inv = result_oim.pop(\"m_inv\")\n b = result_oim.pop(\"b\")\n\n results.append(result_oim)\n\n logger_tlu.debug(\n f\"Removing the new TIM files {tim_name} and the temp directories {dir_name}\"\n )\n os.remove(tim_name)\n shutil.rmtree(dir_name)\n\n return pd.DataFrame(results)","def __iter__(self):\n return _Iter_Ciudad_(self.aeropuertos)","def tiene_epicrisis(historia_id):\n return Epicrisis.objects.filter(historia=historia_id).all()","def todo(self, start_time=None, end_time=None):\n\n if not start_time:\n start_time = datetime.datetime.now()\n if not end_time:\n end_time = datetime.datetime.now() + datetime.timedelta(days=1)\n if start_time > end_time:\n raise ValueError\n queryset = self.model.objects.filter(active=True)\n\n todo = []\n for t in queryset:\n execution_time = t.next_run(start_time)\n while execution_time < end_time:\n todo.append(t)\n execution_time = t.next_run(execution_time + datetime.timedelta(minutes=1))\n return todo","def iterate(self):\n raise NotImplementedError()","def __iter__(self):\n for partition in self._partition_set:\n yield partition","def iterate(self):\n yield self\n for x in self:\n for y in x.iterate():\n yield y","def __iter__(self):\n keys = [CoolProp.iDmass,CoolProp.iHmass,CoolProp.iP,CoolProp.iSmass,CoolProp.iT]\n for key in sorted(keys):\n yield key","def copy_many_from_temp(self,\r\n count):\r\n\r\n for counter in range(count):\r\n print(PERIOD,end=EMPTYCHAR)\r\n self.copy_from_temp(self.tempobject)\r\n self.constitute_key_freq_dict()\r\n print()","def get_template_series(self, nb_images):\n\n # Tab for the series of images\n self.template = []\n\n # Tab\n temp = []\n\n # Make current position the zero position\n self.arm.set_to_zero([0, 1, 2])\n self.microscope.set_to_zero([0, 1, 2])\n\n # Take imges only in the template zone\n template = self.template_zone()\n height, width = template.shape[:2]\n\n # Tab of weight to detect where the pipette is\n weight = []\n\n # Detecting the tip\n for i in range(3):\n for j in range(3):\n if (i != 1) & (j != 1):\n # divide template zone into 8 images\n temp = template[i * height / 4:height / 2 + i * height / 4, j * width / 4:width / 2 + j * width / 4]\n\n # Search the tip using the number of darkest pixel in the image\n bin_edge, _ = np.histogram(temp.flatten())\n weight += [bin_edge.min()]\n else:\n # image is the center of template zone, do not consider to have functional get_withdraw_sign method\n weight += [-1]\n\n # pipette is in the image with the most darkest pixels\n index = weight.index(max(weight))\n j = index % 3\n i = index // 3\n\n # Update the position of the tip in image\n self.template_loc = [temp.shape[1] * (1 - j / 2.), temp.shape[0] * (1 - i / 2.)]\n\n # Get the series of template images at different height\n for k in range(nb_images):\n self.microscope.absolute_move(k - (nb_images - 1) / 2, 2)\n self.microscope.wait_motor_stop(2)\n time.sleep(1)\n img = self.template_zone()\n height, width = img.shape[:2]\n img = img[i * height / 4:height / 2 + i * height / 4, j * width / 4:width / 2 + j * width / 4]\n self.template += [img]\n\n # reset position at the end\n self.go_to_zero()\n pass","def testEjemploTp(self):\n azul = [0, 4, 5, 0]\n rojo = [1, 7, 4, 0]\n amarillo = [3, 6, 8, 0]\n negro = [6, 10, 10, 0]\n magenta = [7, 8, 12, 0]\n verde = [9, 11, 11, 0]\n perfiles = []\n perfiles.append(azul)\n perfiles.append(rojo)\n perfiles.append(amarillo)\n perfiles.append(negro)\n perfiles.append(magenta)\n perfiles.append(verde)\n perfil = Perfil.Perfil()\n resultadoEsperado = [0, 4, 1, 7, 4, 6, 6, 10, 9, 11, 11, 8, 12]\n for x in range(10000):\n inicial = random_integers(6, 0)\n inicial = inicial*4\n perfilOriginal = []\n for i in range (inicial, len(perfiles)+inicial, 1):\n perfilOriginal += perfiles[i%len(perfiles)]\n \n resultado = perfil.calcularPerfil(perfilOriginal, 0)\n self.assertEqual(resultadoEsperado, resultado)","async def getTiers(self, ctx):\n server_dict = self.get_server_dict(ctx)\n tierList = server_dict.setdefault(\"Tiers\", [])\n\n if(len(tierList) > 0):\n await self.bot.say(\"Tiers:\")\n for tier in tierList:\n await self.bot.say(tier)\n else:\n await self.bot.say(\":x: No tiers in tier list\")","def __iter__(self):\n if self.use_dic:\n for data in sorted(self.dic):\n self.data = data\n for activity in sorted(self.dic[data]):\n self.activity = activity\n for imsize in sorted(self.dic[data][activity]):\n self.imsize = imsize\n self.allimgs, self.alllabels = [], []\n for img in sorted(self.dic[data][activity][imsize]):\n self.img = img\n self.labels = self.dic[data][activity][imsize][img]\n if self.imlist:\n self.allimgs.append(self.img)\n self.alllabels.append(self.labels)\n else:\n yield data, activity, imsize, img, self.labels\n self.i += 1\n if self.imlist:\n yield data, activity, imsize, self.allimgs, self.alllabels\n self.i += 1\n else:\n for data in sorted(self.dic):\n self.img = data\n self.labels = self.dic[data]\n yield self.img, self.labels\n self.i += 1","def __iter__(self):\n if len(self) == 0:\n return\n current = self.first_timestamp\n delta = datetime.timedelta(0, self.interval)\n while current <= self.last_timestamp:\n yield current\n current += delta","def iteritems(self):","def __iter__(self):\n\n return iter([self.id, self.id, self.flight_num, self.arrival_time,\n self.first_name, self.last_name, self.birthdate,\n self.nationality, self.enque_time, self.departure_time,\n self.service_time, self.connecting_flight, self.processed])","def __iter__(self):\n self.__prevtask = None\n self.__curtask = None\n self.__taskiter = iter(self.tasks)\n return self.__taskiter","def __iter__(self):\n\n # Wanted to do this, but count() only accepts numbers:\n # return count(start, timedelta(days=self.step))\n\n next = self.start\n while (True):\n yield next\n next = next + timedelta(days=self.step)","def __iter__(self):\n pass\n\n # TODO: range, based on iterator","def tiers(self):\n return Parent.objects.filter(\n name=self.name,\n country=self.country\n ).order_by(\n '-start_date'\n ).values('tier', 'start_date')","def consultI(listaI): # Esta sección fue hecha por Ángel\n for fila in listaI:\n print(\"\\n\")\n for elemento in fila:\n print(elemento + \"\\t\",end = \"\")","def _topological_sort_timestamp_index(self) -> Iterator[BaseTransaction]:\n raise NotImplementedError","def iter_meters(self):\n log.info(\"Scraping meter elements from page.\")\n acct_table = self.get_accounts_table()\n rows = acct_table.find_elements_by_css_selector(\"tr\")\n\n for row in rows:\n meter = MeterElement.from_table_row(row)\n if meter is not None:\n yield meter\n else:\n log.info(\"Failed to parse table row into meter data.\")","def __iter__(self):\r\n \r\n return iter(self._by_number)","def calcular_traspuesta(self):\n # supongo que el nodo de mayor indice en je es el maximo nodo que hay\n n1 = np.max(self.je) + 1 # el +1 es por la base-0 de python\n # ahora para cada elem1, recorro los elem0 para ver las conexiones\n # notar que supondre que los elems0 son range(self.num) y los elems1 son range(n1)\n jeT = []\n len_jeT = 0\n neT = np.zeros(n1, dtype=int)\n for i1 in range(n1): # aca supongo que los elems1 son range(n1), o sea una lista de indices\n for i0 in range(self.num): # idem para elems0, son una lista de indices\n elem0 = self.get_con_elem0(i0)\n if i1 in elem0:\n jeT.append(i0)\n len_jeT += 1\n neT[i1] += 1\n # convierto el jeT a numpy\n jeT = np.array(jeT, dtype=int)\n # ensamblo el ieT\n ieT = np.zeros(n1+1, dtype=int)\n ieT[n1] = len_jeT # empiezo con el indice de un elemento extra que no existe\n for i1 in range(n1-1, -1, -1):\n ieT[i1] = ieT[i1+1] - neT[i1] # de ahi calculo el indice donde empieza cada elemento\n return n1, len_jeT, neT, ieT, jeT","def nextIter(self):\n\t\tpass","def __iter__(self) -> Iterator[T]:\n return self","def vytvorit_generator():\n mylist = range(3)\n print 'mylist = ', mylist\n for element in mylist:\n yield element","def __iter__(self):\n for arc in self.agenda:\n yield arc","def iteritems(self):\n for name, data_containers in self._name_index.items():\n for data_container in data_containers:\n yield data_container","def __iter__(self):\n n = self.head\n for _ in range(len(self)):\n if n == self.capacity:\n n = 0\n yield self.lst[n]\n n += 1","def __iter__( self ) :\n\n for entry in self.__entries : yield entry","def T_i(self, value: u.K):\n if value is None:\n self._T_i = np.repeat(self._T_e, self._number_of_particles)\n return\n\n if value.size == 1:\n self._T_i = np.repeat(value, self._number_of_particles)\n elif value.size == self._number_of_particles:\n self._T_i = value\n else:\n error_str = (\n \"T_i must be set with either one common temperature\"\n f\" for all ions, or a set of {self._number_of_particles} of them. \"\n )\n\n if value.size == 5 and self._number_of_particles != 5:\n error_str += f\" For {self.base_particle}, five is right out.\"\n raise ParticleError(error_str)","def stepm(self,numero):\n try:\n for x in range(numero):\n self.tiempos.siguiente()\n except StopIteration:\n return","def getTimes():","def getTimes():"],"string":"[\n \"def __iter__(self):\\n start_times = (start for start, end in self.tss)\\n names = (name.rstrip() for name in self.inps)\\n for ind, (c, t) in enumerate(zip(names, start_times)):\\n yield (c, t, ind)\",\n \"def build_tiers(self):\\n self.tiers = []\\n for size in range(1,len(self.sigma)+1):\\n for combo in itertools.combinations(self.sigma, size):\\n self.tiers.append(tuple(sorted(list(combo))))\",\n \"def __iter__(self) -> Iterator[int]:\\n return iter(self._tasks)\",\n \"def time_list(self):\\n return (self.N_T * (np.arange(self.N_itr) + 1) /\\n self.N_itr * 1000 * self.DT)\",\n \"def iter_mempool_tips_from_tx_tips(self) -> Iterator[Transaction]:\\n assert self.indexes is not None\\n tx_tips = self.indexes.tx_tips\\n\\n for interval in tx_tips[self.latest_timestamp + 1]:\\n tx = self.get_transaction(interval.data)\\n tx_meta = tx.get_metadata()\\n assert isinstance(tx, Transaction) # XXX: tx_tips only has transactions\\n # XXX: skip txs that have already been confirmed\\n if tx_meta.first_block:\\n continue\\n yield tx\",\n \"def _generate_instances(self, single_traj):\\n return [single_traj[:2].values]\",\n \"def generos_existentes(catalog, generos):\\n lista_repetidos_total = lt.newList('ARRAY_LIST')\\n list_generos = generos.split(\\\",\\\")\\n for genero in list_generos:\\n artistasNoRepetidos = lt.newList('ARRAY_LIST')\\n artistasRepetidos = lt.newList('ARRAY_LIST')\\n MapGeneros = mp.get(catalog['musicaGenero'], genero)\\n RBTgenero = me.getValue(MapGeneros)\\n valor_min = om.minKey(RBTgenero)\\n valor_max = om.maxKey(RBTgenero)\\n lista_listas_musica = om.values(RBTgenero, valor_min, valor_max)\\n lista_lista_musica = it.newIterator(lista_listas_musica)\\n while it.hasNext(lista_lista_musica): \\n lista_musica = it.next(lista_lista_musica)\\n musicas = it.newIterator(lista_musica)\\n while it.hasNext(musicas):\\n musica = it.next(musicas)\\n if int(lt.isPresent(artistasNoRepetidos, musica['artist_id'])) == 0:\\n lt.addLast(artistasNoRepetidos, musica['artist_id'])\\n if int(lt.isPresent(artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id']))) == 0:\\n lt.addLast(artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id']))\\n #if int(lt.isPresent(lista_repetidos_total, (musica['created_at'] + musica['user_id'] + musica['track_id']))) == 0:\\n # lt.addLast(lista_repetidos_total, (musica['created_at'] + musica['user_id'] + musica['track_id']))\\n else:\\n if int(lt.isPresent(artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id']))) == 0:\\n lt.addLast(artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id']))\\n #if int(lt.isPresent(lista_repetidos_total, (musica['created_at'] + musica['user_id'] + musica['track_id']))) == 0:\\n # lt.addLast(lista_repetidos_total, (musica['created_at'] + musica['user_id'] + musica['track_id']))\\n \\n print(str(genero) + ' is between ' + str(valor_min) + ' and ' + str(valor_max))\\n print('Total of reproduction: ' + str(lt.size(artistasRepetidos)) + ' Total of unique artists: ' + str(lt.size(artistasNoRepetidos))) \\n print('--------------- Some artists for ' + str(genero) + ' -----------')\\n i = 0\\n while i <= 9:\\n print('Artist ' + str(i) + ': ' + lt.getElement(artistasNoRepetidos, i))\\n i += 1\\n print('Total of reproduction is ' + str(lt.size(lista_repetidos_total)))\",\n \"def __getitem__(self, i):\\n return self.__tiers[i]\",\n \"def iterate(self):\",\n \"def extraireTemps(self, noeud=\\\"Turn\\\", attributs=(\\\"startTime\\\", \\\"endTime\\\")):\\n temps = self.entree.find_all(noeud)\\n\\n for debut, fin in map(lambda x: (x.get(attributs[0]), x.get(attributs[1])), temps):\\n yield debut, fin\",\n \"def __init__(self, aeropuertos):\\n self.iter = iter(aeropuertos)\",\n \"def _iter_items(data_sequence):\\n for time, element in data_sequence:\\n for item in element:\\n yield time, item\",\n \"def iterator(self):\\n yield\",\n \"def iter_trajs(self, idxs=False, traj_sel=None):\\n\\n\\n # set the selection of trajectories to iterate over\\n if traj_sel is None:\\n idx_tups = self.run_traj_idx_tuples()\\n else:\\n idx_tups = traj_sel\\n\\n # get each traj for each idx_tup and yield them for the generator\\n for run_idx, traj_idx in idx_tups:\\n traj = self.traj(run_idx, traj_idx)\\n if idxs:\\n yield (run_idx, traj_idx), traj\\n else:\\n yield traj\",\n \"def enumerate_trajectories(gpGraph, n, source, target, max_iter=1000):\\n trajectories = [MonteCarloSimulation.trajectory(gpGraph, source, target, max_iter) for i in range(n)]\\n return Counter(trajectories)\",\n \"def static_trajectory(Tinit, n):\\n for i in xrange(n):\\n yield Tinit\",\n \"async def iterate_and_pass(table_sub: pxapi.TableSub) -> None:\\n async for _ in table_sub:\\n pass\",\n \"def test_generate_temperature_list(self):\\n self.assertEqual(list(self.GenTlist), [450.0, 500.0, 678.0, 700.0])\",\n \"def __iter__(self):\\n return iter(self._tasks)\",\n \"def items(self):\\n for ts in self:\\n yield ts, self[ts]\",\n \"def __iter__(self):\\n ids_productos = self.carro.keys()\\n #obtiene los objetos producto y los agrega al carro\\n productos = Producto.objects.filter(id__in=ids_productos)\\n for producto in productos:\\n self.carro[str(producto.id)]['producto'] = producto\\n\\n for item in self.carro.values():\\n item['precio']=Decimal(item['precio'])\\n item['precio_total'] = item['precio']*item['cantidad']\\n yield item\",\n \"def iter_trios(self):\\n for row in self._ped_tab.itertuples():\\n if row.father == '0':\\n continue\\n if row.mother == '0':\\n continue\\n yield (row.sample_id, row.father, row.mother)\",\n \"def tzip(iter1, *iter2plus, **tqdm_kwargs):\\n kwargs = tqdm_kwargs.copy()\\n tqdm_class = kwargs.pop(\\\"tqdm_class\\\", tqdm_auto)\\n for i in zip(tqdm_class(iter1, **tqdm_kwargs), *iter2plus):\\n yield i\",\n \"def uvozi_podatke(tabele):\\n for t in tabele:\\n t.uvozi()\",\n \"def mix_iterator(self):\\n self.job = OrderedDict()\\n for list_i in self.grid_iterator():\\n # Pick the values to be used in this run\\n for (k, i) in zip(self.table.keys(), list_i):\\n self.job[k] = self.table[k][i]\\n # Do the string replace operations on the values themselves\\n self.expand_values()\\n yield self.job\",\n \"def vecinos(self, estado):\\n x = list(estado)\\n for i, j in combinations(range(self.n), 2):\\n self.swap(x, i, j)\\n yield tuple(x)\\n self.swap(x, i, j)\",\n \"def __iter__(self):\\n return self._timeseriesData.__iter__()\",\n \"def tcvs(self):\\n for name in self._tcvs:\\n yield name, self._data[name]\",\n \"def __get_emptiest (self, person):\\n doubles = []\\n for scheduling_unit in person.get_scheduling_units ( ):\\n doubles.append ((scheduling_unit, self.__calculate_emptiness (scheduling_unit)))\\n \\n doubles.sort (key=lambda trio: trio[1])\\n \\n scheduling_units = []\\n for double in doubles:\\n scheduling_units.append (double[0])\\n \\n return scheduling_units\",\n \"def __iter__():\",\n \"def __iter__():\",\n \"def __iter__():\",\n \"def __iter__():\",\n \"def get_all_teas(self):\\n self.tView.all_teas_display(self.manyTea)\\n self.tView.prompt_display(0)\",\n \"def iter_mempool_from_tx_tips(self) -> Iterator[Transaction]:\\n from hathor.transaction.storage.traversal import BFSTimestampWalk\\n\\n root = self.iter_mempool_tips_from_tx_tips()\\n walk = BFSTimestampWalk(self, is_dag_funds=True, is_dag_verifications=True, is_left_to_right=False)\\n for tx in walk.run(root):\\n tx_meta = tx.get_metadata()\\n # XXX: skip blocks and tx-tips that have already been confirmed\\n if tx_meta.first_block is not None or tx.is_block:\\n walk.skip_neighbors(tx)\\n else:\\n assert isinstance(tx, Transaction)\\n yield tx\",\n \"def iter(self):\\n return []\",\n \"def visualizar_fornecedores(self):\\r\\n for fornecedor in self.fornecedores:\\r\\n fornecedor.visualizar()\",\n \"def _multitasking_fake(task_iter, **kwargs):\\n time_list = []\\n if isinstance(task_iter, dict):\\n out_iter = {}\\n iter_type = 'dict'\\n elif isinstance(task_iter, list):\\n out_iter = [None] * len(task_iter)\\n iter_type = 'list'\\n else:\\n raise ValueError('Param `task_iter` must be a list or a dict object.')\\n if iter_type == 'dict':\\n iter_items = task_iter.items()\\n else:\\n iter_items = enumerate(task_iter)\\n for k, v in iter_items:\\n assert len(\\n v) <= 3, 'Length of list as the value in dict cant be longer than 3.'\\n v = {\\n 1: list(v) + [(), {}],\\n 2: list(v) + [{}],\\n 3: v,\\n }.get(len(v))\\n func, args, kws = v\\n start = datetime.datetime.now()\\n out_iter[k] = func(*args, **kws)\\n end = datetime.datetime.now()\\n time_list.append((k, (end - start).microseconds))\\n time_list.sort(key=operator.itemgetter(1), reverse=True)\\n all_time = float(sum([_[1] for _ in time_list]))\\n print '*' * 10, 'cost:', all_time / 1e6, '(S)', '*' * 10\\n for t in time_list:\\n print t[0], ':', t[1], '>', str(round(t[1] / all_time * 100, 2)) + '%'\\n return out_iter\",\n \"def keys(self):\\n for ts in self:\\n yield ts\",\n \"def __iter__(self):\\n from sage.combinat.posets.posets import FinitePosets_n\\n n = 0\\n while True:\\n for P in FinitePosets_n(n):\\n yield P\\n n += 1\",\n \"def get_tides(self, table, dates_from_table):\\n tides = defaultdict(list)\\n trs = table.find_all('tr', attrs={'class': 'tide-table__separator'})\\n for tr in trs:\\n if not self.has_tide_info(tr, 'low'):\\n continue\\n\\n day = 0\\n td_index = 0\\n tds = tr.find_all('td')\\n\\n while True:\\n if td_index >= len(tds):\\n return tides\\n\\n td = tds[td_index]\\n dt, cols = dates_from_table[day]\\n\\n if cols == 0:\\n tides[dt] = self.get_data(td)\\n td_index += 1\\n else:\\n for _ in range(0, cols):\\n td = tds[td_index]\\n data = self.get_data(td)\\n if data:\\n tides[dt].extend(data)\\n td_index += 1\\n\\n day += 1\",\n \"def __iter__(self):\\n for transaction in self.transaction_list:\\n yield transaction\",\n \"def _generate_trajectories(self, velocity, dt, num_trajectories, prediction_time, current_belief):\\n\\n\\n\\n\\n trajectories = []\\n #print(\\\"len(self._estimated_positions: {}\\\".format(len(self._estimated_positions)))\\n for i in range(num_trajectories):\\n # First, sample a position and a goal from the current belief and the estimated positions\\n position, goal = self._sample_position(self._estimated_positions, current_belief)\\n\\n # Generate a full trajectory\\n trajectory = self._generate_trajectory(position, velocity, goal, dt, prediction_time)\\n\\n\\n trajectories.append(trajectory)\\n return trajectories\",\n \"def iteridents(self):\\n raise NotImplementedError\",\n \"def buscar_Newgenero(tempomin, tempomax, catalog):\\n artistasNoRepetidos = lt.newList('ARRAY_LIST')\\n artistasRepetidos = lt.newList('ARRAY_LIST')\\n MapGeneros = mp.get(catalog['caraContenido'], 'tempo')\\n RBTgenero = me.getValue(MapGeneros)\\n lista_listas_musica = om.values(RBTgenero, tempomin, tempomax)\\n lista_lista_musica = it.newIterator(lista_listas_musica)\\n while it.hasNext(lista_lista_musica): \\n lista_musica = it.next(lista_lista_musica)\\n musicas = it.newIterator(lista_musica)\\n while it.hasNext(musicas):\\n musica = it.next(musicas)\\n if int(lt.isPresent(artistasNoRepetidos, (musica['artist_id']))) == 0:\\n lt.addLast(artistasNoRepetidos, musica['artist_id'])\\n if int(lt.isPresent(artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id']))) == 0:\\n lt.addLast(artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id']))\\n else:\\n if int(lt.isPresent(artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id']))) == 0:\\n lt.addLast(artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id']))\\n \\n return artistasRepetidos, artistasNoRepetidos\",\n \"def imprimi_tweets(lista):\\n\\n for texto in lista:\\n print(texto)\",\n \"def iter_nodes(self):\",\n \"def __iter__(self):\\n for x in self.innings:\\n yield x\",\n \"def sequence(self):\\n for tn in self._testnodes:\\n yield tn\",\n \"def join(self):\\n for t in self.created_list:\\n t.join()\",\n \"def backm(self,numero):\\n try:\\n for x in range(numero):\\n self.tiempos.anterior()\\n except StopIteration:\\n return\",\n \"def iter(self):\\n\\t\\tfor element in self.elements:\\n\\t\\t\\tyield element\",\n \"def iter(self):\\n\\t\\tfor element in self.elements:\\n\\t\\t\\tyield element\",\n \"def cellules(self): # itérateur rendu safe\\n cellule_courante = self.tete\\n while cellule_courante is not None:\\n cellule_suivante = cellule_courante.suivant # sauvegarde\\n yield cellule_courante\\n cellule_courante = cellule_suivante # récupération de la sauvegarde\",\n \"def get_trajectories(self):\\n use_timesteps = self.config[\\\"batch_update\\\"] == \\\"timesteps\\\"\\n trajectories = []\\n timesteps_total = 0\\n i = 0\\n while (use_timesteps and timesteps_total < self.config[\\\"timesteps_per_batch\\\"]) or (not(use_timesteps) and i < self.config[\\\"trajectories_per_batch\\\"]):\\n i += 1\\n trajectory = self.get_trajectory()\\n trajectories.append(trajectory)\\n timesteps_total += len(trajectory[\\\"reward\\\"])\\n return trajectories\",\n \"def _read_trajectory_files(self):\\n dflist = []\\n self.Ntimes = {}\\n for downD in self.case.downstreamD:\\n outputs = self.case.get_outputs(self.method,downD)\\n print(outputs['trajectory_file'])\\n df = pd.read_csv(outputs['trajectory_file'],\\n header=None,\\n usecols=[0,1,2])\\n df.columns = ['t','y','z']\\n df['x'] = downD * self.case.turbine.D\\n df['z'] -= self.case.turbine.zhub\\n df = df.set_index(['t','x'])[['y','z']]\\n self.Ntimes[downD] = len(df.index.levels[0])\\n dflist.append(df)\\n self.df = pd.concat(dflist).sort_index()\",\n \"def iter_tads(self, x_name, normed=True):\\n if not self.experiments[x_name]['hi-c']:\\n raise Exception('No Hi-c data for {} experiment\\\\n'.format(x_name))\\n for tad in self.experiments[x_name]['tads']:\\n yield self.get_tad_hic(self.experiments[x_name]['tads'][tad],\\n x_name, normed=normed)\",\n \"def __iter__(self):\\n with open(self.fn + \\\".fai\\\") as fai:\\n for toks in (l.rstrip(\\\"\\\\r\\\\n\\\").split(\\\"\\\\t\\\") for l in fai):\\n yield toks[0], int(toks[1])\",\n \"def obstacle_iterator(self):\\n for obstacle in self.tmx_data.get_layer_by_name(\\\"obstacles\\\"):\\n yield obstacle\",\n \"def __iter__(self):\\n for run in self.runs:\\n yield run\",\n \"def next(self) -> List[object]:\\n ...\",\n \"def obtenir_joueurs(self, tournoi):\\n i = 1\\n for x in range(0, NOMBRE_JOUEURS):\\n # collect player via view\\n infos = self.vue.demander_info_joueur(i)\\n joueur = Joueur(infos)\\n # add to the list of players\\n tournoi.enregistrer_joueur(joueur)\\n i += 1\",\n \"def consultVen(dataNoBs):\\n for fila in dataNoBs:\\n for elemento in fila:\\n print(elemento + \\\"\\\\t\\\")\",\n \"def __iter__(self):\\n for datum in self.data[self.name]:\\n yield datum\",\n \"def timlinucb_parallel_t(\\n df_edges,\\n df_feats,\\n times,\\n nodes,\\n num_seeds=5,\\n sigma=4,\\n c=0.1,\\n epsilon=0.4,\\n num_repeats_oim=10,\\n num_repeats_oim_reward=10,\\n style=\\\"additive\\\",\\n process_id=1,\\n persist=False,\\n):\\n if \\\"tim\\\" not in os.listdir():\\n logger_tlu.warning(\\\"Couldn't find TIM in the program directory\\\")\\n return False\\n\\n tim_name = f\\\"tim_tlu_{process_id}\\\"\\n dir_name = f\\\"{tim_name}_dir\\\"\\n logger_tlu.debug(f\\\"Name of the new TIM file: {tim_name}\\\")\\n shutil.copyfile(\\\"tim\\\", tim_name)\\n\\n # Making the new tim file executable\\n st = os.stat(tim_name)\\n os.chmod(tim_name, st.st_mode | stat.S_IEXEC)\\n\\n results = []\\n\\n # For persistent parameters - making the b and M matrices\\n if persist:\\n b = np.zeros((df_feats.shape[1], 1))\\n m_inv = np.eye(df_feats.shape[1], df_feats.shape[1])\\n else:\\n b = None\\n m_inv = None\\n\\n for t in times:\\n if style == \\\"additive\\\":\\n df_t = df_edges[df_edges[\\\"day\\\"] <= t].sort_values(\\\"source\\\").reset_index()\\n elif style == \\\"dynamic\\\":\\n df_t = df_edges[df_edges[\\\"day\\\"] == t].sort_values(\\\"source\\\").reset_index()\\n\\n df_feats_t = df_t[\\\"index\\\"].apply(lambda x: df_feats.loc[x])\\n\\n result_oim = oim_node2vec(\\n df_t,\\n df_feats_t,\\n nodes,\\n num_inf=num_seeds,\\n sigma=sigma,\\n c=c,\\n epsilon=epsilon,\\n num_repeats=num_repeats_oim,\\n num_repeats_reward=num_repeats_oim_reward,\\n oracle=partial(tim_parallel, tim_file=tim_name, temp_dir=dir_name),\\n hide_tqdm=True,\\n persist=persist,\\n m_inv=m_inv,\\n b=b,\\n )\\n\\n result_oim[\\\"time\\\"] = t\\n\\n if persist:\\n m_inv = result_oim.pop(\\\"m_inv\\\")\\n b = result_oim.pop(\\\"b\\\")\\n\\n results.append(result_oim)\\n\\n logger_tlu.debug(\\n f\\\"Removing the new TIM files {tim_name} and the temp directories {dir_name}\\\"\\n )\\n os.remove(tim_name)\\n shutil.rmtree(dir_name)\\n\\n return pd.DataFrame(results)\",\n \"def __iter__(self):\\n return _Iter_Ciudad_(self.aeropuertos)\",\n \"def tiene_epicrisis(historia_id):\\n return Epicrisis.objects.filter(historia=historia_id).all()\",\n \"def todo(self, start_time=None, end_time=None):\\n\\n if not start_time:\\n start_time = datetime.datetime.now()\\n if not end_time:\\n end_time = datetime.datetime.now() + datetime.timedelta(days=1)\\n if start_time > end_time:\\n raise ValueError\\n queryset = self.model.objects.filter(active=True)\\n\\n todo = []\\n for t in queryset:\\n execution_time = t.next_run(start_time)\\n while execution_time < end_time:\\n todo.append(t)\\n execution_time = t.next_run(execution_time + datetime.timedelta(minutes=1))\\n return todo\",\n \"def iterate(self):\\n raise NotImplementedError()\",\n \"def __iter__(self):\\n for partition in self._partition_set:\\n yield partition\",\n \"def iterate(self):\\n yield self\\n for x in self:\\n for y in x.iterate():\\n yield y\",\n \"def __iter__(self):\\n keys = [CoolProp.iDmass,CoolProp.iHmass,CoolProp.iP,CoolProp.iSmass,CoolProp.iT]\\n for key in sorted(keys):\\n yield key\",\n \"def copy_many_from_temp(self,\\r\\n count):\\r\\n\\r\\n for counter in range(count):\\r\\n print(PERIOD,end=EMPTYCHAR)\\r\\n self.copy_from_temp(self.tempobject)\\r\\n self.constitute_key_freq_dict()\\r\\n print()\",\n \"def get_template_series(self, nb_images):\\n\\n # Tab for the series of images\\n self.template = []\\n\\n # Tab\\n temp = []\\n\\n # Make current position the zero position\\n self.arm.set_to_zero([0, 1, 2])\\n self.microscope.set_to_zero([0, 1, 2])\\n\\n # Take imges only in the template zone\\n template = self.template_zone()\\n height, width = template.shape[:2]\\n\\n # Tab of weight to detect where the pipette is\\n weight = []\\n\\n # Detecting the tip\\n for i in range(3):\\n for j in range(3):\\n if (i != 1) & (j != 1):\\n # divide template zone into 8 images\\n temp = template[i * height / 4:height / 2 + i * height / 4, j * width / 4:width / 2 + j * width / 4]\\n\\n # Search the tip using the number of darkest pixel in the image\\n bin_edge, _ = np.histogram(temp.flatten())\\n weight += [bin_edge.min()]\\n else:\\n # image is the center of template zone, do not consider to have functional get_withdraw_sign method\\n weight += [-1]\\n\\n # pipette is in the image with the most darkest pixels\\n index = weight.index(max(weight))\\n j = index % 3\\n i = index // 3\\n\\n # Update the position of the tip in image\\n self.template_loc = [temp.shape[1] * (1 - j / 2.), temp.shape[0] * (1 - i / 2.)]\\n\\n # Get the series of template images at different height\\n for k in range(nb_images):\\n self.microscope.absolute_move(k - (nb_images - 1) / 2, 2)\\n self.microscope.wait_motor_stop(2)\\n time.sleep(1)\\n img = self.template_zone()\\n height, width = img.shape[:2]\\n img = img[i * height / 4:height / 2 + i * height / 4, j * width / 4:width / 2 + j * width / 4]\\n self.template += [img]\\n\\n # reset position at the end\\n self.go_to_zero()\\n pass\",\n \"def testEjemploTp(self):\\n azul = [0, 4, 5, 0]\\n rojo = [1, 7, 4, 0]\\n amarillo = [3, 6, 8, 0]\\n negro = [6, 10, 10, 0]\\n magenta = [7, 8, 12, 0]\\n verde = [9, 11, 11, 0]\\n perfiles = []\\n perfiles.append(azul)\\n perfiles.append(rojo)\\n perfiles.append(amarillo)\\n perfiles.append(negro)\\n perfiles.append(magenta)\\n perfiles.append(verde)\\n perfil = Perfil.Perfil()\\n resultadoEsperado = [0, 4, 1, 7, 4, 6, 6, 10, 9, 11, 11, 8, 12]\\n for x in range(10000):\\n inicial = random_integers(6, 0)\\n inicial = inicial*4\\n perfilOriginal = []\\n for i in range (inicial, len(perfiles)+inicial, 1):\\n perfilOriginal += perfiles[i%len(perfiles)]\\n \\n resultado = perfil.calcularPerfil(perfilOriginal, 0)\\n self.assertEqual(resultadoEsperado, resultado)\",\n \"async def getTiers(self, ctx):\\n server_dict = self.get_server_dict(ctx)\\n tierList = server_dict.setdefault(\\\"Tiers\\\", [])\\n\\n if(len(tierList) > 0):\\n await self.bot.say(\\\"Tiers:\\\")\\n for tier in tierList:\\n await self.bot.say(tier)\\n else:\\n await self.bot.say(\\\":x: No tiers in tier list\\\")\",\n \"def __iter__(self):\\n if self.use_dic:\\n for data in sorted(self.dic):\\n self.data = data\\n for activity in sorted(self.dic[data]):\\n self.activity = activity\\n for imsize in sorted(self.dic[data][activity]):\\n self.imsize = imsize\\n self.allimgs, self.alllabels = [], []\\n for img in sorted(self.dic[data][activity][imsize]):\\n self.img = img\\n self.labels = self.dic[data][activity][imsize][img]\\n if self.imlist:\\n self.allimgs.append(self.img)\\n self.alllabels.append(self.labels)\\n else:\\n yield data, activity, imsize, img, self.labels\\n self.i += 1\\n if self.imlist:\\n yield data, activity, imsize, self.allimgs, self.alllabels\\n self.i += 1\\n else:\\n for data in sorted(self.dic):\\n self.img = data\\n self.labels = self.dic[data]\\n yield self.img, self.labels\\n self.i += 1\",\n \"def __iter__(self):\\n if len(self) == 0:\\n return\\n current = self.first_timestamp\\n delta = datetime.timedelta(0, self.interval)\\n while current <= self.last_timestamp:\\n yield current\\n current += delta\",\n \"def iteritems(self):\",\n \"def __iter__(self):\\n\\n return iter([self.id, self.id, self.flight_num, self.arrival_time,\\n self.first_name, self.last_name, self.birthdate,\\n self.nationality, self.enque_time, self.departure_time,\\n self.service_time, self.connecting_flight, self.processed])\",\n \"def __iter__(self):\\n self.__prevtask = None\\n self.__curtask = None\\n self.__taskiter = iter(self.tasks)\\n return self.__taskiter\",\n \"def __iter__(self):\\n\\n # Wanted to do this, but count() only accepts numbers:\\n # return count(start, timedelta(days=self.step))\\n\\n next = self.start\\n while (True):\\n yield next\\n next = next + timedelta(days=self.step)\",\n \"def __iter__(self):\\n pass\\n\\n # TODO: range, based on iterator\",\n \"def tiers(self):\\n return Parent.objects.filter(\\n name=self.name,\\n country=self.country\\n ).order_by(\\n '-start_date'\\n ).values('tier', 'start_date')\",\n \"def consultI(listaI): # Esta sección fue hecha por Ángel\\n for fila in listaI:\\n print(\\\"\\\\n\\\")\\n for elemento in fila:\\n print(elemento + \\\"\\\\t\\\",end = \\\"\\\")\",\n \"def _topological_sort_timestamp_index(self) -> Iterator[BaseTransaction]:\\n raise NotImplementedError\",\n \"def iter_meters(self):\\n log.info(\\\"Scraping meter elements from page.\\\")\\n acct_table = self.get_accounts_table()\\n rows = acct_table.find_elements_by_css_selector(\\\"tr\\\")\\n\\n for row in rows:\\n meter = MeterElement.from_table_row(row)\\n if meter is not None:\\n yield meter\\n else:\\n log.info(\\\"Failed to parse table row into meter data.\\\")\",\n \"def __iter__(self):\\r\\n \\r\\n return iter(self._by_number)\",\n \"def calcular_traspuesta(self):\\n # supongo que el nodo de mayor indice en je es el maximo nodo que hay\\n n1 = np.max(self.je) + 1 # el +1 es por la base-0 de python\\n # ahora para cada elem1, recorro los elem0 para ver las conexiones\\n # notar que supondre que los elems0 son range(self.num) y los elems1 son range(n1)\\n jeT = []\\n len_jeT = 0\\n neT = np.zeros(n1, dtype=int)\\n for i1 in range(n1): # aca supongo que los elems1 son range(n1), o sea una lista de indices\\n for i0 in range(self.num): # idem para elems0, son una lista de indices\\n elem0 = self.get_con_elem0(i0)\\n if i1 in elem0:\\n jeT.append(i0)\\n len_jeT += 1\\n neT[i1] += 1\\n # convierto el jeT a numpy\\n jeT = np.array(jeT, dtype=int)\\n # ensamblo el ieT\\n ieT = np.zeros(n1+1, dtype=int)\\n ieT[n1] = len_jeT # empiezo con el indice de un elemento extra que no existe\\n for i1 in range(n1-1, -1, -1):\\n ieT[i1] = ieT[i1+1] - neT[i1] # de ahi calculo el indice donde empieza cada elemento\\n return n1, len_jeT, neT, ieT, jeT\",\n \"def nextIter(self):\\n\\t\\tpass\",\n \"def __iter__(self) -> Iterator[T]:\\n return self\",\n \"def vytvorit_generator():\\n mylist = range(3)\\n print 'mylist = ', mylist\\n for element in mylist:\\n yield element\",\n \"def __iter__(self):\\n for arc in self.agenda:\\n yield arc\",\n \"def iteritems(self):\\n for name, data_containers in self._name_index.items():\\n for data_container in data_containers:\\n yield data_container\",\n \"def __iter__(self):\\n n = self.head\\n for _ in range(len(self)):\\n if n == self.capacity:\\n n = 0\\n yield self.lst[n]\\n n += 1\",\n \"def __iter__( self ) :\\n\\n for entry in self.__entries : yield entry\",\n \"def T_i(self, value: u.K):\\n if value is None:\\n self._T_i = np.repeat(self._T_e, self._number_of_particles)\\n return\\n\\n if value.size == 1:\\n self._T_i = np.repeat(value, self._number_of_particles)\\n elif value.size == self._number_of_particles:\\n self._T_i = value\\n else:\\n error_str = (\\n \\\"T_i must be set with either one common temperature\\\"\\n f\\\" for all ions, or a set of {self._number_of_particles} of them. \\\"\\n )\\n\\n if value.size == 5 and self._number_of_particles != 5:\\n error_str += f\\\" For {self.base_particle}, five is right out.\\\"\\n raise ParticleError(error_str)\",\n \"def stepm(self,numero):\\n try:\\n for x in range(numero):\\n self.tiempos.siguiente()\\n except StopIteration:\\n return\",\n \"def getTimes():\",\n \"def getTimes():\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.594252","0.56421316","0.5424925","0.54007185","0.539346","0.53655404","0.5364286","0.5360746","0.5349394","0.5274494","0.52421033","0.5217823","0.5169063","0.516716","0.5154065","0.51434505","0.5137085","0.5135831","0.5119165","0.5110781","0.5105052","0.50906223","0.50787127","0.50688004","0.50666225","0.5056651","0.50563467","0.50212437","0.5019319","0.5009487","0.5009487","0.5009487","0.5009487","0.49944094","0.49717954","0.49672142","0.4965659","0.4951592","0.49438608","0.49436858","0.494081","0.4936276","0.49352136","0.4918635","0.48955676","0.48943555","0.48920506","0.48879483","0.4873255","0.48711297","0.48662972","0.48574543","0.48574543","0.48491558","0.48373845","0.4833049","0.48293254","0.48240292","0.48209223","0.4804221","0.48026207","0.48006046","0.48003238","0.4789259","0.47848722","0.4779614","0.47751316","0.47744578","0.47730395","0.47605732","0.47600028","0.47572514","0.47455427","0.47454143","0.4744842","0.4742376","0.4742012","0.47368267","0.47353557","0.47326928","0.47318938","0.4728007","0.4727914","0.4727078","0.4724332","0.47159636","0.47155267","0.47138476","0.47101864","0.47084495","0.47043833","0.46990186","0.46982646","0.46954116","0.46888235","0.46877596","0.46875516","0.46873707","0.4684691","0.4684691"],"string":"[\n \"0.594252\",\n \"0.56421316\",\n \"0.5424925\",\n \"0.54007185\",\n \"0.539346\",\n \"0.53655404\",\n \"0.5364286\",\n \"0.5360746\",\n \"0.5349394\",\n \"0.5274494\",\n \"0.52421033\",\n \"0.5217823\",\n \"0.5169063\",\n \"0.516716\",\n \"0.5154065\",\n \"0.51434505\",\n \"0.5137085\",\n \"0.5135831\",\n \"0.5119165\",\n \"0.5110781\",\n \"0.5105052\",\n \"0.50906223\",\n \"0.50787127\",\n \"0.50688004\",\n \"0.50666225\",\n \"0.5056651\",\n \"0.50563467\",\n \"0.50212437\",\n \"0.5019319\",\n \"0.5009487\",\n \"0.5009487\",\n \"0.5009487\",\n \"0.5009487\",\n \"0.49944094\",\n \"0.49717954\",\n \"0.49672142\",\n \"0.4965659\",\n \"0.4951592\",\n \"0.49438608\",\n \"0.49436858\",\n \"0.494081\",\n \"0.4936276\",\n \"0.49352136\",\n \"0.4918635\",\n \"0.48955676\",\n \"0.48943555\",\n \"0.48920506\",\n \"0.48879483\",\n \"0.4873255\",\n \"0.48711297\",\n \"0.48662972\",\n \"0.48574543\",\n \"0.48574543\",\n \"0.48491558\",\n \"0.48373845\",\n \"0.4833049\",\n \"0.48293254\",\n \"0.48240292\",\n \"0.48209223\",\n \"0.4804221\",\n \"0.48026207\",\n \"0.48006046\",\n \"0.48003238\",\n \"0.4789259\",\n \"0.47848722\",\n \"0.4779614\",\n \"0.47751316\",\n \"0.47744578\",\n \"0.47730395\",\n \"0.47605732\",\n \"0.47600028\",\n \"0.47572514\",\n \"0.47455427\",\n \"0.47454143\",\n \"0.4744842\",\n \"0.4742376\",\n \"0.4742012\",\n \"0.47368267\",\n \"0.47353557\",\n \"0.47326928\",\n \"0.47318938\",\n \"0.4728007\",\n \"0.4727914\",\n \"0.4727078\",\n \"0.4724332\",\n \"0.47159636\",\n \"0.47155267\",\n \"0.47138476\",\n \"0.47101864\",\n \"0.47084495\",\n \"0.47043833\",\n \"0.46990186\",\n \"0.46982646\",\n \"0.46954116\",\n \"0.46888235\",\n \"0.46877596\",\n \"0.46875516\",\n \"0.46873707\",\n \"0.4684691\",\n \"0.4684691\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.52542615"},"document_rank":{"kind":"string","value":"10"}}},{"rowIdx":79083,"cells":{"query":{"kind":"string","value":"Interpola linealmente el valor en el instante t"},"document":{"kind":"string","value":"def __call__(self, t):\n \n c = c1 = c2 = 0\n d = d1 = d2 = None\n while d1==None or d2==None or d<=d2:\n _t = self.time(c)\n if _t == None:\n break\n else:\n d = abs(t - _t)\n if d1 == None or d<d1:\n c1, d1 = c, d\n elif d2 == None or d<d2:\n c2, d2 = c, d\n c += 1\n t1, t2 = map(self.time, [c1, c2])\n v1, v2 = map(self.__getitem__, [c1, c2])\n # a lo mejor la lista solo contiene un elemento\n if t1 == t2:\n return v1\n else:\n # si contiene por lo menos dos, pues interpolacion lineal\n return (v2*(t - t1) - v1*(t - t2))/(t2 - t1)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_t(self):\n return self.t","def get_t_value(self):\n return float(self.data[2]) / 10","def Temp(t):\n return 20 # Need to link to data","def value(t):\r\n return t(0)","def lin_pol_to_TE_TM(field):\n\n pass","def __str__(self):\n return str(self.t1)+\"<-->t1, \\t\"+str(self.t2)+\"<-->t2, \\t\"+str(self.phi)+\"<-->phi, \\t\"+str(self.m)+\"<-->m, \\t\"+str(self.t31)+\"<-->t31, \\t\"+str(self.t32)+\"<-->t32, \\n\"","def t(self):\n return self._t","def t(self):\n return self._t","def line():\n tt.left(90)\n tt.down()\n tt.forward(50)\n tt.up()\n tt.right(90)\n tt.forward(10)\n tt.right(90)\n tt.forward(50)\n tt.left(90)","def get_tin(self):\n return self.tin[:]","def set_tr(self, x):\n x = float(x)\n if self.tr != x:\n self.tr = x","def line(value):\r\n return '({}, {}), ({}, {})'.format(value.x1(), value.y1(), value.x2(), value.y2())","def at(self, t):\n return self.start + (self.end - self.start) * t","def make_t(self):\n self.img[1, 1:-1] = 1\n self.img[2:-1, self.l_i / 2] = 1\n self.img_name = 'T'","def set_tlines(ty,slist):\r\n t = []\r\n for i in range(numpops-1):\r\n t.append([slist[5][4][i][1],slist[5][4][i][2],slist[5][4][i][3]]) ## [time, upper ci, lower ci]\r\n ty = []\r\n if gv[\"localyscale\"] == -1:\r\n yint = gv[\"line0y\"] - gv[\"lastt_lower_y\"]\r\n for i in range(numpops-1):\r\n ty.append([])\r\n if gv[\"eventimes\"] == False:\r\n tmax = slist[5][4][numpops-2][3] ## bottom of confidence interval of largest(oldest) t\r\n for j in range(3):\r\n ty[i].append(gv[\"line0y\"] - (t[i][j]*yint)/tmax)\r\n else:\r\n## ty[i].append(gv[\"line0y\"] - ((i+1)/float(numpops+1)*yint)/tmax)\r\n ty[i].append(gv[\"line0y\"] - yint * (i+1)/float(numpops) )\r\n else:\r\n timeumean = slist[7][4][1]\r\n scaleumean = slist[7][4][2]\r\n for i in range(numpops-1):\r\n ty.append([])\r\n for j in range(3):\r\n ty[i].append(gv[\"line0y\"] - (t[i][j] * (scaleumean/timeumean/1e6)* gv[\"localyscale\"]))\r\n if ty[i][j] < gv[\"lineINFy\"]:\r\n print ( \" time line too low in graph, reduce local y scale (-y value) \")\r\n gv[\"lastt_lower_y\"] = ty[numpops-2][2]\r\n## print \"ty : \",ty\r\n return ty","def letra_tiempo(self):\n return self.letra, self.tiempo","def set_tin(self, tin):\n self.tin = tin[:]","def tangeant(self, t, length):\n a = self.a0 + t * self.da\n ca = cos(a)\n sa = sin(a)\n p = self.c + Vector((self.r * ca, self.r * sa))\n v = Vector((length * sa, -length * ca))\n if self.da > 0:\n v = -v\n return Line(p, v)","def create_time_line(self, axes, t, y, time_value, label):\n # don't create lines on the very left\n if time_value == t[-1]:\n return\n\n # create timeLine\n time_line = Line2D([time_value, time_value],\n [np.min(y), y[t.index(time_value)]],\n ls=self.line_style,\n c=self.line_color)\n axes.add_line(time_line)\n axes.text(time_value + self.spacing, self.label_posistions[self.label_counter], label, size=self.font_size)","def t(self, t):\n\n self._t = t","def setText(self, t):\n #self._state[0] = str(t)\n self._param.update()","def TE_TM_pol_to_lin(field):\n\n pass","def t_ICONST(t):\n return t","def set_T(self, T):\n self.T = T","def vertical_line(t, n):\n lt(t)\n fd(t,n)\n rt(t)","def t_fleche(t):\r\n ev=donne_evenement()\r\n type_ev=type_evenement(ev)\r\n if type_ev==\"Deplacement\":\r\n t=clic_x(ev)\r\n else:\r\n t=t\r\n return t","def escrever_trio_extenso(self, trio):\r\n saida = []\r\n\r\n if trio == '100':\r\n return 'cem'\r\n elif trio == '000':\r\n return 'zero'\r\n else:\r\n c, d, u = trio\r\n c, d, u = int(c), int(d), int(u)\r\n\r\n if c != 0:\r\n saida.append(self.trioextenso[3][c])\r\n if d == 1:\r\n saida.append(self.trioextenso[1][u])\r\n else:\r\n if d != 0:\r\n saida.append(self.trioextenso[2][d])\r\n if u != 0:\r\n saida.append(self.trioextenso[0][u])\r\n return ' e '.join(saida)","def proc_prev_ph_tpl(self, ft, nul_val): # TODO change to phoneme!!\n return (nul_val,) + getattr(self, ft)[:-1]","def __call__(self,t=0):\n\n return (self.g(t) if (t<self.tc) else self.itpr(t))","def trilha1(self, trilha1):\n self._trilha1 = trilha1","def _eval_td_t(self, t):\n\n # Shortcuts for more compact notation:\n\n St = self._trajectory[t].observation # evaluated state tuple (x, y)\n At = self._trajectory[t].action\n St_1 = self._trajectory[t+1].observation # next state tuple (x, y)\n Rt_1 = self._trajectory[t+1].reward # next step reward\n done = self._trajectory[t+1].done\n\n #\n # SARSA\n #\n if done:\n Tt = Rt_1\n else:\n At_1 = self._trajectory[t+1].action\n if At_1 is None:\n At_1 = self.policy.pick_action(St_1)\n Tt = Rt_1 + self._discount * self.Q.estimate(St_1, At_1) \n\n self.Q.train(St, At, Tt)","def horizontal_line(t,n, h):\n lt(t)\n pu(t)\n fd(t,h)\n pd(t)\n lt(t)\n fd(t,n)\n rt(t)","def value(self, *args):\n return _ida_hexrays.ccase_t_value(self, *args)","def trilha1(self):\n return self._trilha1","def vertPosT(self):\n return 5.47","def get_LT_TM_trafo(self, row):\r\n \r\n rot_LT_TM = Rotation.from_euler('XYZ',\r\n [row['measurement_rx'],\r\n row['measurement_ry'],\r\n row['measurement_rz']],\r\n degrees = True) \r\n trafo_LT_TM = np.identity(4)\r\n trafo_LT_TM[:3, :3] = rot_LT_TM.as_matrix()\r\n trafo_LT_TM[:3, 3] = [row['measurement_x'], row['measurement_y'], row['measurement_z']]\r\n return trafo_LT_TM","def setTd(self, Td):\r\n\t\tself.Td = Td\r\n\t\tself.label = \"standard_PID_Controller/Kp=%f, Ti=%f, Td=%f\" % (self.Kp, self.Ti, self.Td)","def proc_next_ph_tpl(self, ft, nul_val): # TODO change to phoneme!!\n return getattr(self, ft)[1:] + (nul_val,)","def table(self):\n return self.t","def lineTo(self, pt: Tuple[float, float]) -> None:\n raise NotImplementedError","def c( self , y , r , t ):\n \n u = self.trajectory.t2u( t )\n \n return u","def constructTimeLineItem(self):\n\t\treturn","def getvalue(self):\n if self._value:\n _d,_t=self._value.strip(' ').replace('\"', '').split(',')\n _d=_d.split('/')\n _t=_t.split(':')\n return '%s%s%sT%s%s%s'%(_d[0].zfill(4), _d[1].zfill(2), _d[2].zfill(2),\n _t[0].zfill(2), _t[1].zfill(2), _t[2].zfill(2))","def cool(self):\n self.t = self.t - 1","def line_param(point_a, point_b, t):\n new_point = point_a - point_b\n return point_b + t*new_point","def Ingresar(frm):\r\n #se asigna el valor de la variable seguir\r\n \r\n #se le pide al usuario que ingresa la altura\r\n posinicial=float(frm.txtposinicial.GetValue())\r\n #posinicial=raw_input(\"Ingrese la altura desde donde se va dejar caer (en metros): \")\r\n #se condiona para que solo permite ingresar numero positivos \r\n \r\n posinicial=float(posinicial)\r\n if posinicial>0:\r\n posinicial=posinicial+2\r\n return posinicial","def get_tr(self):\n return self.tr","def Ttl(self) -> int:","def Ttl(self) -> int:","def t(self):\n index = self.var_index()\n return self.var_data(index)","def format_line_lean(self):\n\t\tline = \"<tr>\\\n\t\t\t\t\t<td>\\\n\t\t\t\t\t\t<font size='2'>\" + self.tag + \"</font>\\\n\t\t\t\t\t</td>\\\n\t\t\t\t\t<td>\\\n\t\t\t\t\t\t<font size='2'>\" + self.value + \"</font>\\\n\t\t\t\t\t</td>\\\n\t\t\t\t</tr>\"\n\t\treturn line","def tlm_vals(self):\n raise NotImplementedError","def t2u( self , t ):\n \n # Default is a constant signal\n u = self.ubar\n \n return u","def CONST_INT(self, t):\n t.value = int(t.value)\n return t","def get_tl_cell(self):\n return self._tl_cell","def setState_TR(self, t, rho):\n self.setTemperature(t)\n self.setDensity(rho)","def draw_t(self):\r\n pen.forward(20)\r\n pen.left(90)\r\n pen.down()\r\n pen.forward(40)\r\n pen.right(90)\r\n pen.up()\r\n pen.forward(20)\r\n pen.down()\r\n pen.back(40)\r\n pen.up()\r\n pen.right(90)\r\n pen.forward(40)\r\n pen.left(90)\r\n pen.forward(50)","def set_T_lm(self):\n self.delta_T_lm_array = ( ((self.exh.T_outlet_array -\n self.cool.T_inlet_array) - (self.exh.T_inlet_array -\n self.cool.T_outlet_array)) / np.log((self.exh.T_outlet_array -\n self.cool.T_inlet_array) / (self.exh.T_inlet_array -\n self.cool.T_outlet_array)) )","def lerp(self, t):\n pass","def t_fleche2(t):\r\n ev=donne_evenement()\r\n type_ev=type_evenement(ev)\r\n if type_ev==\"Touche\":\r\n t=touche(ev)\r\n else:\r\n t=\"kek\"\r\n return t","def ti_func(self):\n return self.ti.val - self.calc_ti()","def set_tendency(self,t):\n\n if t is None:\n self.tendency=(1,1,1,1,1,1,1,1)\n else:\n self.tendency = t\n #a,b,c,d,e,f,g,h = self.tendency\n #self.possibility = sum(self.tendency)","def addTcline(self, line, temperature=None):\n self._checkfigure()\n ld = self._get_linedict(line)\n line = ld['line']\n if temperature is None:\n temperature = ld['Tc']\n color = line.get_c()\n axvl = self.axes.axvline(temperature, color=color, ls='--')\n # self.axvlines.append(axvl)\n ld['vlines'].append(axvl)","def AddTE(self, te):\n self._totalte += te","def txa(self):\n\n self.a = self.x\n self.set_zn(self.a)","def ttd_l_func(self):\n i2 = self.inl[1].to_flow()\n o1 = self.outl[0].to_flow()\n return (self.ttd_l.val - T_mix_ph(o1, T0=self.outl[0].T.val_SI) +\n T_mix_ph(i2, T0=self.inl[1].T.val_SI))","def make(value):\n if isinstance(value, Trit):\n return value\n elif isinstance(value, numbers.Real):\n if value == 0:\n return TRIT_ZERO\n elif value > 0:\n return TRIT_POS\n else:\n return TRIT_NEG\n elif value is None:\n return TRIT_ZERO\n\n text = str(value).strip()\n if text in INPUTS:\n return TRITS[INPUTS[text]]\n else:\n raise ValueError(\n \"Failed to parse {0!r} as a trit.\".format(value))","def setTi(self, Ti):\r\n\t\tself.Ti = Ti\r\n\t\tself.label = \"standard_PID_Controller/Kp=%f, Ti=%f, Td=%f\" % (self.Kp, self.Ti, self.Td)","def draw_T(self):\n for i in range(self.n):\n for j in range(self.m):\n t = self.T[i, j]\n if t != 0 and self.V[i, j] == 1:\n if len(self.images) > 0:\n self.draw_img(i, j, t)\n else:\n self.draw_text(i, j, str(t), BLACK)","def _get_table_val(val):\n text = val.text.strip()\n if val.br:\n val = \", \".join(text.split('\\r\\n'))\n elif val.sup:\n val = \"\".join(map(str, val.contents))\n elif NON_BREAK_SPACE in text:\n val = \", \".join(text.split(f' {NON_BREAK_SPACE} {NON_BREAK_SPACE} '))\n else:\n val = text\n\n return val","def Value(self) -> _n_0_t_14:","def step(self, value):\n super().step(value) # Keep this line, it triggers the parent class method.\n \n if self.soo1 > 0.5 and self.soo2> 0.5:\n\t\t\n self.mdot = self.mdot1 + self.mdot2\n self.Tout = (self.Tin1*self.mdot1 + self.Tin2*self.mdot2)/ max(1.,self.mdot)\t\n\n elif self.soo3 > 0.5 and self.soo4> 0.5:\t\n\n self.mdot = self.mdot3 + self.mdot4\n self.Tout = (self.Tin3*self.mdot3 + self.Tin4*self.mdot4)/ max(1.,self.mdot)\t\n\t\t\n else:\t\t\n\t\t\n if self.soo1 > 0.5:\n\t\t \n self.mdot = self.mdot1\n self.Tout = self.Tin1\n\t\t\t \n elif self.soo2> 0.5:\n\n self.mdot = self.mdot2\n self.Tout = self.Tin2\t\n\n elif self.soo3> 0.5:\n\n self.mdot = self.mdot3\n self.Tout = self.Tin3\n\n elif self.soo4> 0.5:\n\n self.mdot = max(1.,self.mdot4)\n self.Tout = self.Tin4\t\n else:\n self.mdot = 0.\n self.Tout = 20.","def _get_tb(I, nu, beam):\n from astropy import units as u\n return (1222.0*I/(nu**2*(beam.minor/1.0).to(u.arcsecond)*(beam.major/1.0).to(u.arcsecond))).value","def stepInput(self,t): \n delta_c = 10 * (math.pi/180) \n if t > 50:\n delta_c = 0\n \n u_control = np.array([delta_c],float) \n\n return u_control","def tay(self):\n\n self.y = self.a\n self.set_zn(self.y)","def get_th_values(self):\n return (\n float(self.data[2]) / 10,\n int(self.data[3]),\n float(self.data[4]) / 10,\n )","def _get_tr(cls, data):\n\t\tprev_close = data['close_-1_s']\n\t\thigh = data['high']\n\t\tlow = data['low']\n\t\tc1 = high - low\n\t\tc2 = np.abs(high - prev_close)\n\t\tc3 = np.abs(low - prev_close)\n\t\tdata['tr'] = np.max((c1, c2, c3), axis=0)","def travisplanet(p):\n # 2012-02-14 14:52 IJMC: Created\n\n vals1 = (p.name.replace(' ','').replace('b', ''), p.msini, p.umsini, p.r, p.r-p.ur, p.r+p.ur)\n vals2 = (p.per, p.a, p.mstar, p.umstar, p.rstar, p.urstar, p.teff, p.uteff, p.fe, p.ufe)\n nvals = len(vals1)+len(vals2)\n fstr = '%s' + ' '*(10-len(vals1)) + ' %1.2f'*5 + ' %1.6f %1.4f' + ' %1.2f'*4 + ' %i'*2 + ' %1.2f'*2\n\n return fstr % (vals1 + vals2 )","def get_tetromino(self):\n tetromino = random.randint(1, 8)\n if tetromino == self.previous_tetromino or tetromino == 8:\n tetromino = random.randint(1, 7)\n self.previous_tetromino = tetromino\n return Tetromino(tetromino, 5, 2, 0, TETROMINOES[tetromino - 1])","def __str__(self):\n\t\tif self.__valide:\n\t\t\treturn str(self.__tete)\n\t\telse:\n\t\t\treturn \"(polynome invalide)\"","def line(self) -> int:","def value(self):","def reemplaza_tildes(palabra):","def tr(self, tr):\n\n self._tr = tr","def position(t):\n return c + tangent_vec * 7 * t ** 2","def get_tr(data):\n if data is None:\n raise EmptyDataError('[!] Invalid data value')\n\n result = TA.TR(data)\n if result is None:\n raise IndicatorException\n return result","def setup(self, i, t):\n \n self.t = t\n return i","def calc_value(exp, t_new):\n t = Symbol('t')\n return exp.evalf(subs={t: t_new})","def GetTRange(self):\n ...","def value(self, grid):\n pass","def test_set_vT(self):\n s = State(substance=\"water\")\n s.vT = Q_(1.801983936953226, \"m**3/kg\"), Q_(400.0, \"K\")\n # Pylance does not support NumPy ufuncs\n assert np.isclose(s.T, Q_(400.0, \"K\")) # type: ignore\n assert np.isclose(s.p, Q_(101325.0, \"Pa\")) # type: ignore\n assert np.isclose(s.vT[1], Q_(400.0, \"K\")) # type: ignore\n assert np.isclose(s.vT[0], Q_(1.801983936953226, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.u, Q_(2547715.3635084038, \"J/kg\")) # type: ignore\n assert np.isclose(s.s, Q_(7496.2021523754065, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.cp, Q_(2009.2902478486988, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.cv, Q_(1509.1482452129906, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.v, Q_(1.801983936953226, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.h, Q_(2730301.3859201893, \"J/kg\")) # type: ignore\n assert s.x is None","def acumula_t1(self, t1, rodada):\n self.t1[rodada].append(t1)","def T_i(self, value: u.K):\n if value is None:\n self._T_i = np.repeat(self._T_e, self._number_of_particles)\n return\n\n if value.size == 1:\n self._T_i = np.repeat(value, self._number_of_particles)\n elif value.size == self._number_of_particles:\n self._T_i = value\n else:\n error_str = (\n \"T_i must be set with either one common temperature\"\n f\" for all ions, or a set of {self._number_of_particles} of them. \"\n )\n\n if value.size == 5 and self._number_of_particles != 5:\n error_str += f\" For {self.base_particle}, five is right out.\"\n raise ParticleError(error_str)","def tya(self):\n\n self.a = self.y\n self.set_zn(self.a)","def t(self, t):\n if self.local_vars_configuration.client_side_validation and t is None: # noqa: E501\n raise ValueError(\"Invalid value for `t`, must not be `None`\") # noqa: E501\n\n self._t = t","def addTN(self, num=1):\n self.tn += num","def test_tlabel(self):\n fig = plt.figure()\n ax = fig.add_subplot(projection='ternary')\n label = \"T\"\n ax.set_tlabel(label)\n assert ax.get_tlabel() == label","def Value(self) -> str:","def setLine1(self, value):\n self.lcd.lcd_string(value, self.lcd.LCD_LINE_1)\n self.line1 = value","def is_tr(self, y, t):\n return t != 0 and y != 0"],"string":"[\n \"def get_t(self):\\n return self.t\",\n \"def get_t_value(self):\\n return float(self.data[2]) / 10\",\n \"def Temp(t):\\n return 20 # Need to link to data\",\n \"def value(t):\\r\\n return t(0)\",\n \"def lin_pol_to_TE_TM(field):\\n\\n pass\",\n \"def __str__(self):\\n return str(self.t1)+\\\"<-->t1, \\\\t\\\"+str(self.t2)+\\\"<-->t2, \\\\t\\\"+str(self.phi)+\\\"<-->phi, \\\\t\\\"+str(self.m)+\\\"<-->m, \\\\t\\\"+str(self.t31)+\\\"<-->t31, \\\\t\\\"+str(self.t32)+\\\"<-->t32, \\\\n\\\"\",\n \"def t(self):\\n return self._t\",\n \"def t(self):\\n return self._t\",\n \"def line():\\n tt.left(90)\\n tt.down()\\n tt.forward(50)\\n tt.up()\\n tt.right(90)\\n tt.forward(10)\\n tt.right(90)\\n tt.forward(50)\\n tt.left(90)\",\n \"def get_tin(self):\\n return self.tin[:]\",\n \"def set_tr(self, x):\\n x = float(x)\\n if self.tr != x:\\n self.tr = x\",\n \"def line(value):\\r\\n return '({}, {}), ({}, {})'.format(value.x1(), value.y1(), value.x2(), value.y2())\",\n \"def at(self, t):\\n return self.start + (self.end - self.start) * t\",\n \"def make_t(self):\\n self.img[1, 1:-1] = 1\\n self.img[2:-1, self.l_i / 2] = 1\\n self.img_name = 'T'\",\n \"def set_tlines(ty,slist):\\r\\n t = []\\r\\n for i in range(numpops-1):\\r\\n t.append([slist[5][4][i][1],slist[5][4][i][2],slist[5][4][i][3]]) ## [time, upper ci, lower ci]\\r\\n ty = []\\r\\n if gv[\\\"localyscale\\\"] == -1:\\r\\n yint = gv[\\\"line0y\\\"] - gv[\\\"lastt_lower_y\\\"]\\r\\n for i in range(numpops-1):\\r\\n ty.append([])\\r\\n if gv[\\\"eventimes\\\"] == False:\\r\\n tmax = slist[5][4][numpops-2][3] ## bottom of confidence interval of largest(oldest) t\\r\\n for j in range(3):\\r\\n ty[i].append(gv[\\\"line0y\\\"] - (t[i][j]*yint)/tmax)\\r\\n else:\\r\\n## ty[i].append(gv[\\\"line0y\\\"] - ((i+1)/float(numpops+1)*yint)/tmax)\\r\\n ty[i].append(gv[\\\"line0y\\\"] - yint * (i+1)/float(numpops) )\\r\\n else:\\r\\n timeumean = slist[7][4][1]\\r\\n scaleumean = slist[7][4][2]\\r\\n for i in range(numpops-1):\\r\\n ty.append([])\\r\\n for j in range(3):\\r\\n ty[i].append(gv[\\\"line0y\\\"] - (t[i][j] * (scaleumean/timeumean/1e6)* gv[\\\"localyscale\\\"]))\\r\\n if ty[i][j] < gv[\\\"lineINFy\\\"]:\\r\\n print ( \\\" time line too low in graph, reduce local y scale (-y value) \\\")\\r\\n gv[\\\"lastt_lower_y\\\"] = ty[numpops-2][2]\\r\\n## print \\\"ty : \\\",ty\\r\\n return ty\",\n \"def letra_tiempo(self):\\n return self.letra, self.tiempo\",\n \"def set_tin(self, tin):\\n self.tin = tin[:]\",\n \"def tangeant(self, t, length):\\n a = self.a0 + t * self.da\\n ca = cos(a)\\n sa = sin(a)\\n p = self.c + Vector((self.r * ca, self.r * sa))\\n v = Vector((length * sa, -length * ca))\\n if self.da > 0:\\n v = -v\\n return Line(p, v)\",\n \"def create_time_line(self, axes, t, y, time_value, label):\\n # don't create lines on the very left\\n if time_value == t[-1]:\\n return\\n\\n # create timeLine\\n time_line = Line2D([time_value, time_value],\\n [np.min(y), y[t.index(time_value)]],\\n ls=self.line_style,\\n c=self.line_color)\\n axes.add_line(time_line)\\n axes.text(time_value + self.spacing, self.label_posistions[self.label_counter], label, size=self.font_size)\",\n \"def t(self, t):\\n\\n self._t = t\",\n \"def setText(self, t):\\n #self._state[0] = str(t)\\n self._param.update()\",\n \"def TE_TM_pol_to_lin(field):\\n\\n pass\",\n \"def t_ICONST(t):\\n return t\",\n \"def set_T(self, T):\\n self.T = T\",\n \"def vertical_line(t, n):\\n lt(t)\\n fd(t,n)\\n rt(t)\",\n \"def t_fleche(t):\\r\\n ev=donne_evenement()\\r\\n type_ev=type_evenement(ev)\\r\\n if type_ev==\\\"Deplacement\\\":\\r\\n t=clic_x(ev)\\r\\n else:\\r\\n t=t\\r\\n return t\",\n \"def escrever_trio_extenso(self, trio):\\r\\n saida = []\\r\\n\\r\\n if trio == '100':\\r\\n return 'cem'\\r\\n elif trio == '000':\\r\\n return 'zero'\\r\\n else:\\r\\n c, d, u = trio\\r\\n c, d, u = int(c), int(d), int(u)\\r\\n\\r\\n if c != 0:\\r\\n saida.append(self.trioextenso[3][c])\\r\\n if d == 1:\\r\\n saida.append(self.trioextenso[1][u])\\r\\n else:\\r\\n if d != 0:\\r\\n saida.append(self.trioextenso[2][d])\\r\\n if u != 0:\\r\\n saida.append(self.trioextenso[0][u])\\r\\n return ' e '.join(saida)\",\n \"def proc_prev_ph_tpl(self, ft, nul_val): # TODO change to phoneme!!\\n return (nul_val,) + getattr(self, ft)[:-1]\",\n \"def __call__(self,t=0):\\n\\n return (self.g(t) if (t<self.tc) else self.itpr(t))\",\n \"def trilha1(self, trilha1):\\n self._trilha1 = trilha1\",\n \"def _eval_td_t(self, t):\\n\\n # Shortcuts for more compact notation:\\n\\n St = self._trajectory[t].observation # evaluated state tuple (x, y)\\n At = self._trajectory[t].action\\n St_1 = self._trajectory[t+1].observation # next state tuple (x, y)\\n Rt_1 = self._trajectory[t+1].reward # next step reward\\n done = self._trajectory[t+1].done\\n\\n #\\n # SARSA\\n #\\n if done:\\n Tt = Rt_1\\n else:\\n At_1 = self._trajectory[t+1].action\\n if At_1 is None:\\n At_1 = self.policy.pick_action(St_1)\\n Tt = Rt_1 + self._discount * self.Q.estimate(St_1, At_1) \\n\\n self.Q.train(St, At, Tt)\",\n \"def horizontal_line(t,n, h):\\n lt(t)\\n pu(t)\\n fd(t,h)\\n pd(t)\\n lt(t)\\n fd(t,n)\\n rt(t)\",\n \"def value(self, *args):\\n return _ida_hexrays.ccase_t_value(self, *args)\",\n \"def trilha1(self):\\n return self._trilha1\",\n \"def vertPosT(self):\\n return 5.47\",\n \"def get_LT_TM_trafo(self, row):\\r\\n \\r\\n rot_LT_TM = Rotation.from_euler('XYZ',\\r\\n [row['measurement_rx'],\\r\\n row['measurement_ry'],\\r\\n row['measurement_rz']],\\r\\n degrees = True) \\r\\n trafo_LT_TM = np.identity(4)\\r\\n trafo_LT_TM[:3, :3] = rot_LT_TM.as_matrix()\\r\\n trafo_LT_TM[:3, 3] = [row['measurement_x'], row['measurement_y'], row['measurement_z']]\\r\\n return trafo_LT_TM\",\n \"def setTd(self, Td):\\r\\n\\t\\tself.Td = Td\\r\\n\\t\\tself.label = \\\"standard_PID_Controller/Kp=%f, Ti=%f, Td=%f\\\" % (self.Kp, self.Ti, self.Td)\",\n \"def proc_next_ph_tpl(self, ft, nul_val): # TODO change to phoneme!!\\n return getattr(self, ft)[1:] + (nul_val,)\",\n \"def table(self):\\n return self.t\",\n \"def lineTo(self, pt: Tuple[float, float]) -> None:\\n raise NotImplementedError\",\n \"def c( self , y , r , t ):\\n \\n u = self.trajectory.t2u( t )\\n \\n return u\",\n \"def constructTimeLineItem(self):\\n\\t\\treturn\",\n \"def getvalue(self):\\n if self._value:\\n _d,_t=self._value.strip(' ').replace('\\\"', '').split(',')\\n _d=_d.split('/')\\n _t=_t.split(':')\\n return '%s%s%sT%s%s%s'%(_d[0].zfill(4), _d[1].zfill(2), _d[2].zfill(2),\\n _t[0].zfill(2), _t[1].zfill(2), _t[2].zfill(2))\",\n \"def cool(self):\\n self.t = self.t - 1\",\n \"def line_param(point_a, point_b, t):\\n new_point = point_a - point_b\\n return point_b + t*new_point\",\n \"def Ingresar(frm):\\r\\n #se asigna el valor de la variable seguir\\r\\n \\r\\n #se le pide al usuario que ingresa la altura\\r\\n posinicial=float(frm.txtposinicial.GetValue())\\r\\n #posinicial=raw_input(\\\"Ingrese la altura desde donde se va dejar caer (en metros): \\\")\\r\\n #se condiona para que solo permite ingresar numero positivos \\r\\n \\r\\n posinicial=float(posinicial)\\r\\n if posinicial>0:\\r\\n posinicial=posinicial+2\\r\\n return posinicial\",\n \"def get_tr(self):\\n return self.tr\",\n \"def Ttl(self) -> int:\",\n \"def Ttl(self) -> int:\",\n \"def t(self):\\n index = self.var_index()\\n return self.var_data(index)\",\n \"def format_line_lean(self):\\n\\t\\tline = \\\"<tr>\\\\\\n\\t\\t\\t\\t\\t<td>\\\\\\n\\t\\t\\t\\t\\t\\t<font size='2'>\\\" + self.tag + \\\"</font>\\\\\\n\\t\\t\\t\\t\\t</td>\\\\\\n\\t\\t\\t\\t\\t<td>\\\\\\n\\t\\t\\t\\t\\t\\t<font size='2'>\\\" + self.value + \\\"</font>\\\\\\n\\t\\t\\t\\t\\t</td>\\\\\\n\\t\\t\\t\\t</tr>\\\"\\n\\t\\treturn line\",\n \"def tlm_vals(self):\\n raise NotImplementedError\",\n \"def t2u( self , t ):\\n \\n # Default is a constant signal\\n u = self.ubar\\n \\n return u\",\n \"def CONST_INT(self, t):\\n t.value = int(t.value)\\n return t\",\n \"def get_tl_cell(self):\\n return self._tl_cell\",\n \"def setState_TR(self, t, rho):\\n self.setTemperature(t)\\n self.setDensity(rho)\",\n \"def draw_t(self):\\r\\n pen.forward(20)\\r\\n pen.left(90)\\r\\n pen.down()\\r\\n pen.forward(40)\\r\\n pen.right(90)\\r\\n pen.up()\\r\\n pen.forward(20)\\r\\n pen.down()\\r\\n pen.back(40)\\r\\n pen.up()\\r\\n pen.right(90)\\r\\n pen.forward(40)\\r\\n pen.left(90)\\r\\n pen.forward(50)\",\n \"def set_T_lm(self):\\n self.delta_T_lm_array = ( ((self.exh.T_outlet_array -\\n self.cool.T_inlet_array) - (self.exh.T_inlet_array -\\n self.cool.T_outlet_array)) / np.log((self.exh.T_outlet_array -\\n self.cool.T_inlet_array) / (self.exh.T_inlet_array -\\n self.cool.T_outlet_array)) )\",\n \"def lerp(self, t):\\n pass\",\n \"def t_fleche2(t):\\r\\n ev=donne_evenement()\\r\\n type_ev=type_evenement(ev)\\r\\n if type_ev==\\\"Touche\\\":\\r\\n t=touche(ev)\\r\\n else:\\r\\n t=\\\"kek\\\"\\r\\n return t\",\n \"def ti_func(self):\\n return self.ti.val - self.calc_ti()\",\n \"def set_tendency(self,t):\\n\\n if t is None:\\n self.tendency=(1,1,1,1,1,1,1,1)\\n else:\\n self.tendency = t\\n #a,b,c,d,e,f,g,h = self.tendency\\n #self.possibility = sum(self.tendency)\",\n \"def addTcline(self, line, temperature=None):\\n self._checkfigure()\\n ld = self._get_linedict(line)\\n line = ld['line']\\n if temperature is None:\\n temperature = ld['Tc']\\n color = line.get_c()\\n axvl = self.axes.axvline(temperature, color=color, ls='--')\\n # self.axvlines.append(axvl)\\n ld['vlines'].append(axvl)\",\n \"def AddTE(self, te):\\n self._totalte += te\",\n \"def txa(self):\\n\\n self.a = self.x\\n self.set_zn(self.a)\",\n \"def ttd_l_func(self):\\n i2 = self.inl[1].to_flow()\\n o1 = self.outl[0].to_flow()\\n return (self.ttd_l.val - T_mix_ph(o1, T0=self.outl[0].T.val_SI) +\\n T_mix_ph(i2, T0=self.inl[1].T.val_SI))\",\n \"def make(value):\\n if isinstance(value, Trit):\\n return value\\n elif isinstance(value, numbers.Real):\\n if value == 0:\\n return TRIT_ZERO\\n elif value > 0:\\n return TRIT_POS\\n else:\\n return TRIT_NEG\\n elif value is None:\\n return TRIT_ZERO\\n\\n text = str(value).strip()\\n if text in INPUTS:\\n return TRITS[INPUTS[text]]\\n else:\\n raise ValueError(\\n \\\"Failed to parse {0!r} as a trit.\\\".format(value))\",\n \"def setTi(self, Ti):\\r\\n\\t\\tself.Ti = Ti\\r\\n\\t\\tself.label = \\\"standard_PID_Controller/Kp=%f, Ti=%f, Td=%f\\\" % (self.Kp, self.Ti, self.Td)\",\n \"def draw_T(self):\\n for i in range(self.n):\\n for j in range(self.m):\\n t = self.T[i, j]\\n if t != 0 and self.V[i, j] == 1:\\n if len(self.images) > 0:\\n self.draw_img(i, j, t)\\n else:\\n self.draw_text(i, j, str(t), BLACK)\",\n \"def _get_table_val(val):\\n text = val.text.strip()\\n if val.br:\\n val = \\\", \\\".join(text.split('\\\\r\\\\n'))\\n elif val.sup:\\n val = \\\"\\\".join(map(str, val.contents))\\n elif NON_BREAK_SPACE in text:\\n val = \\\", \\\".join(text.split(f' {NON_BREAK_SPACE} {NON_BREAK_SPACE} '))\\n else:\\n val = text\\n\\n return val\",\n \"def Value(self) -> _n_0_t_14:\",\n \"def step(self, value):\\n super().step(value) # Keep this line, it triggers the parent class method.\\n \\n if self.soo1 > 0.5 and self.soo2> 0.5:\\n\\t\\t\\n self.mdot = self.mdot1 + self.mdot2\\n self.Tout = (self.Tin1*self.mdot1 + self.Tin2*self.mdot2)/ max(1.,self.mdot)\\t\\n\\n elif self.soo3 > 0.5 and self.soo4> 0.5:\\t\\n\\n self.mdot = self.mdot3 + self.mdot4\\n self.Tout = (self.Tin3*self.mdot3 + self.Tin4*self.mdot4)/ max(1.,self.mdot)\\t\\n\\t\\t\\n else:\\t\\t\\n\\t\\t\\n if self.soo1 > 0.5:\\n\\t\\t \\n self.mdot = self.mdot1\\n self.Tout = self.Tin1\\n\\t\\t\\t \\n elif self.soo2> 0.5:\\n\\n self.mdot = self.mdot2\\n self.Tout = self.Tin2\\t\\n\\n elif self.soo3> 0.5:\\n\\n self.mdot = self.mdot3\\n self.Tout = self.Tin3\\n\\n elif self.soo4> 0.5:\\n\\n self.mdot = max(1.,self.mdot4)\\n self.Tout = self.Tin4\\t\\n else:\\n self.mdot = 0.\\n self.Tout = 20.\",\n \"def _get_tb(I, nu, beam):\\n from astropy import units as u\\n return (1222.0*I/(nu**2*(beam.minor/1.0).to(u.arcsecond)*(beam.major/1.0).to(u.arcsecond))).value\",\n \"def stepInput(self,t): \\n delta_c = 10 * (math.pi/180) \\n if t > 50:\\n delta_c = 0\\n \\n u_control = np.array([delta_c],float) \\n\\n return u_control\",\n \"def tay(self):\\n\\n self.y = self.a\\n self.set_zn(self.y)\",\n \"def get_th_values(self):\\n return (\\n float(self.data[2]) / 10,\\n int(self.data[3]),\\n float(self.data[4]) / 10,\\n )\",\n \"def _get_tr(cls, data):\\n\\t\\tprev_close = data['close_-1_s']\\n\\t\\thigh = data['high']\\n\\t\\tlow = data['low']\\n\\t\\tc1 = high - low\\n\\t\\tc2 = np.abs(high - prev_close)\\n\\t\\tc3 = np.abs(low - prev_close)\\n\\t\\tdata['tr'] = np.max((c1, c2, c3), axis=0)\",\n \"def travisplanet(p):\\n # 2012-02-14 14:52 IJMC: Created\\n\\n vals1 = (p.name.replace(' ','').replace('b', ''), p.msini, p.umsini, p.r, p.r-p.ur, p.r+p.ur)\\n vals2 = (p.per, p.a, p.mstar, p.umstar, p.rstar, p.urstar, p.teff, p.uteff, p.fe, p.ufe)\\n nvals = len(vals1)+len(vals2)\\n fstr = '%s' + ' '*(10-len(vals1)) + ' %1.2f'*5 + ' %1.6f %1.4f' + ' %1.2f'*4 + ' %i'*2 + ' %1.2f'*2\\n\\n return fstr % (vals1 + vals2 )\",\n \"def get_tetromino(self):\\n tetromino = random.randint(1, 8)\\n if tetromino == self.previous_tetromino or tetromino == 8:\\n tetromino = random.randint(1, 7)\\n self.previous_tetromino = tetromino\\n return Tetromino(tetromino, 5, 2, 0, TETROMINOES[tetromino - 1])\",\n \"def __str__(self):\\n\\t\\tif self.__valide:\\n\\t\\t\\treturn str(self.__tete)\\n\\t\\telse:\\n\\t\\t\\treturn \\\"(polynome invalide)\\\"\",\n \"def line(self) -> int:\",\n \"def value(self):\",\n \"def reemplaza_tildes(palabra):\",\n \"def tr(self, tr):\\n\\n self._tr = tr\",\n \"def position(t):\\n return c + tangent_vec * 7 * t ** 2\",\n \"def get_tr(data):\\n if data is None:\\n raise EmptyDataError('[!] Invalid data value')\\n\\n result = TA.TR(data)\\n if result is None:\\n raise IndicatorException\\n return result\",\n \"def setup(self, i, t):\\n \\n self.t = t\\n return i\",\n \"def calc_value(exp, t_new):\\n t = Symbol('t')\\n return exp.evalf(subs={t: t_new})\",\n \"def GetTRange(self):\\n ...\",\n \"def value(self, grid):\\n pass\",\n \"def test_set_vT(self):\\n s = State(substance=\\\"water\\\")\\n s.vT = Q_(1.801983936953226, \\\"m**3/kg\\\"), Q_(400.0, \\\"K\\\")\\n # Pylance does not support NumPy ufuncs\\n assert np.isclose(s.T, Q_(400.0, \\\"K\\\")) # type: ignore\\n assert np.isclose(s.p, Q_(101325.0, \\\"Pa\\\")) # type: ignore\\n assert np.isclose(s.vT[1], Q_(400.0, \\\"K\\\")) # type: ignore\\n assert np.isclose(s.vT[0], Q_(1.801983936953226, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.u, Q_(2547715.3635084038, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.s, Q_(7496.2021523754065, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.cp, Q_(2009.2902478486988, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.cv, Q_(1509.1482452129906, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.v, Q_(1.801983936953226, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.h, Q_(2730301.3859201893, \\\"J/kg\\\")) # type: ignore\\n assert s.x is None\",\n \"def acumula_t1(self, t1, rodada):\\n self.t1[rodada].append(t1)\",\n \"def T_i(self, value: u.K):\\n if value is None:\\n self._T_i = np.repeat(self._T_e, self._number_of_particles)\\n return\\n\\n if value.size == 1:\\n self._T_i = np.repeat(value, self._number_of_particles)\\n elif value.size == self._number_of_particles:\\n self._T_i = value\\n else:\\n error_str = (\\n \\\"T_i must be set with either one common temperature\\\"\\n f\\\" for all ions, or a set of {self._number_of_particles} of them. \\\"\\n )\\n\\n if value.size == 5 and self._number_of_particles != 5:\\n error_str += f\\\" For {self.base_particle}, five is right out.\\\"\\n raise ParticleError(error_str)\",\n \"def tya(self):\\n\\n self.a = self.y\\n self.set_zn(self.a)\",\n \"def t(self, t):\\n if self.local_vars_configuration.client_side_validation and t is None: # noqa: E501\\n raise ValueError(\\\"Invalid value for `t`, must not be `None`\\\") # noqa: E501\\n\\n self._t = t\",\n \"def addTN(self, num=1):\\n self.tn += num\",\n \"def test_tlabel(self):\\n fig = plt.figure()\\n ax = fig.add_subplot(projection='ternary')\\n label = \\\"T\\\"\\n ax.set_tlabel(label)\\n assert ax.get_tlabel() == label\",\n \"def Value(self) -> str:\",\n \"def setLine1(self, value):\\n self.lcd.lcd_string(value, self.lcd.LCD_LINE_1)\\n self.line1 = value\",\n \"def is_tr(self, y, t):\\n return t != 0 and y != 0\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59880507","0.5949386","0.58090144","0.57953244","0.5758886","0.57477516","0.5688287","0.5688287","0.56690115","0.563481","0.5611574","0.5603627","0.5531453","0.5472372","0.5468471","0.5451955","0.5434617","0.54339397","0.543298","0.5397063","0.5372944","0.5351336","0.5324761","0.5320657","0.5293512","0.5281389","0.5261982","0.526055","0.5238896","0.52339894","0.5195476","0.51848257","0.5182441","0.5182392","0.517387","0.5169613","0.5151585","0.5149241","0.5130261","0.51102155","0.5108986","0.50946164","0.50919986","0.50896436","0.5060216","0.50586146","0.5043355","0.50426334","0.50426334","0.50403994","0.5018094","0.50140786","0.5010853","0.5010687","0.5008401","0.5006309","0.49946293","0.4994587","0.49941847","0.49929708","0.49900162","0.4984691","0.49736586","0.4972127","0.49711773","0.49685854","0.49631536","0.49562228","0.49476582","0.4946868","0.494387","0.49372888","0.4936924","0.49352583","0.4932841","0.49261072","0.4924288","0.49209493","0.49174267","0.4910948","0.49099097","0.49086857","0.4905581","0.49024138","0.48946193","0.48930004","0.48921865","0.489193","0.4890185","0.4889165","0.4888072","0.48832044","0.48812914","0.4879244","0.48733103","0.48711514","0.4861099","0.48583528","0.48577452","0.48501658"],"string":"[\n \"0.59880507\",\n \"0.5949386\",\n \"0.58090144\",\n \"0.57953244\",\n \"0.5758886\",\n \"0.57477516\",\n \"0.5688287\",\n \"0.5688287\",\n \"0.56690115\",\n \"0.563481\",\n \"0.5611574\",\n \"0.5603627\",\n \"0.5531453\",\n \"0.5472372\",\n \"0.5468471\",\n \"0.5451955\",\n \"0.5434617\",\n \"0.54339397\",\n \"0.543298\",\n \"0.5397063\",\n \"0.5372944\",\n \"0.5351336\",\n \"0.5324761\",\n \"0.5320657\",\n \"0.5293512\",\n \"0.5281389\",\n \"0.5261982\",\n \"0.526055\",\n \"0.5238896\",\n \"0.52339894\",\n \"0.5195476\",\n \"0.51848257\",\n \"0.5182441\",\n \"0.5182392\",\n \"0.517387\",\n \"0.5169613\",\n \"0.5151585\",\n \"0.5149241\",\n \"0.5130261\",\n \"0.51102155\",\n \"0.5108986\",\n \"0.50946164\",\n \"0.50919986\",\n \"0.50896436\",\n \"0.5060216\",\n \"0.50586146\",\n \"0.5043355\",\n \"0.50426334\",\n \"0.50426334\",\n \"0.50403994\",\n \"0.5018094\",\n \"0.50140786\",\n \"0.5010853\",\n \"0.5010687\",\n \"0.5008401\",\n \"0.5006309\",\n \"0.49946293\",\n \"0.4994587\",\n \"0.49941847\",\n \"0.49929708\",\n \"0.49900162\",\n \"0.4984691\",\n \"0.49736586\",\n \"0.4972127\",\n \"0.49711773\",\n \"0.49685854\",\n \"0.49631536\",\n \"0.49562228\",\n \"0.49476582\",\n \"0.4946868\",\n \"0.494387\",\n \"0.49372888\",\n \"0.4936924\",\n \"0.49352583\",\n \"0.4932841\",\n \"0.49261072\",\n \"0.4924288\",\n \"0.49209493\",\n \"0.49174267\",\n \"0.4910948\",\n \"0.49099097\",\n \"0.49086857\",\n \"0.4905581\",\n \"0.49024138\",\n \"0.48946193\",\n \"0.48930004\",\n \"0.48921865\",\n \"0.489193\",\n \"0.4890185\",\n \"0.4889165\",\n \"0.4888072\",\n \"0.48832044\",\n \"0.48812914\",\n \"0.4879244\",\n \"0.48733103\",\n \"0.48711514\",\n \"0.4861099\",\n \"0.48583528\",\n \"0.48577452\",\n \"0.48501658\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5732259"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":79084,"cells":{"query":{"kind":"string","value":"Arranca el reloj, si ya estaba arrancado no pasa nada."},"document":{"kind":"string","value":"def arranca(self):\n \n if self.t0 == None:\n self.t0 = self.timeFunc()\n self.funciona = True\n if not self.funciona:\n self.retraso += self.timeFunc() - self.parada\n self.funciona = True"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def array(self):","def __init__(self,array):\n self.arr = array\n # self.result = []","def __init__(self):\n self.arr = []","def __init__(self):\n self.arr = []","def __init__(self):\n self.arr = []","def __init__(self):\n self.arr = []","def abrir(self):\n assert self.open == False\n self.ne = [n for n in self.ne]\n self.je = [e1 for e1 in self.je]\n self.ie = []\n self.open = True","def _make_result_list(self,res):\n res_list = []\n for r in res:\n res_list.append(r)\n\n return res_list","def __init__(self, id, padre, hijos):\n\n self.__id = id\n self.__padre = padre\n self.__hijos = np.array([])\n for i in range(len(hijos)):\n newHijos = np.delete(hijos,i,0)#Se remueve el nodo de la lista una vez recorrido\n self.__hijos = np.append(self.__hijos, NodoCiudad(hijos[i],self,newHijos))","def __init__(self, bolsa,letras=[]):\n self.atril = []\n self.bolsa = bolsa\n if letras == []:\n self.initialize()\n else:\n self.cargar_atril(letras,bolsa)","def reiniciarMatrix(self):\n self.matrixMAPA = []\n self.rellenarMatrix()","def __radd__(self, left_arr):\n concat_arr = left_arr.copy() # Create new instance to return\n concat_arr.extend(self)\n return concat_arr","def arredondar(self):\n for y in range(self.altura):\n for x in range(self.largura):\n for i in range(3):\n self.lista[x][y][i] = int(self.lista[x][y][i])","def __init__(self, arr=None):\n self.data = arr.copy() if arr else []","def preencherJogadores():\n global jogadores\n for x in participantes:\n if x['porta'] != lider['porta']:\n jogadores.append(x)","def rellenar_atril(self):\n while self.get_atril_espaciosVacios() > 0 and self.bolsa.cantidad_Fichas() > 0:\n self.agregar_al_atril()","def __init__(self):\n mi_parqueo = list()","def arr(self):\n return self._arr","def flag(self, arr):\n return arr","def __init__(self):\n self.arr = []\n self.size = 0","def AgregarCara(Cara,*J):\n\tJugador=[]\n\tfor x in J:\n\t Jugador.append(x)\n\t\n\tif Cara == 1 and Disponibles[0] == True:\n\t\tJugador[0] = Jugador[0] + 1\n\t\t#e=Jugador[0]\n\t\t#Jugador[0]=e+1\n\telse:\n\t\tif Cara == 2 and Disponibles[1] == True:\n\t\t\tJugador[1] = Jugador[1] + 1\n\t\t\t#e=Jugador[1]\n\t\t\t#Jugador[1]=e + 1\n\t\telse:\n\t\t\tif Cara == 3 and Disponibles[2] == True:\n\t\t\t\tJugador[2] = Jugador[2] + 1\n\t\t\t\t#e=Jugador[2]\n\t\t\t\t#Jugador[2]=e + 1\n\t\t\telse:\n\t\t\t\tif Cara == 4 and Disponibles[3] == True:\n\t\t\t\t\tJugador[3] = Jugador[3] + 1\n\t\t\t\t\t#e=Jugador[3]\n\t\t\t\t\t#Jugador[3]=e + 1\n\t\t\t\telse:\n\t\t\t\t\tif Cara == 5 and Disponibles[4] == True:\n\t\t\t\t\t\tJugador[4] = Jugador[4] + 1\n\t\t\t\t\t\t#e=Jugador[4]\n\t\t\t\t\t\t#Jugador[4]=e + 1\n\t\t\t\t\telse:\n\t\t\t\t\t\tif Cara == 6 and Disponibles[5] == True:\n\t\t\t\t\t\t\tJugador[5] = Jugador[5] + 1\n\t\t\t\t\t\t\t#e=Jugador[5]\n\t\t\t\t\t\t\t#Jugador[5]=e + 1\n\treturn Jugador","def __init__(self):\n self._data=[]","def __init__(self):\n self.l = []\n self.r = []","def asArray(self):\n\n # Caching is evil, Loomis. Don't do that.\n if not hasattr(self, 'array'):\n self.sealArray()\n return self.recarray","def toArray(self, *args):\n pass","def abrir(self):\n self.x0 = [val for val in self.x0]\n self.x = [val for val in self.x]\n self.tipos = [val for val in self.tipos]\n self.mask_fr = [val for val in self.mask_fr]\n self.mask_in = [val for val in self.mask_in]\n self.open = True","def __init__(self):\n\n self.notas = []","def __add__(self, right_arr):\n concat_arr = self.copy() # Create new instance to return\n concat_arr.extend(right_arr)\n return concat_arr","def apilar(self,dato):\r\n\t\tself.elementos.append(dato)\r\n\t\tself.len += 1","def pq_to_array(pq, target):\r\n temp = None\r\n \r\n while pq.is_empty() == False:\r\n temp = pq.remove()\r\n target.append(temp)\r\n \r\n return","def toarray(self, object_):\n\n raise NotImplementedError","def reconstruct(self, X):","def reconstruct(self, X):","def test_rarefy_to_list(self):\r\n maker = RarefactionMaker(self.otu_table_fp, 0, 1, 1, 1)\r\n res = maker.rarefy_to_list(include_full=True)\r\n self.assertItemsEqual(res[-1][2].SampleIds, self.otu_table.SampleIds)\r\n self.assertItemsEqual(\r\n res[-1][2].ObservationIds,\r\n self.otu_table.ObservationIds)\r\n self.assertEqual(res[-1][2], self.otu_table)\r\n\r\n sample_value_sum = []\r\n for val in res[1][2].iterSampleData():\r\n sample_value_sum.append(val.sum())\r\n assert_almost_equal(sample_value_sum, [1.0, 1.0])","def __init__(self):\n self.arr = []\n for i in range(80):\n self.arr.append([])","def __init__(self):\n self.b = []","def array(self, src) -> None:\n self.set_array(src)","def cargar_obras(self):\n self.cargarObjetos(self.tableObra,\n ObraSocialModel.buscarTodos(\"razon_social\", self.sesion).all(),\n (\"razon_social\", \"cuit\", \"direccion\")\n )","def post_process(self, res):\n # some lists are better converted to numpy arrays\n convert_to_arr = (\n 'prediction_rank',\n 'cumulative_area',\n 'prediction_values',\n 'cumulative_crime',\n 'cumulative_crime_count',\n 'cumulative_crime_max',\n 'pai'\n )\n for k in convert_to_arr:\n if k in res:\n # this allows for optional components such as prediction values\n res[k] = np.array(res[k])","def comando(accion,_):\r\n return array_comandos","def __init__(self):\n self.grille = []\n for i in range(3):\n self.grille.append([0, 0, 0])","async def begin_array(self):","def makeArray(self):\n for idx in range(len(self.SRB)-1):\n active = self.SRBOnOff[idx]\n eMode = self.eMode[idx]\n eMode_next = self.eMode[idx+1]\n\n if active:\n if eMode and eMode_next:\n for item in np.arange(self.SRB[idx],\n self.SRB[idx+1],\n self.StepSize[idx]):\n self.energy_list.append(round(item,5))\n\n elif not eMode and eMode_next:\n for item in np.arange(self.energy_list[-1],\n self.SRB[idx+1],\n self.StepSize[idx]):\n self.energy_list.append(round(item,5))\n\n else:\n if not len(self.energy_list):\n raise ValueError\n\n for item in self.kMode(self.energy_list[-1],\n self.SRB[idx+1],\n self.StepSize[idx]):\n self.energy_list.append(round(item,5))","def appendconesseq(self,ct,conepar,nummem,j_): # 3\n num_ = None\n if num_ is None:\n num_ = len(ct)\n elif num_ != len(ct):\n raise IndexError(\"Inconsistent length of array ct\")\n if num_ is None:\n num_ = len(conepar)\n elif num_ != len(conepar):\n raise IndexError(\"Inconsistent length of array conepar\")\n if num_ is None:\n num_ = len(nummem)\n elif num_ != len(nummem):\n raise IndexError(\"Inconsistent length of array nummem\")\n if num_ is None: num_ = 0\n if ct is None: raise TypeError(\"Invalid type for argument ct\")\n if ct is None:\n ct_ = None\n else:\n try:\n ct_ = memoryview(ct)\n except TypeError:\n try:\n _tmparr_ct = array.array(\"i\",ct)\n except TypeError:\n raise TypeError(\"Argument ct has wrong type\")\n else:\n ct_ = memoryview(_tmparr_ct)\n \n else:\n if ct_.format != \"i\":\n ct_ = memoryview(array.array(\"i\",ct))\n \n if conepar is None: raise TypeError(\"Invalid type for argument conepar\")\n if conepar is None:\n conepar_ = None\n else:\n try:\n conepar_ = memoryview(conepar)\n except TypeError:\n try:\n _tmparr_conepar = array.array(\"d\",conepar)\n except TypeError:\n raise TypeError(\"Argument conepar has wrong type\")\n else:\n conepar_ = memoryview(_tmparr_conepar)\n \n else:\n if conepar_.format != \"d\":\n conepar_ = memoryview(array.array(\"d\",conepar))\n \n if nummem is None: raise TypeError(\"Invalid type for argument nummem\")\n if nummem is None:\n nummem_ = None\n else:\n try:\n nummem_ = memoryview(nummem)\n except TypeError:\n try:\n _tmparr_nummem = array.array(\"i\",nummem)\n except TypeError:\n raise TypeError(\"Argument nummem has wrong type\")\n else:\n nummem_ = memoryview(_tmparr_nummem)\n \n else:\n if nummem_.format != \"i\":\n nummem_ = memoryview(array.array(\"i\",nummem))\n \n res = self.__obj.appendconesseq(num_,ct_,conepar_,nummem_,j_)\n if res != 0:\n result,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)","def array(self):\n return list(self.sequence)","def build_augmented_matrix(self):\r\n for row in range(self.SIZE):\r\n self.matrix[row].append(self.result[row])","def __array__(self):\n return self.to_array()","def cargar_atril(self,lista,bolsa):\n self.atril = lista\n self.bolsa = bolsa","def __array__(self):\n return self.array","def collect(self, name_to_arr):\n raise NotImplementedError","def cargarObras(self):\n self.cargarObjetos(self.tableOs,\n ObraSocialModel.buscarTodos(\"razon_social\", self.sesion).all(),\n (\"razon_social\", \"cuit\", \"direccion\")\n )","def _from_linked_list_to_array(self):\n arr = []\n if self.size() > 0:\n current = self.head\n while current is not None:\n arr.append(current.value)\n current = current.next\n return arr\n else:\n return arr","def rellenarMatrix(self):\n for i in range(0, 26):\n self.matrixMAPA.append([])\n for j in range(0, 26):\n self.matrixMAPA[i].append((0, str(i)+\"-\"+str(j)))","def __init__(self):\n self.cont = [[[] for _ in range(101)] for _ in range(101)]","def putbaraijlist(self,subi_,subj_,alphaptrb_,alphaptre_,matidx_,weights_):\n num_ = None\n if num_ is None:\n num_ = len(subi_)\n elif num_ != len(subi_):\n raise IndexError(\"Inconsistent length of array subi\")\n if num_ is None:\n num_ = len(subj_)\n elif num_ != len(subj_):\n raise IndexError(\"Inconsistent length of array subj\")\n if num_ is None:\n num_ = len(alphaptrb_)\n elif num_ != len(alphaptrb_):\n raise IndexError(\"Inconsistent length of array alphaptrb\")\n if num_ is None:\n num_ = len(alphaptre_)\n elif num_ != len(alphaptre_):\n raise IndexError(\"Inconsistent length of array alphaptre\")\n if subi_ is None:\n raise ValueError(\"Argument subi cannot be None\")\n if subi_ is None:\n raise ValueError(\"Argument subi may not be None\")\n if isinstance(subi_, numpy.ndarray) and subi_.dtype is numpy.dtype(numpy.int32) and subi_.flags.contiguous:\n _subi_copyarray = False\n _subi_tmp = ctypes.cast(subi_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int32))\n elif subi_ is not None:\n _subi_copyarray = True\n _subi_np_tmp = numpy.zeros(len(subi_),numpy.dtype(numpy.int32))\n _subi_np_tmp[:] = subi_\n assert _subi_np_tmp.flags.contiguous\n _subi_tmp = ctypes.cast(_subi_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int32))\n else:\n _subi_copyarray = False\n _subi_tmp = None\n \n if subj_ is None:\n raise ValueError(\"Argument subj cannot be None\")\n if subj_ is None:\n raise ValueError(\"Argument subj may not be None\")\n if isinstance(subj_, numpy.ndarray) and subj_.dtype is numpy.dtype(numpy.int32) and subj_.flags.contiguous:\n _subj_copyarray = False\n _subj_tmp = ctypes.cast(subj_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int32))\n elif subj_ is not None:\n _subj_copyarray = True\n _subj_np_tmp = numpy.zeros(len(subj_),numpy.dtype(numpy.int32))\n _subj_np_tmp[:] = subj_\n assert _subj_np_tmp.flags.contiguous\n _subj_tmp = ctypes.cast(_subj_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int32))\n else:\n _subj_copyarray = False\n _subj_tmp = None\n \n if alphaptrb_ is None:\n raise ValueError(\"Argument alphaptrb cannot be None\")\n if alphaptrb_ is None:\n raise ValueError(\"Argument alphaptrb may not be None\")\n if isinstance(alphaptrb_, numpy.ndarray) and alphaptrb_.dtype is numpy.dtype(numpy.int64) and alphaptrb_.flags.contiguous:\n _alphaptrb_copyarray = False\n _alphaptrb_tmp = ctypes.cast(alphaptrb_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int64))\n elif alphaptrb_ is not None:\n _alphaptrb_copyarray = True\n _alphaptrb_np_tmp = numpy.zeros(len(alphaptrb_),numpy.dtype(numpy.int64))\n _alphaptrb_np_tmp[:] = alphaptrb_\n assert _alphaptrb_np_tmp.flags.contiguous\n _alphaptrb_tmp = ctypes.cast(_alphaptrb_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int64))\n else:\n _alphaptrb_copyarray = False\n _alphaptrb_tmp = None\n \n if alphaptre_ is None:\n raise ValueError(\"Argument alphaptre cannot be None\")\n if alphaptre_ is None:\n raise ValueError(\"Argument alphaptre may not be None\")\n if isinstance(alphaptre_, numpy.ndarray) and alphaptre_.dtype is numpy.dtype(numpy.int64) and alphaptre_.flags.contiguous:\n _alphaptre_copyarray = False\n _alphaptre_tmp = ctypes.cast(alphaptre_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int64))\n elif alphaptre_ is not None:\n _alphaptre_copyarray = True\n _alphaptre_np_tmp = numpy.zeros(len(alphaptre_),numpy.dtype(numpy.int64))\n _alphaptre_np_tmp[:] = alphaptre_\n assert _alphaptre_np_tmp.flags.contiguous\n _alphaptre_tmp = ctypes.cast(_alphaptre_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int64))\n else:\n _alphaptre_copyarray = False\n _alphaptre_tmp = None\n \n if matidx_ is None:\n raise ValueError(\"Argument matidx cannot be None\")\n if matidx_ is None:\n raise ValueError(\"Argument matidx may not be None\")\n if isinstance(matidx_, numpy.ndarray) and matidx_.dtype is numpy.dtype(numpy.int64) and matidx_.flags.contiguous:\n _matidx_copyarray = False\n _matidx_tmp = ctypes.cast(matidx_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int64))\n elif matidx_ is not None:\n _matidx_copyarray = True\n _matidx_np_tmp = numpy.zeros(len(matidx_),numpy.dtype(numpy.int64))\n _matidx_np_tmp[:] = matidx_\n assert _matidx_np_tmp.flags.contiguous\n _matidx_tmp = ctypes.cast(_matidx_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int64))\n else:\n _matidx_copyarray = False\n _matidx_tmp = None\n \n if weights_ is None:\n raise ValueError(\"Argument weights cannot be None\")\n if weights_ is None:\n raise ValueError(\"Argument weights may not be None\")\n if isinstance(weights_, numpy.ndarray) and weights_.dtype is numpy.dtype(numpy.float64) and weights_.flags.contiguous:\n _weights_copyarray = False\n _weights_tmp = ctypes.cast(weights_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n elif weights_ is not None:\n _weights_copyarray = True\n _weights_np_tmp = numpy.zeros(len(weights_),numpy.dtype(numpy.float64))\n _weights_np_tmp[:] = weights_\n assert _weights_np_tmp.flags.contiguous\n _weights_tmp = ctypes.cast(_weights_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n else:\n _weights_copyarray = False\n _weights_tmp = None\n \n res = __library__.MSK_XX_putbaraijlist(self.__nativep,num_,_subi_tmp,_subj_tmp,_alphaptrb_tmp,_alphaptre_tmp,_matidx_tmp,_weights_tmp)\n if res != 0:\n _,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)","def _build_iterable(self):","def get_atril_array(self):\n return self.atril","def merge_roidb(roidbs):\n roidb = roidbs[0]\n for r in roidbs[1:]:\n roidb.extend(r)\n return roidb","def merge_roidb(roidbs):\n roidb = roidbs[0]\n for r in roidbs[1:]:\n roidb.extend(r)\n return roidb","def putaijlist(self,subi,subj,valij): # 3\n num_ = None\n if num_ is None:\n num_ = len(subi)\n elif num_ != len(subi):\n raise IndexError(\"Inconsistent length of array subi\")\n if num_ is None:\n num_ = len(subj)\n elif num_ != len(subj):\n raise IndexError(\"Inconsistent length of array subj\")\n if num_ is None:\n num_ = len(valij)\n elif num_ != len(valij):\n raise IndexError(\"Inconsistent length of array valij\")\n if num_ is None: num_ = 0\n if subi is None: raise TypeError(\"Invalid type for argument subi\")\n if subi is None:\n subi_ = None\n else:\n try:\n subi_ = memoryview(subi)\n except TypeError:\n try:\n _tmparr_subi = array.array(\"i\",subi)\n except TypeError:\n raise TypeError(\"Argument subi has wrong type\")\n else:\n subi_ = memoryview(_tmparr_subi)\n \n else:\n if subi_.format != \"i\":\n subi_ = memoryview(array.array(\"i\",subi))\n \n if subj is None: raise TypeError(\"Invalid type for argument subj\")\n if subj is None:\n subj_ = None\n else:\n try:\n subj_ = memoryview(subj)\n except TypeError:\n try:\n _tmparr_subj = array.array(\"i\",subj)\n except TypeError:\n raise TypeError(\"Argument subj has wrong type\")\n else:\n subj_ = memoryview(_tmparr_subj)\n \n else:\n if subj_.format != \"i\":\n subj_ = memoryview(array.array(\"i\",subj))\n \n if valij is None: raise TypeError(\"Invalid type for argument valij\")\n if valij is None:\n valij_ = None\n else:\n try:\n valij_ = memoryview(valij)\n except TypeError:\n try:\n _tmparr_valij = array.array(\"d\",valij)\n except TypeError:\n raise TypeError(\"Argument valij has wrong type\")\n else:\n valij_ = memoryview(_tmparr_valij)\n \n else:\n if valij_.format != \"d\":\n valij_ = memoryview(array.array(\"d\",valij))\n \n res = self.__obj.putaijlist64(num_,subi_,subj_,valij_)\n if res != 0:\n result,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)","def add_res_list(res_list):","def agregar_al_atril(self):\n self.atril.append(self.bolsa.tomar_bolsa())","def putaijlist(self,subi_,subj_,valij_):\n num_ = None\n if num_ is None:\n num_ = len(subi_)\n elif num_ != len(subi_):\n raise IndexError(\"Inconsistent length of array subi\")\n if num_ is None:\n num_ = len(subj_)\n elif num_ != len(subj_):\n raise IndexError(\"Inconsistent length of array subj\")\n if num_ is None:\n num_ = len(valij_)\n elif num_ != len(valij_):\n raise IndexError(\"Inconsistent length of array valij\")\n if subi_ is None:\n raise ValueError(\"Argument subi cannot be None\")\n if subi_ is None:\n raise ValueError(\"Argument subi may not be None\")\n if isinstance(subi_, numpy.ndarray) and subi_.dtype is numpy.dtype(numpy.int32) and subi_.flags.contiguous:\n _subi_copyarray = False\n _subi_tmp = ctypes.cast(subi_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int32))\n elif subi_ is not None:\n _subi_copyarray = True\n _subi_np_tmp = numpy.zeros(len(subi_),numpy.dtype(numpy.int32))\n _subi_np_tmp[:] = subi_\n assert _subi_np_tmp.flags.contiguous\n _subi_tmp = ctypes.cast(_subi_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int32))\n else:\n _subi_copyarray = False\n _subi_tmp = None\n \n if subj_ is None:\n raise ValueError(\"Argument subj cannot be None\")\n if subj_ is None:\n raise ValueError(\"Argument subj may not be None\")\n if isinstance(subj_, numpy.ndarray) and subj_.dtype is numpy.dtype(numpy.int32) and subj_.flags.contiguous:\n _subj_copyarray = False\n _subj_tmp = ctypes.cast(subj_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int32))\n elif subj_ is not None:\n _subj_copyarray = True\n _subj_np_tmp = numpy.zeros(len(subj_),numpy.dtype(numpy.int32))\n _subj_np_tmp[:] = subj_\n assert _subj_np_tmp.flags.contiguous\n _subj_tmp = ctypes.cast(_subj_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int32))\n else:\n _subj_copyarray = False\n _subj_tmp = None\n \n if valij_ is None:\n raise ValueError(\"Argument valij cannot be None\")\n if valij_ is None:\n raise ValueError(\"Argument valij may not be None\")\n if isinstance(valij_, numpy.ndarray) and valij_.dtype is numpy.dtype(numpy.float64) and valij_.flags.contiguous:\n _valij_copyarray = False\n _valij_tmp = ctypes.cast(valij_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n elif valij_ is not None:\n _valij_copyarray = True\n _valij_np_tmp = numpy.zeros(len(valij_),numpy.dtype(numpy.float64))\n _valij_np_tmp[:] = valij_\n assert _valij_np_tmp.flags.contiguous\n _valij_tmp = ctypes.cast(_valij_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n else:\n _valij_copyarray = False\n _valij_tmp = None\n \n res = __library__.MSK_XX_putaijlist64(self.__nativep,num_,_subi_tmp,_subj_tmp,_valij_tmp)\n if res != 0:\n _,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)","def update(self):\n\n # Ordenamos los personajes por fila, para luego dibujarlos correctamente. Para que no se solapen.\n self._personajes.sort(self._comparar_coordenadas_personajes)\n\n for personaje in self._personajes:\n if (personaje.andando): # Si está andando.\n # Si el personaje se encuentra en el centro de la celda a donde debia llegar ...\n if (personaje.obtener_coordenadas() == self._mapa.obtener_coordenadas_por_posicion((personaje.camino[0][0], personaje.camino[0][1]),self._mapa.CENTER)): \n del personaje.camino[:1] # Eliminamos esa celda del camino ha seguir porque ya ha llegado a ella. \n if ((personaje.camino == []) or (personaje.camino == None)): # Si ya no queda camino a seguir...\n personaje.parar() # Paramos al Personaje.\n if not(personaje.accion == None): # Si tiene asignada alguna acción después de haber llegado a su destino ...\n personaje.accion() # Ejecutamos la acción\n personaje.accion = None # Y limpiamos la acción\n if (personaje.nombre != \"Jugador\"): # Si el Personaje no es el Jugador establacemos su dirección final.\n personaje.actualizar_direccion(personaje.direccion_final)\n else: # Calculamos la nueva direccion hacia donde tiene que mover\n # Obtenemos la fila y columna donde se encuenta el personaje.\n origen = self._mapa.obtener_posicion_por_coordenadas(personaje.obtener_coordenadas())\n # Establecemos hacia donde tiene que mirar el Personaje para ir en esa dirección.\n personaje.actualizar_direccion(self._mapa.direcciones.index([personaje.camino[0][0] - origen[0], personaje.camino[0][1] - origen[1]]))\n else: # Si el personaje no esa todavia en el centro de la celda \n if (not self._hay_colision(personaje, (personaje.camino[0][0], personaje.camino[0][1]))): # Si no hay colisión en la celda de destino \n personaje.mover(personaje.obtener_direccion()) # Movemos al personaje en esa dirección.\n else: # Si hay colision\n celda_personaje = self._mapa.obtener_posicion_por_coordenadas(personaje.obtener_coordenadas())\n personaje.actualizar_posicion(self._mapa.obtener_coordenadas_por_posicion((celda_personaje[0], celda_personaje[1]),self._mapa.CENTER))\n # Volvermos a calcular una ruta para llegar al destino.\n self.ir_a(personaje, personaje.destino, personaje.direccion_final)\n \n personaje.update() # Actualizamos el personaje.\n \n for objeto in self._objetos: # Actualizamos los objetos.\n objeto.update()\n \n self._dibujar(\n )","def __init__(self):\n self.l = []","def rosterRowData(self):","def __init__(self):\n self.data = []","def __init__(self):\n self.data = []","def __call__(self):\n return self.array","def acumula_nq1(self, nq1, rodada):\n self.nq1[rodada].append(nq1)","def __init__(self):\n self.s = []","def __init__(self):\n self.s = []","def __init__(self):\n self._data = []","def __init__(self):\n self._data = []","def __init__(self):\n self._data = []","def __init__(self):\n self._data = []","def __init__(self):\n self._data = []","def __init__(self):\n self._data = []","def list_to_array(llist, target):\r\n while llist.is_empty() == False:\r\n target.append(llist.pop(0))\r\n \r\n return","def __init__(self):\n self.min =[] \n self.arr = []","def __init__(self):\n self.data = [[] for i in range(self._MOD)]","def __init__(self):\n self.a = []","def __init__(self):\n self.a = []","def queue_to_array(queue, target):\r\n temp = None\r\n \r\n while queue.is_empty() == False:\r\n temp = queue.remove()\r\n target.append(temp)\r\n\r\n return","def arrays(self, select_output):\n pass","def _flatten(self):\n n = self.B\n idx = self.nodect - 1\n self.seq = []\n while n is not None:\n n['idx'] = idx\n self.seq.insert(0, n)\n idx -= 1\n n = n['pred']","def __init__(self):\n self.que = []\n self.tem_que = []","def fim_da_rodada(self, recompensa, m, numero_de_cacadores):\n #print('Jogador 4 {}'.format(self.historico[-1]))\n pass","def obter_lista_arquivos(self):\n if os.path.exists(self.caminho):\n return [arq for arq in self.obter_lista_conteudo() \\\n if os.path.isfile(arq)]\n else:\n return []","def _parseArray(self, options, race, save):\n\t\t\n\t\tif options[1] == True:\n\t\t\tstart = options[2] \n\t\t\tfinish = options[3] \n\t\t\tfor i in range(start, finish): #index are ok\n\t\t\t\t# delete invalid chars { } '\n\t\t\t\t# line is: {x, y, z, rx, ry, rz, 'gatename'},\n\t\t\t\tline = self.content[i].replace(\"{\", \"\").replace(\"}\", \"\").replace(\"'\", \"\").strip().split(\",\")\n\t\t\t\tp = positionClass()\n\t\t\t\tp.asTuple = float(line[0]), float(line[1]), float(line[2])\n\t\t\t\trot = rotationClass()\n\t\t\t\trot.asTuple = float(line[3]), float(line[4]), float(line[5])\n\t\t\t\tgatename = line[6].replace(\"'\", \"\").replace('\"', '').replace(' ', '')\n\t\t\t\tsave.append({'pos': p, 'rot': rot, 'entry':None, 'gate':gatename})","def array_to_list(llist, source):\r\n while source: #a list is considered True as long as it is not empty\r\n llist.append(source.pop(0))\r\n \r\n return","def __array__(self):\n return dict2rec(self)","def add_row(matrix):\n\tl = len(matrix[0])\n\ttemp = matrix[:]\n\ttemp += [[0]*l]\n\treturn temp","def set_ret(self, ret):\n \n self.ret = [i for i in ret]","def __init__(self):\n self._array = None","def __init__(self):\n self.arr = array(\"i\")","def append(self, traj):\n if hasattr(traj, 'trajid'):\n self.trajectories.append(traj)\n self.trajids.append(traj.trajid)\n self.trajcount = len(self.trajectories)","def add(self, experience: []):\n if len(self.buffer) + len(experience) >= self.buffer_size:\n self.buffer[0:1] = []\n self.buffer.append(experience)","def representarArbolAutomatico(self):\n if not self.stepByStep:\n print(\"Pintar paredes en auto\")\n # Reinicio la matrix\n self.reiniciarMatrix()\n if self.arbol.raiz != None:\n # Capturo todos los valores\n for i in self.arbol.returnArbolComoVector():\n \n # Esta variable captura si se debe de pintar en x o y\n xy = int(i[1])\n cordenadas = i[0]\n print(\"===========NODOS DEL ARBOL=============\")\n print(i)\n print(\"===========NODOS DEL ARBOL=============\")\n # Se pinta en x o y?\n if xy == 0:\n self.crearParedX(int(cordenadas[0]), int(cordenadas[1]))\n else:\n self.crearParedY(int(cordenadas[0]), int(cordenadas[1]))\n\n self.esperarUnRato()\n\n print(\"========LISTO PARA PINTAR EL SIGUIENTE================\")\n \n else:\n print(\"Arbol vacio\")","def __init__(self):\n self.l = []\n self.length = 0"],"string":"[\n \"def array(self):\",\n \"def __init__(self,array):\\n self.arr = array\\n # self.result = []\",\n \"def __init__(self):\\n self.arr = []\",\n \"def __init__(self):\\n self.arr = []\",\n \"def __init__(self):\\n self.arr = []\",\n \"def __init__(self):\\n self.arr = []\",\n \"def abrir(self):\\n assert self.open == False\\n self.ne = [n for n in self.ne]\\n self.je = [e1 for e1 in self.je]\\n self.ie = []\\n self.open = True\",\n \"def _make_result_list(self,res):\\n res_list = []\\n for r in res:\\n res_list.append(r)\\n\\n return res_list\",\n \"def __init__(self, id, padre, hijos):\\n\\n self.__id = id\\n self.__padre = padre\\n self.__hijos = np.array([])\\n for i in range(len(hijos)):\\n newHijos = np.delete(hijos,i,0)#Se remueve el nodo de la lista una vez recorrido\\n self.__hijos = np.append(self.__hijos, NodoCiudad(hijos[i],self,newHijos))\",\n \"def __init__(self, bolsa,letras=[]):\\n self.atril = []\\n self.bolsa = bolsa\\n if letras == []:\\n self.initialize()\\n else:\\n self.cargar_atril(letras,bolsa)\",\n \"def reiniciarMatrix(self):\\n self.matrixMAPA = []\\n self.rellenarMatrix()\",\n \"def __radd__(self, left_arr):\\n concat_arr = left_arr.copy() # Create new instance to return\\n concat_arr.extend(self)\\n return concat_arr\",\n \"def arredondar(self):\\n for y in range(self.altura):\\n for x in range(self.largura):\\n for i in range(3):\\n self.lista[x][y][i] = int(self.lista[x][y][i])\",\n \"def __init__(self, arr=None):\\n self.data = arr.copy() if arr else []\",\n \"def preencherJogadores():\\n global jogadores\\n for x in participantes:\\n if x['porta'] != lider['porta']:\\n jogadores.append(x)\",\n \"def rellenar_atril(self):\\n while self.get_atril_espaciosVacios() > 0 and self.bolsa.cantidad_Fichas() > 0:\\n self.agregar_al_atril()\",\n \"def __init__(self):\\n mi_parqueo = list()\",\n \"def arr(self):\\n return self._arr\",\n \"def flag(self, arr):\\n return arr\",\n \"def __init__(self):\\n self.arr = []\\n self.size = 0\",\n \"def AgregarCara(Cara,*J):\\n\\tJugador=[]\\n\\tfor x in J:\\n\\t Jugador.append(x)\\n\\t\\n\\tif Cara == 1 and Disponibles[0] == True:\\n\\t\\tJugador[0] = Jugador[0] + 1\\n\\t\\t#e=Jugador[0]\\n\\t\\t#Jugador[0]=e+1\\n\\telse:\\n\\t\\tif Cara == 2 and Disponibles[1] == True:\\n\\t\\t\\tJugador[1] = Jugador[1] + 1\\n\\t\\t\\t#e=Jugador[1]\\n\\t\\t\\t#Jugador[1]=e + 1\\n\\t\\telse:\\n\\t\\t\\tif Cara == 3 and Disponibles[2] == True:\\n\\t\\t\\t\\tJugador[2] = Jugador[2] + 1\\n\\t\\t\\t\\t#e=Jugador[2]\\n\\t\\t\\t\\t#Jugador[2]=e + 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tif Cara == 4 and Disponibles[3] == True:\\n\\t\\t\\t\\t\\tJugador[3] = Jugador[3] + 1\\n\\t\\t\\t\\t\\t#e=Jugador[3]\\n\\t\\t\\t\\t\\t#Jugador[3]=e + 1\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tif Cara == 5 and Disponibles[4] == True:\\n\\t\\t\\t\\t\\t\\tJugador[4] = Jugador[4] + 1\\n\\t\\t\\t\\t\\t\\t#e=Jugador[4]\\n\\t\\t\\t\\t\\t\\t#Jugador[4]=e + 1\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tif Cara == 6 and Disponibles[5] == True:\\n\\t\\t\\t\\t\\t\\t\\tJugador[5] = Jugador[5] + 1\\n\\t\\t\\t\\t\\t\\t\\t#e=Jugador[5]\\n\\t\\t\\t\\t\\t\\t\\t#Jugador[5]=e + 1\\n\\treturn Jugador\",\n \"def __init__(self):\\n self._data=[]\",\n \"def __init__(self):\\n self.l = []\\n self.r = []\",\n \"def asArray(self):\\n\\n # Caching is evil, Loomis. Don't do that.\\n if not hasattr(self, 'array'):\\n self.sealArray()\\n return self.recarray\",\n \"def toArray(self, *args):\\n pass\",\n \"def abrir(self):\\n self.x0 = [val for val in self.x0]\\n self.x = [val for val in self.x]\\n self.tipos = [val for val in self.tipos]\\n self.mask_fr = [val for val in self.mask_fr]\\n self.mask_in = [val for val in self.mask_in]\\n self.open = True\",\n \"def __init__(self):\\n\\n self.notas = []\",\n \"def __add__(self, right_arr):\\n concat_arr = self.copy() # Create new instance to return\\n concat_arr.extend(right_arr)\\n return concat_arr\",\n \"def apilar(self,dato):\\r\\n\\t\\tself.elementos.append(dato)\\r\\n\\t\\tself.len += 1\",\n \"def pq_to_array(pq, target):\\r\\n temp = None\\r\\n \\r\\n while pq.is_empty() == False:\\r\\n temp = pq.remove()\\r\\n target.append(temp)\\r\\n \\r\\n return\",\n \"def toarray(self, object_):\\n\\n raise NotImplementedError\",\n \"def reconstruct(self, X):\",\n \"def reconstruct(self, X):\",\n \"def test_rarefy_to_list(self):\\r\\n maker = RarefactionMaker(self.otu_table_fp, 0, 1, 1, 1)\\r\\n res = maker.rarefy_to_list(include_full=True)\\r\\n self.assertItemsEqual(res[-1][2].SampleIds, self.otu_table.SampleIds)\\r\\n self.assertItemsEqual(\\r\\n res[-1][2].ObservationIds,\\r\\n self.otu_table.ObservationIds)\\r\\n self.assertEqual(res[-1][2], self.otu_table)\\r\\n\\r\\n sample_value_sum = []\\r\\n for val in res[1][2].iterSampleData():\\r\\n sample_value_sum.append(val.sum())\\r\\n assert_almost_equal(sample_value_sum, [1.0, 1.0])\",\n \"def __init__(self):\\n self.arr = []\\n for i in range(80):\\n self.arr.append([])\",\n \"def __init__(self):\\n self.b = []\",\n \"def array(self, src) -> None:\\n self.set_array(src)\",\n \"def cargar_obras(self):\\n self.cargarObjetos(self.tableObra,\\n ObraSocialModel.buscarTodos(\\\"razon_social\\\", self.sesion).all(),\\n (\\\"razon_social\\\", \\\"cuit\\\", \\\"direccion\\\")\\n )\",\n \"def post_process(self, res):\\n # some lists are better converted to numpy arrays\\n convert_to_arr = (\\n 'prediction_rank',\\n 'cumulative_area',\\n 'prediction_values',\\n 'cumulative_crime',\\n 'cumulative_crime_count',\\n 'cumulative_crime_max',\\n 'pai'\\n )\\n for k in convert_to_arr:\\n if k in res:\\n # this allows for optional components such as prediction values\\n res[k] = np.array(res[k])\",\n \"def comando(accion,_):\\r\\n return array_comandos\",\n \"def __init__(self):\\n self.grille = []\\n for i in range(3):\\n self.grille.append([0, 0, 0])\",\n \"async def begin_array(self):\",\n \"def makeArray(self):\\n for idx in range(len(self.SRB)-1):\\n active = self.SRBOnOff[idx]\\n eMode = self.eMode[idx]\\n eMode_next = self.eMode[idx+1]\\n\\n if active:\\n if eMode and eMode_next:\\n for item in np.arange(self.SRB[idx],\\n self.SRB[idx+1],\\n self.StepSize[idx]):\\n self.energy_list.append(round(item,5))\\n\\n elif not eMode and eMode_next:\\n for item in np.arange(self.energy_list[-1],\\n self.SRB[idx+1],\\n self.StepSize[idx]):\\n self.energy_list.append(round(item,5))\\n\\n else:\\n if not len(self.energy_list):\\n raise ValueError\\n\\n for item in self.kMode(self.energy_list[-1],\\n self.SRB[idx+1],\\n self.StepSize[idx]):\\n self.energy_list.append(round(item,5))\",\n \"def appendconesseq(self,ct,conepar,nummem,j_): # 3\\n num_ = None\\n if num_ is None:\\n num_ = len(ct)\\n elif num_ != len(ct):\\n raise IndexError(\\\"Inconsistent length of array ct\\\")\\n if num_ is None:\\n num_ = len(conepar)\\n elif num_ != len(conepar):\\n raise IndexError(\\\"Inconsistent length of array conepar\\\")\\n if num_ is None:\\n num_ = len(nummem)\\n elif num_ != len(nummem):\\n raise IndexError(\\\"Inconsistent length of array nummem\\\")\\n if num_ is None: num_ = 0\\n if ct is None: raise TypeError(\\\"Invalid type for argument ct\\\")\\n if ct is None:\\n ct_ = None\\n else:\\n try:\\n ct_ = memoryview(ct)\\n except TypeError:\\n try:\\n _tmparr_ct = array.array(\\\"i\\\",ct)\\n except TypeError:\\n raise TypeError(\\\"Argument ct has wrong type\\\")\\n else:\\n ct_ = memoryview(_tmparr_ct)\\n \\n else:\\n if ct_.format != \\\"i\\\":\\n ct_ = memoryview(array.array(\\\"i\\\",ct))\\n \\n if conepar is None: raise TypeError(\\\"Invalid type for argument conepar\\\")\\n if conepar is None:\\n conepar_ = None\\n else:\\n try:\\n conepar_ = memoryview(conepar)\\n except TypeError:\\n try:\\n _tmparr_conepar = array.array(\\\"d\\\",conepar)\\n except TypeError:\\n raise TypeError(\\\"Argument conepar has wrong type\\\")\\n else:\\n conepar_ = memoryview(_tmparr_conepar)\\n \\n else:\\n if conepar_.format != \\\"d\\\":\\n conepar_ = memoryview(array.array(\\\"d\\\",conepar))\\n \\n if nummem is None: raise TypeError(\\\"Invalid type for argument nummem\\\")\\n if nummem is None:\\n nummem_ = None\\n else:\\n try:\\n nummem_ = memoryview(nummem)\\n except TypeError:\\n try:\\n _tmparr_nummem = array.array(\\\"i\\\",nummem)\\n except TypeError:\\n raise TypeError(\\\"Argument nummem has wrong type\\\")\\n else:\\n nummem_ = memoryview(_tmparr_nummem)\\n \\n else:\\n if nummem_.format != \\\"i\\\":\\n nummem_ = memoryview(array.array(\\\"i\\\",nummem))\\n \\n res = self.__obj.appendconesseq(num_,ct_,conepar_,nummem_,j_)\\n if res != 0:\\n result,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\",\n \"def array(self):\\n return list(self.sequence)\",\n \"def build_augmented_matrix(self):\\r\\n for row in range(self.SIZE):\\r\\n self.matrix[row].append(self.result[row])\",\n \"def __array__(self):\\n return self.to_array()\",\n \"def cargar_atril(self,lista,bolsa):\\n self.atril = lista\\n self.bolsa = bolsa\",\n \"def __array__(self):\\n return self.array\",\n \"def collect(self, name_to_arr):\\n raise NotImplementedError\",\n \"def cargarObras(self):\\n self.cargarObjetos(self.tableOs,\\n ObraSocialModel.buscarTodos(\\\"razon_social\\\", self.sesion).all(),\\n (\\\"razon_social\\\", \\\"cuit\\\", \\\"direccion\\\")\\n )\",\n \"def _from_linked_list_to_array(self):\\n arr = []\\n if self.size() > 0:\\n current = self.head\\n while current is not None:\\n arr.append(current.value)\\n current = current.next\\n return arr\\n else:\\n return arr\",\n \"def rellenarMatrix(self):\\n for i in range(0, 26):\\n self.matrixMAPA.append([])\\n for j in range(0, 26):\\n self.matrixMAPA[i].append((0, str(i)+\\\"-\\\"+str(j)))\",\n \"def __init__(self):\\n self.cont = [[[] for _ in range(101)] for _ in range(101)]\",\n \"def putbaraijlist(self,subi_,subj_,alphaptrb_,alphaptre_,matidx_,weights_):\\n num_ = None\\n if num_ is None:\\n num_ = len(subi_)\\n elif num_ != len(subi_):\\n raise IndexError(\\\"Inconsistent length of array subi\\\")\\n if num_ is None:\\n num_ = len(subj_)\\n elif num_ != len(subj_):\\n raise IndexError(\\\"Inconsistent length of array subj\\\")\\n if num_ is None:\\n num_ = len(alphaptrb_)\\n elif num_ != len(alphaptrb_):\\n raise IndexError(\\\"Inconsistent length of array alphaptrb\\\")\\n if num_ is None:\\n num_ = len(alphaptre_)\\n elif num_ != len(alphaptre_):\\n raise IndexError(\\\"Inconsistent length of array alphaptre\\\")\\n if subi_ is None:\\n raise ValueError(\\\"Argument subi cannot be None\\\")\\n if subi_ is None:\\n raise ValueError(\\\"Argument subi may not be None\\\")\\n if isinstance(subi_, numpy.ndarray) and subi_.dtype is numpy.dtype(numpy.int32) and subi_.flags.contiguous:\\n _subi_copyarray = False\\n _subi_tmp = ctypes.cast(subi_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int32))\\n elif subi_ is not None:\\n _subi_copyarray = True\\n _subi_np_tmp = numpy.zeros(len(subi_),numpy.dtype(numpy.int32))\\n _subi_np_tmp[:] = subi_\\n assert _subi_np_tmp.flags.contiguous\\n _subi_tmp = ctypes.cast(_subi_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int32))\\n else:\\n _subi_copyarray = False\\n _subi_tmp = None\\n \\n if subj_ is None:\\n raise ValueError(\\\"Argument subj cannot be None\\\")\\n if subj_ is None:\\n raise ValueError(\\\"Argument subj may not be None\\\")\\n if isinstance(subj_, numpy.ndarray) and subj_.dtype is numpy.dtype(numpy.int32) and subj_.flags.contiguous:\\n _subj_copyarray = False\\n _subj_tmp = ctypes.cast(subj_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int32))\\n elif subj_ is not None:\\n _subj_copyarray = True\\n _subj_np_tmp = numpy.zeros(len(subj_),numpy.dtype(numpy.int32))\\n _subj_np_tmp[:] = subj_\\n assert _subj_np_tmp.flags.contiguous\\n _subj_tmp = ctypes.cast(_subj_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int32))\\n else:\\n _subj_copyarray = False\\n _subj_tmp = None\\n \\n if alphaptrb_ is None:\\n raise ValueError(\\\"Argument alphaptrb cannot be None\\\")\\n if alphaptrb_ is None:\\n raise ValueError(\\\"Argument alphaptrb may not be None\\\")\\n if isinstance(alphaptrb_, numpy.ndarray) and alphaptrb_.dtype is numpy.dtype(numpy.int64) and alphaptrb_.flags.contiguous:\\n _alphaptrb_copyarray = False\\n _alphaptrb_tmp = ctypes.cast(alphaptrb_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int64))\\n elif alphaptrb_ is not None:\\n _alphaptrb_copyarray = True\\n _alphaptrb_np_tmp = numpy.zeros(len(alphaptrb_),numpy.dtype(numpy.int64))\\n _alphaptrb_np_tmp[:] = alphaptrb_\\n assert _alphaptrb_np_tmp.flags.contiguous\\n _alphaptrb_tmp = ctypes.cast(_alphaptrb_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int64))\\n else:\\n _alphaptrb_copyarray = False\\n _alphaptrb_tmp = None\\n \\n if alphaptre_ is None:\\n raise ValueError(\\\"Argument alphaptre cannot be None\\\")\\n if alphaptre_ is None:\\n raise ValueError(\\\"Argument alphaptre may not be None\\\")\\n if isinstance(alphaptre_, numpy.ndarray) and alphaptre_.dtype is numpy.dtype(numpy.int64) and alphaptre_.flags.contiguous:\\n _alphaptre_copyarray = False\\n _alphaptre_tmp = ctypes.cast(alphaptre_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int64))\\n elif alphaptre_ is not None:\\n _alphaptre_copyarray = True\\n _alphaptre_np_tmp = numpy.zeros(len(alphaptre_),numpy.dtype(numpy.int64))\\n _alphaptre_np_tmp[:] = alphaptre_\\n assert _alphaptre_np_tmp.flags.contiguous\\n _alphaptre_tmp = ctypes.cast(_alphaptre_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int64))\\n else:\\n _alphaptre_copyarray = False\\n _alphaptre_tmp = None\\n \\n if matidx_ is None:\\n raise ValueError(\\\"Argument matidx cannot be None\\\")\\n if matidx_ is None:\\n raise ValueError(\\\"Argument matidx may not be None\\\")\\n if isinstance(matidx_, numpy.ndarray) and matidx_.dtype is numpy.dtype(numpy.int64) and matidx_.flags.contiguous:\\n _matidx_copyarray = False\\n _matidx_tmp = ctypes.cast(matidx_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int64))\\n elif matidx_ is not None:\\n _matidx_copyarray = True\\n _matidx_np_tmp = numpy.zeros(len(matidx_),numpy.dtype(numpy.int64))\\n _matidx_np_tmp[:] = matidx_\\n assert _matidx_np_tmp.flags.contiguous\\n _matidx_tmp = ctypes.cast(_matidx_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int64))\\n else:\\n _matidx_copyarray = False\\n _matidx_tmp = None\\n \\n if weights_ is None:\\n raise ValueError(\\\"Argument weights cannot be None\\\")\\n if weights_ is None:\\n raise ValueError(\\\"Argument weights may not be None\\\")\\n if isinstance(weights_, numpy.ndarray) and weights_.dtype is numpy.dtype(numpy.float64) and weights_.flags.contiguous:\\n _weights_copyarray = False\\n _weights_tmp = ctypes.cast(weights_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n elif weights_ is not None:\\n _weights_copyarray = True\\n _weights_np_tmp = numpy.zeros(len(weights_),numpy.dtype(numpy.float64))\\n _weights_np_tmp[:] = weights_\\n assert _weights_np_tmp.flags.contiguous\\n _weights_tmp = ctypes.cast(_weights_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n else:\\n _weights_copyarray = False\\n _weights_tmp = None\\n \\n res = __library__.MSK_XX_putbaraijlist(self.__nativep,num_,_subi_tmp,_subj_tmp,_alphaptrb_tmp,_alphaptre_tmp,_matidx_tmp,_weights_tmp)\\n if res != 0:\\n _,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\",\n \"def _build_iterable(self):\",\n \"def get_atril_array(self):\\n return self.atril\",\n \"def merge_roidb(roidbs):\\n roidb = roidbs[0]\\n for r in roidbs[1:]:\\n roidb.extend(r)\\n return roidb\",\n \"def merge_roidb(roidbs):\\n roidb = roidbs[0]\\n for r in roidbs[1:]:\\n roidb.extend(r)\\n return roidb\",\n \"def putaijlist(self,subi,subj,valij): # 3\\n num_ = None\\n if num_ is None:\\n num_ = len(subi)\\n elif num_ != len(subi):\\n raise IndexError(\\\"Inconsistent length of array subi\\\")\\n if num_ is None:\\n num_ = len(subj)\\n elif num_ != len(subj):\\n raise IndexError(\\\"Inconsistent length of array subj\\\")\\n if num_ is None:\\n num_ = len(valij)\\n elif num_ != len(valij):\\n raise IndexError(\\\"Inconsistent length of array valij\\\")\\n if num_ is None: num_ = 0\\n if subi is None: raise TypeError(\\\"Invalid type for argument subi\\\")\\n if subi is None:\\n subi_ = None\\n else:\\n try:\\n subi_ = memoryview(subi)\\n except TypeError:\\n try:\\n _tmparr_subi = array.array(\\\"i\\\",subi)\\n except TypeError:\\n raise TypeError(\\\"Argument subi has wrong type\\\")\\n else:\\n subi_ = memoryview(_tmparr_subi)\\n \\n else:\\n if subi_.format != \\\"i\\\":\\n subi_ = memoryview(array.array(\\\"i\\\",subi))\\n \\n if subj is None: raise TypeError(\\\"Invalid type for argument subj\\\")\\n if subj is None:\\n subj_ = None\\n else:\\n try:\\n subj_ = memoryview(subj)\\n except TypeError:\\n try:\\n _tmparr_subj = array.array(\\\"i\\\",subj)\\n except TypeError:\\n raise TypeError(\\\"Argument subj has wrong type\\\")\\n else:\\n subj_ = memoryview(_tmparr_subj)\\n \\n else:\\n if subj_.format != \\\"i\\\":\\n subj_ = memoryview(array.array(\\\"i\\\",subj))\\n \\n if valij is None: raise TypeError(\\\"Invalid type for argument valij\\\")\\n if valij is None:\\n valij_ = None\\n else:\\n try:\\n valij_ = memoryview(valij)\\n except TypeError:\\n try:\\n _tmparr_valij = array.array(\\\"d\\\",valij)\\n except TypeError:\\n raise TypeError(\\\"Argument valij has wrong type\\\")\\n else:\\n valij_ = memoryview(_tmparr_valij)\\n \\n else:\\n if valij_.format != \\\"d\\\":\\n valij_ = memoryview(array.array(\\\"d\\\",valij))\\n \\n res = self.__obj.putaijlist64(num_,subi_,subj_,valij_)\\n if res != 0:\\n result,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\",\n \"def add_res_list(res_list):\",\n \"def agregar_al_atril(self):\\n self.atril.append(self.bolsa.tomar_bolsa())\",\n \"def putaijlist(self,subi_,subj_,valij_):\\n num_ = None\\n if num_ is None:\\n num_ = len(subi_)\\n elif num_ != len(subi_):\\n raise IndexError(\\\"Inconsistent length of array subi\\\")\\n if num_ is None:\\n num_ = len(subj_)\\n elif num_ != len(subj_):\\n raise IndexError(\\\"Inconsistent length of array subj\\\")\\n if num_ is None:\\n num_ = len(valij_)\\n elif num_ != len(valij_):\\n raise IndexError(\\\"Inconsistent length of array valij\\\")\\n if subi_ is None:\\n raise ValueError(\\\"Argument subi cannot be None\\\")\\n if subi_ is None:\\n raise ValueError(\\\"Argument subi may not be None\\\")\\n if isinstance(subi_, numpy.ndarray) and subi_.dtype is numpy.dtype(numpy.int32) and subi_.flags.contiguous:\\n _subi_copyarray = False\\n _subi_tmp = ctypes.cast(subi_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int32))\\n elif subi_ is not None:\\n _subi_copyarray = True\\n _subi_np_tmp = numpy.zeros(len(subi_),numpy.dtype(numpy.int32))\\n _subi_np_tmp[:] = subi_\\n assert _subi_np_tmp.flags.contiguous\\n _subi_tmp = ctypes.cast(_subi_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int32))\\n else:\\n _subi_copyarray = False\\n _subi_tmp = None\\n \\n if subj_ is None:\\n raise ValueError(\\\"Argument subj cannot be None\\\")\\n if subj_ is None:\\n raise ValueError(\\\"Argument subj may not be None\\\")\\n if isinstance(subj_, numpy.ndarray) and subj_.dtype is numpy.dtype(numpy.int32) and subj_.flags.contiguous:\\n _subj_copyarray = False\\n _subj_tmp = ctypes.cast(subj_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int32))\\n elif subj_ is not None:\\n _subj_copyarray = True\\n _subj_np_tmp = numpy.zeros(len(subj_),numpy.dtype(numpy.int32))\\n _subj_np_tmp[:] = subj_\\n assert _subj_np_tmp.flags.contiguous\\n _subj_tmp = ctypes.cast(_subj_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_int32))\\n else:\\n _subj_copyarray = False\\n _subj_tmp = None\\n \\n if valij_ is None:\\n raise ValueError(\\\"Argument valij cannot be None\\\")\\n if valij_ is None:\\n raise ValueError(\\\"Argument valij may not be None\\\")\\n if isinstance(valij_, numpy.ndarray) and valij_.dtype is numpy.dtype(numpy.float64) and valij_.flags.contiguous:\\n _valij_copyarray = False\\n _valij_tmp = ctypes.cast(valij_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n elif valij_ is not None:\\n _valij_copyarray = True\\n _valij_np_tmp = numpy.zeros(len(valij_),numpy.dtype(numpy.float64))\\n _valij_np_tmp[:] = valij_\\n assert _valij_np_tmp.flags.contiguous\\n _valij_tmp = ctypes.cast(_valij_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n else:\\n _valij_copyarray = False\\n _valij_tmp = None\\n \\n res = __library__.MSK_XX_putaijlist64(self.__nativep,num_,_subi_tmp,_subj_tmp,_valij_tmp)\\n if res != 0:\\n _,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\",\n \"def update(self):\\n\\n # Ordenamos los personajes por fila, para luego dibujarlos correctamente. Para que no se solapen.\\n self._personajes.sort(self._comparar_coordenadas_personajes)\\n\\n for personaje in self._personajes:\\n if (personaje.andando): # Si está andando.\\n # Si el personaje se encuentra en el centro de la celda a donde debia llegar ...\\n if (personaje.obtener_coordenadas() == self._mapa.obtener_coordenadas_por_posicion((personaje.camino[0][0], personaje.camino[0][1]),self._mapa.CENTER)): \\n del personaje.camino[:1] # Eliminamos esa celda del camino ha seguir porque ya ha llegado a ella. \\n if ((personaje.camino == []) or (personaje.camino == None)): # Si ya no queda camino a seguir...\\n personaje.parar() # Paramos al Personaje.\\n if not(personaje.accion == None): # Si tiene asignada alguna acción después de haber llegado a su destino ...\\n personaje.accion() # Ejecutamos la acción\\n personaje.accion = None # Y limpiamos la acción\\n if (personaje.nombre != \\\"Jugador\\\"): # Si el Personaje no es el Jugador establacemos su dirección final.\\n personaje.actualizar_direccion(personaje.direccion_final)\\n else: # Calculamos la nueva direccion hacia donde tiene que mover\\n # Obtenemos la fila y columna donde se encuenta el personaje.\\n origen = self._mapa.obtener_posicion_por_coordenadas(personaje.obtener_coordenadas())\\n # Establecemos hacia donde tiene que mirar el Personaje para ir en esa dirección.\\n personaje.actualizar_direccion(self._mapa.direcciones.index([personaje.camino[0][0] - origen[0], personaje.camino[0][1] - origen[1]]))\\n else: # Si el personaje no esa todavia en el centro de la celda \\n if (not self._hay_colision(personaje, (personaje.camino[0][0], personaje.camino[0][1]))): # Si no hay colisión en la celda de destino \\n personaje.mover(personaje.obtener_direccion()) # Movemos al personaje en esa dirección.\\n else: # Si hay colision\\n celda_personaje = self._mapa.obtener_posicion_por_coordenadas(personaje.obtener_coordenadas())\\n personaje.actualizar_posicion(self._mapa.obtener_coordenadas_por_posicion((celda_personaje[0], celda_personaje[1]),self._mapa.CENTER))\\n # Volvermos a calcular una ruta para llegar al destino.\\n self.ir_a(personaje, personaje.destino, personaje.direccion_final)\\n \\n personaje.update() # Actualizamos el personaje.\\n \\n for objeto in self._objetos: # Actualizamos los objetos.\\n objeto.update()\\n \\n self._dibujar(\\n )\",\n \"def __init__(self):\\n self.l = []\",\n \"def rosterRowData(self):\",\n \"def __init__(self):\\n self.data = []\",\n \"def __init__(self):\\n self.data = []\",\n \"def __call__(self):\\n return self.array\",\n \"def acumula_nq1(self, nq1, rodada):\\n self.nq1[rodada].append(nq1)\",\n \"def __init__(self):\\n self.s = []\",\n \"def __init__(self):\\n self.s = []\",\n \"def __init__(self):\\n self._data = []\",\n \"def __init__(self):\\n self._data = []\",\n \"def __init__(self):\\n self._data = []\",\n \"def __init__(self):\\n self._data = []\",\n \"def __init__(self):\\n self._data = []\",\n \"def __init__(self):\\n self._data = []\",\n \"def list_to_array(llist, target):\\r\\n while llist.is_empty() == False:\\r\\n target.append(llist.pop(0))\\r\\n \\r\\n return\",\n \"def __init__(self):\\n self.min =[] \\n self.arr = []\",\n \"def __init__(self):\\n self.data = [[] for i in range(self._MOD)]\",\n \"def __init__(self):\\n self.a = []\",\n \"def __init__(self):\\n self.a = []\",\n \"def queue_to_array(queue, target):\\r\\n temp = None\\r\\n \\r\\n while queue.is_empty() == False:\\r\\n temp = queue.remove()\\r\\n target.append(temp)\\r\\n\\r\\n return\",\n \"def arrays(self, select_output):\\n pass\",\n \"def _flatten(self):\\n n = self.B\\n idx = self.nodect - 1\\n self.seq = []\\n while n is not None:\\n n['idx'] = idx\\n self.seq.insert(0, n)\\n idx -= 1\\n n = n['pred']\",\n \"def __init__(self):\\n self.que = []\\n self.tem_que = []\",\n \"def fim_da_rodada(self, recompensa, m, numero_de_cacadores):\\n #print('Jogador 4 {}'.format(self.historico[-1]))\\n pass\",\n \"def obter_lista_arquivos(self):\\n if os.path.exists(self.caminho):\\n return [arq for arq in self.obter_lista_conteudo() \\\\\\n if os.path.isfile(arq)]\\n else:\\n return []\",\n \"def _parseArray(self, options, race, save):\\n\\t\\t\\n\\t\\tif options[1] == True:\\n\\t\\t\\tstart = options[2] \\n\\t\\t\\tfinish = options[3] \\n\\t\\t\\tfor i in range(start, finish): #index are ok\\n\\t\\t\\t\\t# delete invalid chars { } '\\n\\t\\t\\t\\t# line is: {x, y, z, rx, ry, rz, 'gatename'},\\n\\t\\t\\t\\tline = self.content[i].replace(\\\"{\\\", \\\"\\\").replace(\\\"}\\\", \\\"\\\").replace(\\\"'\\\", \\\"\\\").strip().split(\\\",\\\")\\n\\t\\t\\t\\tp = positionClass()\\n\\t\\t\\t\\tp.asTuple = float(line[0]), float(line[1]), float(line[2])\\n\\t\\t\\t\\trot = rotationClass()\\n\\t\\t\\t\\trot.asTuple = float(line[3]), float(line[4]), float(line[5])\\n\\t\\t\\t\\tgatename = line[6].replace(\\\"'\\\", \\\"\\\").replace('\\\"', '').replace(' ', '')\\n\\t\\t\\t\\tsave.append({'pos': p, 'rot': rot, 'entry':None, 'gate':gatename})\",\n \"def array_to_list(llist, source):\\r\\n while source: #a list is considered True as long as it is not empty\\r\\n llist.append(source.pop(0))\\r\\n \\r\\n return\",\n \"def __array__(self):\\n return dict2rec(self)\",\n \"def add_row(matrix):\\n\\tl = len(matrix[0])\\n\\ttemp = matrix[:]\\n\\ttemp += [[0]*l]\\n\\treturn temp\",\n \"def set_ret(self, ret):\\n \\n self.ret = [i for i in ret]\",\n \"def __init__(self):\\n self._array = None\",\n \"def __init__(self):\\n self.arr = array(\\\"i\\\")\",\n \"def append(self, traj):\\n if hasattr(traj, 'trajid'):\\n self.trajectories.append(traj)\\n self.trajids.append(traj.trajid)\\n self.trajcount = len(self.trajectories)\",\n \"def add(self, experience: []):\\n if len(self.buffer) + len(experience) >= self.buffer_size:\\n self.buffer[0:1] = []\\n self.buffer.append(experience)\",\n \"def representarArbolAutomatico(self):\\n if not self.stepByStep:\\n print(\\\"Pintar paredes en auto\\\")\\n # Reinicio la matrix\\n self.reiniciarMatrix()\\n if self.arbol.raiz != None:\\n # Capturo todos los valores\\n for i in self.arbol.returnArbolComoVector():\\n \\n # Esta variable captura si se debe de pintar en x o y\\n xy = int(i[1])\\n cordenadas = i[0]\\n print(\\\"===========NODOS DEL ARBOL=============\\\")\\n print(i)\\n print(\\\"===========NODOS DEL ARBOL=============\\\")\\n # Se pinta en x o y?\\n if xy == 0:\\n self.crearParedX(int(cordenadas[0]), int(cordenadas[1]))\\n else:\\n self.crearParedY(int(cordenadas[0]), int(cordenadas[1]))\\n\\n self.esperarUnRato()\\n\\n print(\\\"========LISTO PARA PINTAR EL SIGUIENTE================\\\")\\n \\n else:\\n print(\\\"Arbol vacio\\\")\",\n \"def __init__(self):\\n self.l = []\\n self.length = 0\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.58543247","0.56239825","0.5529206","0.5529206","0.5529206","0.5529206","0.545713","0.53414357","0.52711475","0.5228194","0.5209801","0.52086926","0.5190303","0.51595616","0.5092528","0.507765","0.50522804","0.50134736","0.49910116","0.49833843","0.4953853","0.49444336","0.49435213","0.49418786","0.49333763","0.4899887","0.4890147","0.48744762","0.48638785","0.48637772","0.48498747","0.4841819","0.4841819","0.48290107","0.48240802","0.4819621","0.48177043","0.48080224","0.48024964","0.47979945","0.4796524","0.47938612","0.47866923","0.47842586","0.4783499","0.4782276","0.47766694","0.4772523","0.47716495","0.47687477","0.4765514","0.47588697","0.47576404","0.4756527","0.4749985","0.47477123","0.47415027","0.4740611","0.4740611","0.4735913","0.4732384","0.47312698","0.47060162","0.46995354","0.469734","0.46863073","0.4684533","0.4684533","0.46808177","0.46497473","0.46475053","0.46475053","0.46436054","0.46436054","0.46436054","0.46436054","0.46436054","0.46436054","0.4631663","0.46286973","0.46162453","0.4611757","0.4611757","0.46066666","0.46051717","0.46009615","0.45915368","0.4588277","0.45816654","0.4566113","0.45640272","0.45591226","0.45586315","0.45554888","0.45525804","0.45424086","0.45391053","0.45382807","0.45356402","0.45330328"],"string":"[\n \"0.58543247\",\n \"0.56239825\",\n \"0.5529206\",\n \"0.5529206\",\n \"0.5529206\",\n \"0.5529206\",\n \"0.545713\",\n \"0.53414357\",\n \"0.52711475\",\n \"0.5228194\",\n \"0.5209801\",\n \"0.52086926\",\n \"0.5190303\",\n \"0.51595616\",\n \"0.5092528\",\n \"0.507765\",\n \"0.50522804\",\n \"0.50134736\",\n \"0.49910116\",\n \"0.49833843\",\n \"0.4953853\",\n \"0.49444336\",\n \"0.49435213\",\n \"0.49418786\",\n \"0.49333763\",\n \"0.4899887\",\n \"0.4890147\",\n \"0.48744762\",\n \"0.48638785\",\n \"0.48637772\",\n \"0.48498747\",\n \"0.4841819\",\n \"0.4841819\",\n \"0.48290107\",\n \"0.48240802\",\n \"0.4819621\",\n \"0.48177043\",\n \"0.48080224\",\n \"0.48024964\",\n \"0.47979945\",\n \"0.4796524\",\n \"0.47938612\",\n \"0.47866923\",\n \"0.47842586\",\n \"0.4783499\",\n \"0.4782276\",\n \"0.47766694\",\n \"0.4772523\",\n \"0.47716495\",\n \"0.47687477\",\n \"0.4765514\",\n \"0.47588697\",\n \"0.47576404\",\n \"0.4756527\",\n \"0.4749985\",\n \"0.47477123\",\n \"0.47415027\",\n \"0.4740611\",\n \"0.4740611\",\n \"0.4735913\",\n \"0.4732384\",\n \"0.47312698\",\n \"0.47060162\",\n \"0.46995354\",\n \"0.469734\",\n \"0.46863073\",\n \"0.4684533\",\n \"0.4684533\",\n \"0.46808177\",\n \"0.46497473\",\n \"0.46475053\",\n \"0.46475053\",\n \"0.46436054\",\n \"0.46436054\",\n \"0.46436054\",\n \"0.46436054\",\n \"0.46436054\",\n \"0.46436054\",\n \"0.4631663\",\n \"0.46286973\",\n \"0.46162453\",\n \"0.4611757\",\n \"0.4611757\",\n \"0.46066666\",\n \"0.46051717\",\n \"0.46009615\",\n \"0.45915368\",\n \"0.4588277\",\n \"0.45816654\",\n \"0.4566113\",\n \"0.45640272\",\n \"0.45591226\",\n \"0.45586315\",\n \"0.45554888\",\n \"0.45525804\",\n \"0.45424086\",\n \"0.45391053\",\n \"0.45382807\",\n \"0.45356402\",\n \"0.45330328\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5356167"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":79085,"cells":{"query":{"kind":"string","value":"Consulta el tiempo actual."},"document":{"kind":"string","value":"def __call__(self):\n \n if self.funciona:\n t = self.timeFunc() - self.t0 - self.retraso\n elif self.t0!=None:\n t = self.parada - self.t0 - self.retraso\n else:\n t = None\n return t"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def TempsCotxe(matricula):\n con=lite.connect('parking.db')\n cursor=con.cursor()\n try:\n cursor.execute(\"SELECT (strftime('%s',DATETIME('now'))-strftime('%s',entrada))/60 from parking where id_cotxe=?\",(matricula,))\n row=cursor.fetchone()\n if row:\n if row[0] < 60:\n print \"El coche amb matricula\",matricula,\" porta\", row[0],\"minuts\"\n print \"en total ha de pagar\",row[0]*0.5,\"€\"\n elif 60 < row[0]<3600:\n print \"El coche amb matricula\",matricula,\" porta\", float(row[0]/60),\"Horas\"\n else:\n print \"El coche amb matricula\",maricula ,\"Porta \",row[0],\n except:\n print \"EEROR NO\"\n con.close()","def prueba_temple_simulado(problema=ProblemaNreinas(8),calendarizacion=None):\n start = time.time()\n solucion = blocales.temple_simulado(problema,calendarizacion)\n #print(\"\\n\\nTemple simulado con calendarización To/(1 + i).\")\n print(\"Costo de la solución: \", problema.costo(solucion))\n print(\"Y la solución es: \")\n print(solucion)\n end = time.time()\n print(\"Tiempo que tarda: Segundos..: \" + str(end - start))","def consultarUltimoInforme(self):\n try:\n cursor = self.__conexion.cursor()\n # Se le suma 1 hora para que este en nuestra franja horaria\n cursor.execute(\n \"SELECT datetime(fecha + 3600, 'unixepoch'), datos, sesion FROM Informes ORDER BY fecha DESC LIMIT 1\")\n self.__conexion.commit()\n datos = cursor.fetchall()\n cursor.close()\n\n return datos\n\n except sqlite3.Error as error:\n print(\"Error al consultar la base de datos: \", error)","def test_time(self):\r\n pass","def f_columnas_tiempos(param_data):\n\n # convertir columna de 'closetime' y 'opentime' utilizando pd.to_datetime\n param_data['closetime'] = pd.to_datetime(param_data['closetime'])\n param_data['opentime'] = pd.to_datetime(param_data['opentime'])\n\n # tiempo transcurrido de una operacion\n param_data['tiempo'] = [(param_data.loc[i, 'closetime'] - param_data.loc[i, 'opentime']).delta / 1e9\n for i in param_data.index]\n\n return param_data","def exptime(self):\n exptime = float(self.get('TRUITIME')) * int(self.get('COADDONE'))\n return exptime","def test_qtd(self):\n self.assertEqual(calcular_qtd_acoes_ate_dia_por_ticker(self.investidor, 'BBPO11', datetime.date(2018, 2, 13)), 617)","def REAL_TIME_ADVANCE(dt):","def get_t(self):\n return self.t","def get_time(self):\r\n\t\tactual_time = '{}, {} de {} del {} ({}:{} {} (UTC))'\r\n\t\tda_taim = actual_time.format(self.wday, self.day, self.mon,\r\n\t\t\t\t\t\t\t\t\t self.year, self.hour, self.min,\r\n\t\t\t\t\t\t\t\t\t self.day_or_night)\r\n\t\treturn da_taim","def find_tim(self):\n start_max = 0\n finish_max = 0\n op_mode = self.op_number + ',' + self.mode_number\n for resource in self.resources:\n end_time = resource.usage[op_mode][\"start_time\"] + resource.usage[op_mode][\"duration\"]\n if end_time > finish_max:\n finish_max = end_time\n start_max = resource.usage[op_mode][\"start_time\"]\n self.tim = finish_max\n self.sim = start_max","def Temp(t):\n return 20 # Need to link to data","def test_details_time(self):\n self.assertLess(self.details.time, datetime.now(timezone.utc))","def tempo(self):\n text = self._get_menu_item_text('Edit->Tempo')\n return float(re.search(r'\\[([0-9.,]+)\\]$', text).group(1))","def le_infotudo(info_file):\n \n infoarq = open(info_file, 'r')\n infodata = infoarq.read()\n infoarq.close()\n \n info_temp = infodata.split('\\n')\n \n # ... lendo data de inicio da simulacao\n info_date = info_temp[5]\n info_date = info_date.split(' ')\n \n lista = list()\n for i in range(len(info_date)):\n if info_date[i] == '':\n lista.append(i)\n \n for j in reversed(lista):\n del info_date[j]\n \n dstart = datetime(int(info_date[2]), int(info_date[1]), int(info_date[0]), int(info_date[3]))\n \n # ... lendo nt e dt\n info_timestep = info_temp[8]\n info_timestep = info_timestep.split(' ')\n \n lista = list()\n for i in range(len(info_timestep)):\n if info_timestep[i] == '':\n lista.append(i)\n \n for j in reversed(lista):\n del info_timestep[j]\n \n nt = info_timestep[0]\n dt = info_timestep[1]\n dt = dt.split(\".\")\n dt = dt[0]\n \n # ... lendo nc\n info_nc = info_temp[11]\n info_nc = info_nc.split(' ')\n \n lista = list()\n for i in range(len(info_nc)):\n if info_nc[i] == '':\n lista.append(i)\n \n for j in reversed(lista):\n del info_nc[j]\n \n nc = info_nc[0]\n \n return int(nc), int(nt), int(dt), dstart","def le_infotudo(info_file):\n \n infoarq = open(info_file, 'r')\n infodata = infoarq.read()\n infoarq.close()\n \n info_temp = infodata.split('\\n')\n \n # ... lendo data de inicio da simulacao\n info_date = info_temp[5]\n info_date = info_date.split(' ')\n \n lista = list()\n for i in range(len(info_date)):\n if info_date[i] == '':\n lista.append(i)\n \n for j in reversed(lista):\n del info_date[j]\n \n dstart = datetime(int(info_date[2]), int(info_date[1]), int(info_date[0]), int(info_date[3]))\n \n # ... lendo nt e dt\n info_timestep = info_temp[8]\n info_timestep = info_timestep.split(' ')\n \n lista = list()\n for i in range(len(info_timestep)):\n if info_timestep[i] == '':\n lista.append(i)\n \n for j in reversed(lista):\n del info_timestep[j]\n \n nt = info_timestep[0]\n dt = info_timestep[1]\n dt = dt.split(\".\")\n dt = dt[0]\n \n # ... lendo nc\n info_nc = info_temp[11]\n info_nc = info_nc.split(' ')\n \n lista = list()\n for i in range(len(info_nc)):\n if info_nc[i] == '':\n lista.append(i)\n \n for j in reversed(lista):\n del info_nc[j]\n \n nc = info_nc[0]\n \n return int(nc), int(nt), int(dt), dstart","def le_infotudo(info_file):\n \n infoarq = open(info_file, 'r')\n infodata = infoarq.read()\n infoarq.close()\n \n info_temp = infodata.split('\\n')\n \n # ... lendo data de inicio da simulacao\n info_date = info_temp[5]\n info_date = info_date.split(' ')\n \n lista = list()\n for i in range(len(info_date)):\n if info_date[i] == '':\n lista.append(i)\n \n for j in reversed(lista):\n del info_date[j]\n \n dstart = datetime(int(info_date[2]), int(info_date[1]), int(info_date[0]), int(info_date[3]))\n \n # ... lendo nt e dt\n info_timestep = info_temp[8]\n info_timestep = info_timestep.split(' ')\n \n lista = list()\n for i in range(len(info_timestep)):\n if info_timestep[i] == '':\n lista.append(i)\n \n for j in reversed(lista):\n del info_timestep[j]\n \n nt = info_timestep[0]\n dt = info_timestep[1]\n dt = dt.split(\".\")\n dt = dt[0]\n \n # ... lendo nc\n info_nc = info_temp[11]\n info_nc = info_nc.split(' ')\n \n lista = list()\n for i in range(len(info_nc)):\n if info_nc[i] == '':\n lista.append(i)\n \n for j in reversed(lista):\n del info_nc[j]\n \n nc = info_nc[0]\n \n return int(nc), int(nt), int(dt), dstart","def le_infotudo(info_file):\n \n infoarq = open(info_file, 'r')\n infodata = infoarq.read()\n infoarq.close()\n \n info_temp = infodata.split('\\n')\n \n # ... lendo data de inicio da simulacao\n info_date = info_temp[5]\n info_date = info_date.split(' ')\n \n lista = list()\n for i in range(len(info_date)):\n if info_date[i] == '':\n lista.append(i)\n \n for j in reversed(lista):\n del info_date[j]\n \n dstart = datetime(int(info_date[2]), int(info_date[1]), int(info_date[0]), int(info_date[3]))\n \n # ... lendo nt e dt\n info_timestep = info_temp[8]\n info_timestep = info_timestep.split(' ')\n \n lista = list()\n for i in range(len(info_timestep)):\n if info_timestep[i] == '':\n lista.append(i)\n \n for j in reversed(lista):\n del info_timestep[j]\n \n nt = info_timestep[0]\n dt = info_timestep[1]\n dt = dt.split(\".\")\n dt = dt[0]\n \n # ... lendo nc\n info_nc = info_temp[11]\n info_nc = info_nc.split(' ')\n \n lista = list()\n for i in range(len(info_nc)):\n if info_nc[i] == '':\n lista.append(i)\n \n for j in reversed(lista):\n del info_nc[j]\n \n nc = info_nc[0]\n \n return int(nc), int(nt), int(dt), dstart","def le_infotudo(info_file):\n \n infoarq = open(info_file, 'r')\n infodata = infoarq.read()\n infoarq.close()\n \n info_temp = infodata.split('\\n')\n \n # ... lendo data de inicio da simulacao\n info_date = info_temp[5]\n info_date = info_date.split(' ')\n \n lista = list()\n for i in range(len(info_date)):\n if info_date[i] == '':\n lista.append(i)\n \n for j in reversed(lista):\n del info_date[j]\n \n dstart = datetime(int(info_date[2]), int(info_date[1]), int(info_date[0]), int(info_date[3]))\n \n # ... lendo nt e dt\n info_timestep = info_temp[8]\n info_timestep = info_timestep.split(' ')\n \n lista = list()\n for i in range(len(info_timestep)):\n if info_timestep[i] == '':\n lista.append(i)\n \n for j in reversed(lista):\n del info_timestep[j]\n \n nt = info_timestep[0]\n dt = info_timestep[1]\n dt = dt.split(\".\")\n dt = dt[0]\n \n # ... lendo nc\n info_nc = info_temp[11]\n info_nc = info_nc.split(' ')\n \n lista = list()\n for i in range(len(info_nc)):\n if info_nc[i] == '':\n lista.append(i)\n \n for j in reversed(lista):\n del info_nc[j]\n \n nc = info_nc[0]\n \n return int(nc), int(nt), int(dt), dstart","def cobroEfectivo(self):\n if self.total_a_pagar == 0:\n QtGui.QMessageBox.information(self,\"Aviso\",\"El saldo restante a pagar es cero\")\n else:\n self.rbtnEfectivo.setChecked(True)\n monto_a_pagar, ok = QtGui.QInputDialog.getDouble(self,\"Cobro Efectivo\",\"Ingrese monto a pagar\",0,0,2000,2)\n\n if ok:\n if monto_a_pagar >= self.total_a_pagar:\n QtGui.QMessageBox.information(self,\"Cobro Efectivo\",\"Su vuelto es:%.2f\" % (monto_a_pagar - self.total_a_pagar))\n temp = [\"Efectivo\",monto_a_pagar]\n self.detalles_cobro[self.tablePagos.rowCount()] = temp\n self.total_a_pagar = 0\n elif monto_a_pagar == 0:\n QtGui.QMessageBox.information(self,\"Aviso\",\"El monto ingresado no puede ser cero\")\n else:\n temp = [\"Efectivo\",monto_a_pagar]\n self.detalles_cobro[self.tablePagos.rowCount()] = temp\n self.total_a_pagar -= monto_a_pagar\n\n self.actualizar_total()\n self.actualizar_tabla()","def comptcptotaltimer(self) :\n\t\ttry :\n\t\t\treturn self._comptcptotaltimer\n\t\texcept Exception as e:\n\t\t\traise e","def getTime(self) -> float:\n return self.t","def med_t_changed(self):\n\t\tprint \"medianus t changed\"\n\t\tmed_t_cbox = self.ui.findChild(QWidget, \"med_t_cbox\")\t\n\t\tnew_med_t = med_t_cbox.currentText()\n\t\t# todo: calculate new values","def test_tema(self):\n periods = 200\n tema = qufilab.tema(self.close, periods)\n tema_talib = talib.TEMA(self.close, periods)\n np.testing.assert_allclose(tema, tema_talib, rtol = self.tolerance)","def get_time(self) -> float:\n raise NotImplementedError()","def tt(self):\n return self.MJD + self.tt_ut1 + 2400000.5","def total_te(self):\r\n return sum(map(lambda x: self.times[x]['te'], self.times))","def test_TPt(self):\n\n test_value = self.portfolio.calculate_total_performance(\n *self.boarder)[self.test_row_number]\n calculated_value = self.manual_cumprod(\n self.portfolio._get_total_portfolio)\n self.assertAlmostEqual(test_value, calculated_value)","def elemento_actual(self):\n\t\tif not self.actual:\n\t\t\treturn None\n\t\treturn self.actual.dato","def time(self):\r\n raise NotImplementedError","def _get_optuna_time_budget(self):\n self._validate_optuna_time_budget()\n\n if self.optuna_time_budget is None:\n if self._get_mode() == \"Optuna\":\n return 3600\n return None\n else:\n if self._get_mode() != \"Optuna\":\n # use only for mode Optuna\n return None\n return deepcopy(self.optuna_time_budget)","def time(self):\n raise NotImplementedError()","def test_calculate_value(self):\n user = CustomUser.objects.get(username = \"Test User\")\n start_date = timezone.now().replace(day=1,month=8,year=2020)\n end_date = start_date + timedelta(days=30) \n expected_result = 720\n actual_result = calculate_total_user_expense_value_in_timeperiod(user, start_date, end_date)\n self.assertEquals(expected_result, actual_result)","def __get_elapsed__(self):\n elapsed = (self.__end_time - self.__start_time)\n unit = \"seconds\"\n if elapsed >= 3600:\n unit = \"minutes\"\n hours = elapsed / 3600\n minutes = hours % 60\n hours = floor(hours)\n print(self.name, \"took\", str(hours), \"hours and\", \"{0:.2f}\".format(minutes), unit, \"to complete\")\n elif elapsed >= 60:\n minutes = floor(elapsed / 60)\n seconds = elapsed % 60\n print(self.name, \"took\", str(minutes), \"minutes and\", \"{0:.2f}\".format(seconds), unit, \"to complete\")\n else:\n print(self.name, \"took\", \"{0:.2f}\".format(elapsed), unit, \"to complete\")","def get_task_time(self, task):\n task.task_time = TASK_TYPES[task.task_type]\n print(\"Fetched task time\")","def gettime(self):\n return self.t","def get_time(self):\n return self.get_timed() / 10.0","def ti_func(self):\n return self.ti.val - self.calc_ti()","def get_time_info(self):\n\n raise NotImplementedError","def actualizar_puntaje(self):\r\n pass","def mostrar_ultimo(self):\n participantes = self.__puntuacion_total()\n podio = self.__armar_podio(participantes)\n print(\n f\"\"\"\n ===================================\n ========== ULTIMO PUESTO ==========\n ===================================\n id disparo: {podio[0]['idDisparo']},\n Disparos: {podio[0]['disparos']},\n Numero participante: {podio[0]['nroParticipante']},\n Nombre: {podio[0]['nombre']},\n Apellido: {podio[0]['apellido']},\n Edad: {podio[0]['edad']},\n sexo: {podio[0]['sexo']},\n Puntaje: {podio[0]['puntaje_total']}\n ===================================\n ===================================\n \"\"\"\n )","def get_tema(data):\n if data is None:\n raise EmptyDataError('[!] Invalid data value')\n\n result = TA.TEMA(data)\n if result is None:\n raise IndicatorException\n return result","def test_time_field():","def test_work_time_saved(self):\n\n self.create_page.configure()\n\n from_time = '20.10.2014'\n to_time = '25.10.2014'\n days_count = 6\n\n self.create_page.ad_form.set_work_time_by_input(from_time, to_time)\n\n info_page = self.create_page.ad_form.submit()\n edit_page = info_page.edit_page()\n\n text = edit_page.ad_form.get_work_time_line_text()\n actual_days_count = int(text.split()[0])\n\n info_page.delete()\n\n self.assertEquals(days_count, actual_days_count)","def update_time_base(self, event):\n print(\"TimeBase.update_time_base()\")\n print(\"Base de temps : \", self.scale_T.get())\n if not isinstance(self.parent, Tk):\n self.parent.update_time(self.scale_T.get())","def _get_time_info(self, keys: list[str]):\n if self.is_info_v2:\n if not self.is_on:\n return 0\n return self.int_or_none(self._data.get(keys[1]))\n return self._data.get(keys[0])","def end_time(self) -> float:\r\n ...","def update_time(self):\n pass # Do nothing","def testEjemploTp(self):\n azul = [0, 4, 5, 0]\n rojo = [1, 7, 4, 0]\n amarillo = [3, 6, 8, 0]\n negro = [6, 10, 10, 0]\n magenta = [7, 8, 12, 0]\n verde = [9, 11, 11, 0]\n perfiles = []\n perfiles.append(azul)\n perfiles.append(rojo)\n perfiles.append(amarillo)\n perfiles.append(negro)\n perfiles.append(magenta)\n perfiles.append(verde)\n perfil = Perfil.Perfil()\n resultadoEsperado = [0, 4, 1, 7, 4, 6, 6, 10, 9, 11, 11, 8, 12]\n for x in range(10000):\n inicial = random_integers(6, 0)\n inicial = inicial*4\n perfilOriginal = []\n for i in range (inicial, len(perfiles)+inicial, 1):\n perfilOriginal += perfiles[i%len(perfiles)]\n \n resultado = perfil.calcularPerfil(perfilOriginal, 0)\n self.assertEqual(resultadoEsperado, resultado)","def tt_ut1(self):\n # return the delta time for the input date converted to days\n return interpolate_delta_time(_delta_file, self.tide)","def test_day_microseconds_now(self):\n day_microseconds = utils.day_microseconds()\n self.assertIsInstance(day_microseconds, int)\n self.assertGreaterEqual(day_microseconds, 0)\n self.assertLess(day_microseconds, 86400000000)","def Tt(s_c, point, system):\n Tx = tra(s_c, point, system)\n Tx.get_time()\n return Tx.time","def t(self):\n return self._t","def t(self):\n return self._t","def __get_emptiest (self, person):\n doubles = []\n for scheduling_unit in person.get_scheduling_units ( ):\n doubles.append ((scheduling_unit, self.__calculate_emptiness (scheduling_unit)))\n \n doubles.sort (key=lambda trio: trio[1])\n \n scheduling_units = []\n for double in doubles:\n scheduling_units.append (double[0])\n \n return scheduling_units","def desired_measurement_entity_response_time(self, status: str) -> int | None:\n defaults = {\n \"confirmed\": 180,\n \"false_positive\": 180,\n \"wont_fix\": 180,\n \"fixed\": 7,\n }\n default = defaults.get(status)\n return int(self.get(\"desired_response_times\", {}).get(status, default)) if status in defaults else None","def computeTm(self):\n #first step is finding the derivative series of the well\n x = self.temperatures\n if self.fluorescence == None:\n self.Tm = None\n return\n y = self.fluorescence\n \n xdiff = np.diff(x)\n dydx = -np.diff(y)/xdiff\n #the derivative series, has one less index since there is one fewer differences than points\n seriesDeriv = pandas.Series(dydx, x[:-1])\n \n #now that we have the derivative series, we can find the Tm\n lowestPoint = 0\n lowestPointIndex = None\n \n #gets number of signchanges between max and min of the curve, used to determin if the curve\n #is complex or not\n lowestPoint2 = 1\n lowestIndex2 = None\n highestPoint = 0\n highestIndex = None\n previous = None\n for i, value in enumerate(self.fluorescence[:-1]):\n if value > highestPoint:\n highestPoint = value\n highestIndex = i\n if highestIndex == 0 :\n highestPoint = 0\n highestIndex = None\n for i, value in enumerate(self.fluorescence[:-1]):\n if value<lowestPoint2:\n lowestPoint2 = value\n lowestIndex2 = i\n for i, value in enumerate(self.fluorescence[:-1]):\n if i < lowestIndex2:\n continue\n if value > highestPoint:\n highestPoint = value\n highestIndex = i\n else:\n for i, value in enumerate(self.fluorescence[:-1]):\n if i > highestIndex:\n break\n if value<lowestPoint2:\n lowestPoint2 = value\n lowestIndex2 = i\n signChange = False\n for ind in seriesDeriv.index[lowestIndex2+1:highestIndex]:\n \n if previous:\n if seriesDeriv[ind] + SIGN_CHANGE_THRESH < 0 and previous - SIGN_CHANGE_THRESH > 0:\n signChange = True\n if seriesDeriv[ind] - SIGN_CHANGE_THRESH > 0 and previous + SIGN_CHANGE_THRESH < 0:\n signChange = True\n # if seriesDeriv[ind] == 0:\n # signChangeCount += 1\n previous = seriesDeriv[ind]\n\n \n #finding the lowest point and its index on the derivative series\n #only search for Tm up to 90degrees, since last part is hard to predict\n #and often gives false positives\n ignoreNum = int(len(seriesDeriv.index)*0.125)\n for ind in seriesDeriv.index[:-ignoreNum]:\n if seriesDeriv[ind]<lowestPoint:\n lowestPoint = seriesDeriv[ind]\n lowestPointIndex = ind\n \n #TODO working, tms not steep enough added to complex\n #if the slope is not steep enough, tm remains saved, but curve is grouped with the\n #complex curves (now known as the unreliable group)\n #if lowestPoint > -0.000001 / (normalisationFactor / saturation max point of all curves thing):\n # print self.name, 'lowestpoint too small', lowestPoint\n # self.complex = True\n\n #if lowest point is the first index, then no curve fit is required\n if lowestPointIndex == seriesDeriv.index[0]:\n tm = lowestPointIndex\n self.Tm = tm\n \n #set complex to true if curve was complex\n if signChange:\n self.complex = True\n return\n \n #could not find any Tm\n if lowestPointIndex == None:\n self.Tm = None\n \n #if no tm, the curve hopefully be picked up as a monotonic/in the noise/saturated/outlier\n #however, if this does not happen, the curve remains as complex\n self.complex = True\n return \n \n #the indices in the series either side of the lowest index\n #note the first list is indexed e.g. list[i] where i is the section using .index\n leftIndex = [ind for ind in seriesDeriv.index][[ind for ind in seriesDeriv.index].index(lowestPointIndex)-1]\n rightIndex = [ind for ind in seriesDeriv.index][[ind for ind in seriesDeriv.index].index(lowestPointIndex)+1]\n \n \n #matrices used to fit a parabola to the 3 points\n Y=[seriesDeriv[leftIndex],\n seriesDeriv[lowestPointIndex],\n seriesDeriv[rightIndex]]\n \n A=[[leftIndex**2, leftIndex, 1],\n [lowestPointIndex**2, lowestPointIndex, 1],\n [rightIndex**2, rightIndex, 1]]\n \n #solve for b, in the form Y=Ab\n (a,b,c) = np.linalg.solve(A,Y)\n \n #initialise tm to left most point of relevant curve\n tm=seriesDeriv[leftIndex]\n tmValue=0\n #make tm the lowest point on the fitted parabola rounded to nearest 0.01\n for x in np.arange(leftIndex,rightIndex,0.01):\n point = (a*(x**2) + b*x + c)\n if tmValue > point:\n tmValue = point\n tm = x\n self.Tm = tm\n \n #again check for complex shape before returning\n if signChange:\n self.complex = True\n\n\n averagePoint = (lowestPoint2 +highestPoint) / 2\n i = lowestIndex2\n while self.fluorescence[i]<averagePoint:\n i += 1;\n\n # estimates tm by another method and if the difference is too large the curve is considred complex\n if (self.temperatures[i] -self.Tm)**2 > 5**2:\n self.complex=True\n return","def do_timing(self):\n sts = datetime.datetime.now()\n _ = dep.read_env(get_path('good_env.txt'))\n ets = datetime.datetime.now()\n print(\"%.5f reads per second\" % (1. / (ets - sts).total_seconds(),))\n self.assertEquals(1, 2)","def tic(self):\n return self._timestamp","def start_time(self) -> float:\r\n ...","def current_time(cls) -> float:","def time(self) -> int:\n pass","def get_time(self):\n return self.run_command('get_time')[0]","def _get_tb(I, nu, beam):\n from astropy import units as u\n return (1222.0*I/(nu**2*(beam.minor/1.0).to(u.arcsecond)*(beam.major/1.0).to(u.arcsecond))).value","def actual_time():\n return _time.time()","def calcula_aptitud(self, individuo, costo=None):","def get_torsion_info(self):\n return","def test_queryset_total_time_no_records(db):\n assert models.TimeRecord.objects.total_time() == datetime.timedelta(0)","def getTempo():\r\n global dauer\r\n \r\n dauer = 0.0\r\n counter = 1\r\n\r\n for x in midi_data.get_tempo_changes(): #pretty_midi saves the tempo of a midi-file in nested-arrays, therefore a few for-loops and if statements are necessary\r\n for e in x:\r\n if e > 0:\r\n if counter > 0:\r\n tempi.append(round(e))\r\n counter = 0\r\n break\r\n \r\n dauer = 60000/(e/4)","def plotTime(self):\n plt.figure()\n t = [i for i in range(len(self.nodes_infected))]\n print(t)\n plt.title('Nodos infectados vs Tiempo')\n plt.xlabel('Instantes de tiempo')\n plt.ylabel('# de nodos infectados')\n plt.plot(t, self.nodes_infected)\n plt.grid(True)\n plt.show()","def cuenta_regresiva(self):\r\n digito = 10\r\n tiempo = datetime.now()\r\n delta_ = timedelta(seconds=1)\r\n while digito > 0:\r\n if datetime.now() - tiempo > delta_:\r\n tiempo = datetime.now()\r\n digito -= 1\r\n self.counter_signal.emit(digito)\r\n self.juguemos()","def getTimes():","def getTimes():","def getTimes():","def test_TRit(self):\n\n prices = self._convert_df_to_list(self.prices)\n currency = self._convert_df_to_list(self.currency)\n\n manual_total = self.list_multiplication(prices, currency)\n manual_calculated = list(self._manual_calculate_formal(manual_total))\n\n self.portfolio._generate_total()\n test_column = self._convert_df_to_list(self.portfolio._df_total)\n\n self.assertAlmostEqual(self._clear_column(manual_calculated),\n self._clear_column(test_column))","def get_umeastime(self):\n return self.utime","def u_dt(self, H, tim):\n\t\tif self.tb_model:\n\t\t\t#cond = QnIni(k=self.k,ctrlt=self.ctrlt)\n\t\t\tdx,dy,dz = self.QnIni.dvec(self.ctrlt[tim]) \n\t\t\td = np.sqrt(dx**2 + dy**2 + dz**2)*self.dt\n\t\t\tu = np.cos(d)*self.pau_i -1j*self.dt/d*np.sin(d)*H\n\n\t\telse:\n\t\t\tu = expm(-1j*H*self.dt)\n\n\t\treturn u","def test_datetime_microseconds(self):\n\n conn = self.connect()\n c = conn.cursor()\n dt = datetime.datetime(2013, 11, 12, 9, 9, 9, 123450)\n c.execute(\"create table test_datetime (id int, ts datetime(6))\")\n try:\n c.execute(\"insert into test_datetime values (%s, %s)\", (1, dt))\n c.execute(\"select ts from test_datetime\")\n self.assertEqual((dt,), c.fetchone())\n finally:\n c.execute(\"drop table test_datetime\")","def test_time(self):\n conn = self.database.connection()\n cursor = conn.cursor()\n dialect = self.database.dialect()\n dbapi = self.database.dbapi()\n query = dialect.translate('DROP TABLE test_time')\n try:\n cursor.execute(query)\n except dbapi.Error:\n conn.rollback()\n query = dialect.translate('CREATE TABLE test_time ' \\\n '( value TIME NOT NULL )')\n cursor.execute(query)\n data = []\n rr = random.randrange\n query = 'INSERT INTO test_time VALUES (%s)'\n for i in range(100):\n item = datetime.time(rr(0,24), rr(0,60), rr(0,60))\n data.append(item)\n cursor.execute(query, (item,))\n query = 'SELECT * FROM test_time'\n cursor.execute(query)\n result = cursor.fetchall()\n for row in result:\n item = row[0]\n assert isinstance(item, datetime.time)\n assert item in data\n data.remove(item)\n query = dialect.translate('DELETE FROM test_time')\n cursor.execute(query)\n query = dialect.translate('DROP TABLE test_time')\n cursor.execute(query)\n conn.commit()","def get_time(self):\n return self.widget().time()","def m_ps_FieldsUpdated(self, sender, e):\r\n ltp = e.Fields.GetLastTradedPriceField()\r\n ltq = e.Fields.GetLastTradedQuantityField()\r\n print(\"ltp and ltq success...\")\r\n if ltp.HasChanged or ltq.HasChanged:\r\n print(ltp.Value, ltq.Value)\r\n ltp = ltp.Value\r\n ltpi = int(ltp.ToTicks())\r\n self.process_row({'time' :pd.datetime.now(), 'close' : ltpi}, key = \"nk\")","def get_temporal(self):\n self.unimpl_base_class()","def eta(self):\n eta = self.fields['eta']\n if eta >= 0:\n return datetime.timedelta(seconds=eta)\n else:\n ValueError('eta not valid')","def test_timesheet_uom(self):\n # create SO and confirm it\n uom_days = self.env.ref('product.product_uom_day')\n sale_order = self.env['sale.order'].create({\n 'partner_id': self.partner_usd.id,\n 'partner_invoice_id': self.partner_usd.id,\n 'partner_shipping_id': self.partner_usd.id,\n 'order_line': [\n (0, 0, {\n 'name': self.product_delivery_timesheet3.name,\n 'product_id': self.product_delivery_timesheet3.id,\n 'product_uom_qty': 5,\n 'product_uom': uom_days.id,\n 'price_unit': self.product_delivery_timesheet3.list_price\n })\n ],\n 'pricelist_id': self.pricelist_usd.id,\n })\n sale_order.action_confirm()\n task = self.env['project.task'].search([('sale_line_id', '=', sale_order.order_line.id)])\n\n # let's log some timesheets\n self.env['account.analytic.line'].create({\n 'name': 'Test Line',\n 'project_id': sale_order.project_project_id.id,\n 'task_id': task.id,\n 'unit_amount': 16,\n 'employee_id': self.employee_manager.id,\n })\n self.assertEqual(sale_order.order_line.qty_delivered, 2, 'Sale: uom conversion of timesheets is wrong')\n\n self.env['account.analytic.line'].create({\n 'name': 'Test Line',\n 'project_id': sale_order.project_project_id.id,\n 'task_id': task.id,\n 'unit_amount': 24,\n 'employee_id': self.employee_user.id,\n })\n sale_order.action_invoice_create()\n self.assertEqual(sale_order.invoice_status, 'invoiced', 'Sale Timesheet: \"invoice on delivery\" timesheets should not modify the invoice_status of the so')","def test_time(self):\n result = self.test_client.time\n\n assert result == \"15093049123\"","def test_fields_effort_time_units_dictionary_success(self, _mock_check):\n field = EffortField(time_units={\"minute\": (\"minute\", \"minutes\")})\n\n errors = field.check()\n self.assertEqual(len(errors), 0)","def compute_iactT(data):\n\t# get only the timestamps\n\ttime = data[0]\n\tprevT = time[0]\n\n\ttotalT = len(time)*0.1\n\n\treturn totalT","def Montecarlo(h,porcentaje,nombre):\n tm = time()\n print('Se esta procesando el '+str(porcentaje)+'% de particulas')\n print('\\n')\n redor = Quitar(porcentaje,redhex)\n Guardar_archivo(redor,nombre + 'original')\n \n redopt = Optim(redor,h,1)\n fin = datetime.now()\n Guardar_archivo(redopt,nombre +'optim')\n print('Calculado para '+str(len(redor))+' particulas')\n Dt2 = time() -tm\n print('en un tiempo de '+str(Dt2)+'s. \\n')\n print(fin)\n return()","def calculation_time(self) -> float:\n return self.__calculation_time","def info(self):\n out = f\"sec: {self.em_sec()}\\nmin: {self.em_min()}\"\n out += f\"\\nhora: {self.em_hora()}\\ndia: {self.em_dia()}\"\n return out","def check(self):\r\n boto.log.info('checking Task[%s]-now=%s, last=%s' % (self.name, self.now, self.last_executed))\r\n\r\n if self.hourly and not self.last_executed:\r\n return 0\r\n \r\n if self.daily and not self.last_executed:\r\n if int(self.hour) == self.now.hour:\r\n return 0\r\n else:\r\n return max( (int(self.hour)-self.now.hour), (self.now.hour-int(self.hour)) )*60*60\r\n\r\n delta = self.now - self.last_executed\r\n if self.hourly:\r\n if delta.seconds >= 60*60:\r\n return 0\r\n else:\r\n return 60*60 - delta.seconds\r\n else:\r\n if int(self.hour) == self.now.hour:\r\n if delta.days >= 1:\r\n return 0\r\n else:\r\n return 82800 # 23 hours, just to be safe\r\n else:\r\n return max( (int(self.hour)-self.now.hour), (self.now.hour-int(self.hour)) )*60*60","def important_time(self):\n\t\twork_s = self.work_time().seconds\n\t\tbreak_s = self.break_time().seconds\n\t\tif self.status():\n\t\t\tremaining_time_s = tomato(work_s, break_s)\n\t\telse:\n\t\t\tremaining_time_s = potato(work_s, break_s)\n\n\t\timp_time = datetime.now() + timedelta(0, remaining_time_s)\n\t\treturn imp_time","def get_system_time(self):\r\n method = self.public_endpoints['system_time']['method']\r\n url = self.base_url + self.public_endpoints['system_time']['url']\r\n req = requests.request(method, url)\r\n res = req.json()\r\n\r\n if res['success'] == True:\r\n return res[\"result\"]\r\n else:\r\n return res","def test_estimate_data_time__correct_doy():\n parser = IMFV283Parser()\n # BOU aka normal\n transmission = '17274013121'\n day = 274\n minute = 72\n (data_time, transmit_time, corrected) = \\\n parser._estimate_data_time(transmission, day, minute)\n assert_equals(data_time, UTCDateTime('2017-10-01T01:12:00Z'))\n assert_equals(transmit_time, UTCDateTime('2017-10-01T01:31:21Z'))\n assert_equals(corrected, False)","def remaining_ms():","def _calculate_tusd_energia_reais(\n self, company_month_data, company_params, tarifas_repository\n ):\n tarifas_month_data_p = self._get_fares_month_data(\n tarifas_repository, company_params, posto=\"Ponta\"\n )\n\n tarifas_month_data_fp = self._get_fares_month_data(\n tarifas_repository, company_params, posto=\"Fora Ponta\"\n )\n\n tusd_energia_p = tarifas_month_data_p[\"tusde\"]\n tusd_energia_fp = tarifas_month_data_fp[\"tusde\"]\n\n consumo_p = company_month_data[\"consumo_ponta\"]\n consumo_fp = company_month_data[\"consumo_fora_ponta\"]\n\n tusd_energia_p_reais = consumo_p*tusd_energia_p\n tusd_energia_fp_reais = consumo_fp*tusd_energia_fp\n\n return {\n \"tusd_energia_p_reais\": tusd_energia_p_reais,\n \"tusd_energia_fp_reais\": tusd_energia_fp_reais\n }","def test_time_status(self):\n result = self.test_client.time_status\n\n assert result == \"12312\"","def test_fund_duration_end(self):\r\n with self.client as c:\r\n results = c.post(\r\n \"/duracion-de-fondos\",\r\n data=json.dumps(DURACION_DE_FONDO_JSON_0),\r\n headers=TestRetirementCalculator.request_headers,\r\n )\r\n data = json.loads(results.data)\r\n\r\n self.assertDictEqual(data, DURACION_DE_FONDO_RESULT_0)","def Ingresar(frm):\r\n #se asigna el valor de la variable seguir\r\n \r\n #se le pide al usuario que ingresa la altura\r\n posinicial=float(frm.txtposinicial.GetValue())\r\n #posinicial=raw_input(\"Ingrese la altura desde donde se va dejar caer (en metros): \")\r\n #se condiona para que solo permite ingresar numero positivos \r\n \r\n posinicial=float(posinicial)\r\n if posinicial>0:\r\n posinicial=posinicial+2\r\n return posinicial","def get_answer_time(self):\n sec = (self.updated_at - self.created_at).total_seconds()\n return f'{int((sec / 60) % 60):02d}:{int(sec):02d}'"],"string":"[\n \"def TempsCotxe(matricula):\\n con=lite.connect('parking.db')\\n cursor=con.cursor()\\n try:\\n cursor.execute(\\\"SELECT (strftime('%s',DATETIME('now'))-strftime('%s',entrada))/60 from parking where id_cotxe=?\\\",(matricula,))\\n row=cursor.fetchone()\\n if row:\\n if row[0] < 60:\\n print \\\"El coche amb matricula\\\",matricula,\\\" porta\\\", row[0],\\\"minuts\\\"\\n print \\\"en total ha de pagar\\\",row[0]*0.5,\\\"€\\\"\\n elif 60 < row[0]<3600:\\n print \\\"El coche amb matricula\\\",matricula,\\\" porta\\\", float(row[0]/60),\\\"Horas\\\"\\n else:\\n print \\\"El coche amb matricula\\\",maricula ,\\\"Porta \\\",row[0],\\n except:\\n print \\\"EEROR NO\\\"\\n con.close()\",\n \"def prueba_temple_simulado(problema=ProblemaNreinas(8),calendarizacion=None):\\n start = time.time()\\n solucion = blocales.temple_simulado(problema,calendarizacion)\\n #print(\\\"\\\\n\\\\nTemple simulado con calendarización To/(1 + i).\\\")\\n print(\\\"Costo de la solución: \\\", problema.costo(solucion))\\n print(\\\"Y la solución es: \\\")\\n print(solucion)\\n end = time.time()\\n print(\\\"Tiempo que tarda: Segundos..: \\\" + str(end - start))\",\n \"def consultarUltimoInforme(self):\\n try:\\n cursor = self.__conexion.cursor()\\n # Se le suma 1 hora para que este en nuestra franja horaria\\n cursor.execute(\\n \\\"SELECT datetime(fecha + 3600, 'unixepoch'), datos, sesion FROM Informes ORDER BY fecha DESC LIMIT 1\\\")\\n self.__conexion.commit()\\n datos = cursor.fetchall()\\n cursor.close()\\n\\n return datos\\n\\n except sqlite3.Error as error:\\n print(\\\"Error al consultar la base de datos: \\\", error)\",\n \"def test_time(self):\\r\\n pass\",\n \"def f_columnas_tiempos(param_data):\\n\\n # convertir columna de 'closetime' y 'opentime' utilizando pd.to_datetime\\n param_data['closetime'] = pd.to_datetime(param_data['closetime'])\\n param_data['opentime'] = pd.to_datetime(param_data['opentime'])\\n\\n # tiempo transcurrido de una operacion\\n param_data['tiempo'] = [(param_data.loc[i, 'closetime'] - param_data.loc[i, 'opentime']).delta / 1e9\\n for i in param_data.index]\\n\\n return param_data\",\n \"def exptime(self):\\n exptime = float(self.get('TRUITIME')) * int(self.get('COADDONE'))\\n return exptime\",\n \"def test_qtd(self):\\n self.assertEqual(calcular_qtd_acoes_ate_dia_por_ticker(self.investidor, 'BBPO11', datetime.date(2018, 2, 13)), 617)\",\n \"def REAL_TIME_ADVANCE(dt):\",\n \"def get_t(self):\\n return self.t\",\n \"def get_time(self):\\r\\n\\t\\tactual_time = '{}, {} de {} del {} ({}:{} {} (UTC))'\\r\\n\\t\\tda_taim = actual_time.format(self.wday, self.day, self.mon,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t self.year, self.hour, self.min,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t self.day_or_night)\\r\\n\\t\\treturn da_taim\",\n \"def find_tim(self):\\n start_max = 0\\n finish_max = 0\\n op_mode = self.op_number + ',' + self.mode_number\\n for resource in self.resources:\\n end_time = resource.usage[op_mode][\\\"start_time\\\"] + resource.usage[op_mode][\\\"duration\\\"]\\n if end_time > finish_max:\\n finish_max = end_time\\n start_max = resource.usage[op_mode][\\\"start_time\\\"]\\n self.tim = finish_max\\n self.sim = start_max\",\n \"def Temp(t):\\n return 20 # Need to link to data\",\n \"def test_details_time(self):\\n self.assertLess(self.details.time, datetime.now(timezone.utc))\",\n \"def tempo(self):\\n text = self._get_menu_item_text('Edit->Tempo')\\n return float(re.search(r'\\\\[([0-9.,]+)\\\\]$', text).group(1))\",\n \"def le_infotudo(info_file):\\n \\n infoarq = open(info_file, 'r')\\n infodata = infoarq.read()\\n infoarq.close()\\n \\n info_temp = infodata.split('\\\\n')\\n \\n # ... lendo data de inicio da simulacao\\n info_date = info_temp[5]\\n info_date = info_date.split(' ')\\n \\n lista = list()\\n for i in range(len(info_date)):\\n if info_date[i] == '':\\n lista.append(i)\\n \\n for j in reversed(lista):\\n del info_date[j]\\n \\n dstart = datetime(int(info_date[2]), int(info_date[1]), int(info_date[0]), int(info_date[3]))\\n \\n # ... lendo nt e dt\\n info_timestep = info_temp[8]\\n info_timestep = info_timestep.split(' ')\\n \\n lista = list()\\n for i in range(len(info_timestep)):\\n if info_timestep[i] == '':\\n lista.append(i)\\n \\n for j in reversed(lista):\\n del info_timestep[j]\\n \\n nt = info_timestep[0]\\n dt = info_timestep[1]\\n dt = dt.split(\\\".\\\")\\n dt = dt[0]\\n \\n # ... lendo nc\\n info_nc = info_temp[11]\\n info_nc = info_nc.split(' ')\\n \\n lista = list()\\n for i in range(len(info_nc)):\\n if info_nc[i] == '':\\n lista.append(i)\\n \\n for j in reversed(lista):\\n del info_nc[j]\\n \\n nc = info_nc[0]\\n \\n return int(nc), int(nt), int(dt), dstart\",\n \"def le_infotudo(info_file):\\n \\n infoarq = open(info_file, 'r')\\n infodata = infoarq.read()\\n infoarq.close()\\n \\n info_temp = infodata.split('\\\\n')\\n \\n # ... lendo data de inicio da simulacao\\n info_date = info_temp[5]\\n info_date = info_date.split(' ')\\n \\n lista = list()\\n for i in range(len(info_date)):\\n if info_date[i] == '':\\n lista.append(i)\\n \\n for j in reversed(lista):\\n del info_date[j]\\n \\n dstart = datetime(int(info_date[2]), int(info_date[1]), int(info_date[0]), int(info_date[3]))\\n \\n # ... lendo nt e dt\\n info_timestep = info_temp[8]\\n info_timestep = info_timestep.split(' ')\\n \\n lista = list()\\n for i in range(len(info_timestep)):\\n if info_timestep[i] == '':\\n lista.append(i)\\n \\n for j in reversed(lista):\\n del info_timestep[j]\\n \\n nt = info_timestep[0]\\n dt = info_timestep[1]\\n dt = dt.split(\\\".\\\")\\n dt = dt[0]\\n \\n # ... lendo nc\\n info_nc = info_temp[11]\\n info_nc = info_nc.split(' ')\\n \\n lista = list()\\n for i in range(len(info_nc)):\\n if info_nc[i] == '':\\n lista.append(i)\\n \\n for j in reversed(lista):\\n del info_nc[j]\\n \\n nc = info_nc[0]\\n \\n return int(nc), int(nt), int(dt), dstart\",\n \"def le_infotudo(info_file):\\n \\n infoarq = open(info_file, 'r')\\n infodata = infoarq.read()\\n infoarq.close()\\n \\n info_temp = infodata.split('\\\\n')\\n \\n # ... lendo data de inicio da simulacao\\n info_date = info_temp[5]\\n info_date = info_date.split(' ')\\n \\n lista = list()\\n for i in range(len(info_date)):\\n if info_date[i] == '':\\n lista.append(i)\\n \\n for j in reversed(lista):\\n del info_date[j]\\n \\n dstart = datetime(int(info_date[2]), int(info_date[1]), int(info_date[0]), int(info_date[3]))\\n \\n # ... lendo nt e dt\\n info_timestep = info_temp[8]\\n info_timestep = info_timestep.split(' ')\\n \\n lista = list()\\n for i in range(len(info_timestep)):\\n if info_timestep[i] == '':\\n lista.append(i)\\n \\n for j in reversed(lista):\\n del info_timestep[j]\\n \\n nt = info_timestep[0]\\n dt = info_timestep[1]\\n dt = dt.split(\\\".\\\")\\n dt = dt[0]\\n \\n # ... lendo nc\\n info_nc = info_temp[11]\\n info_nc = info_nc.split(' ')\\n \\n lista = list()\\n for i in range(len(info_nc)):\\n if info_nc[i] == '':\\n lista.append(i)\\n \\n for j in reversed(lista):\\n del info_nc[j]\\n \\n nc = info_nc[0]\\n \\n return int(nc), int(nt), int(dt), dstart\",\n \"def le_infotudo(info_file):\\n \\n infoarq = open(info_file, 'r')\\n infodata = infoarq.read()\\n infoarq.close()\\n \\n info_temp = infodata.split('\\\\n')\\n \\n # ... lendo data de inicio da simulacao\\n info_date = info_temp[5]\\n info_date = info_date.split(' ')\\n \\n lista = list()\\n for i in range(len(info_date)):\\n if info_date[i] == '':\\n lista.append(i)\\n \\n for j in reversed(lista):\\n del info_date[j]\\n \\n dstart = datetime(int(info_date[2]), int(info_date[1]), int(info_date[0]), int(info_date[3]))\\n \\n # ... lendo nt e dt\\n info_timestep = info_temp[8]\\n info_timestep = info_timestep.split(' ')\\n \\n lista = list()\\n for i in range(len(info_timestep)):\\n if info_timestep[i] == '':\\n lista.append(i)\\n \\n for j in reversed(lista):\\n del info_timestep[j]\\n \\n nt = info_timestep[0]\\n dt = info_timestep[1]\\n dt = dt.split(\\\".\\\")\\n dt = dt[0]\\n \\n # ... lendo nc\\n info_nc = info_temp[11]\\n info_nc = info_nc.split(' ')\\n \\n lista = list()\\n for i in range(len(info_nc)):\\n if info_nc[i] == '':\\n lista.append(i)\\n \\n for j in reversed(lista):\\n del info_nc[j]\\n \\n nc = info_nc[0]\\n \\n return int(nc), int(nt), int(dt), dstart\",\n \"def le_infotudo(info_file):\\n \\n infoarq = open(info_file, 'r')\\n infodata = infoarq.read()\\n infoarq.close()\\n \\n info_temp = infodata.split('\\\\n')\\n \\n # ... lendo data de inicio da simulacao\\n info_date = info_temp[5]\\n info_date = info_date.split(' ')\\n \\n lista = list()\\n for i in range(len(info_date)):\\n if info_date[i] == '':\\n lista.append(i)\\n \\n for j in reversed(lista):\\n del info_date[j]\\n \\n dstart = datetime(int(info_date[2]), int(info_date[1]), int(info_date[0]), int(info_date[3]))\\n \\n # ... lendo nt e dt\\n info_timestep = info_temp[8]\\n info_timestep = info_timestep.split(' ')\\n \\n lista = list()\\n for i in range(len(info_timestep)):\\n if info_timestep[i] == '':\\n lista.append(i)\\n \\n for j in reversed(lista):\\n del info_timestep[j]\\n \\n nt = info_timestep[0]\\n dt = info_timestep[1]\\n dt = dt.split(\\\".\\\")\\n dt = dt[0]\\n \\n # ... lendo nc\\n info_nc = info_temp[11]\\n info_nc = info_nc.split(' ')\\n \\n lista = list()\\n for i in range(len(info_nc)):\\n if info_nc[i] == '':\\n lista.append(i)\\n \\n for j in reversed(lista):\\n del info_nc[j]\\n \\n nc = info_nc[0]\\n \\n return int(nc), int(nt), int(dt), dstart\",\n \"def cobroEfectivo(self):\\n if self.total_a_pagar == 0:\\n QtGui.QMessageBox.information(self,\\\"Aviso\\\",\\\"El saldo restante a pagar es cero\\\")\\n else:\\n self.rbtnEfectivo.setChecked(True)\\n monto_a_pagar, ok = QtGui.QInputDialog.getDouble(self,\\\"Cobro Efectivo\\\",\\\"Ingrese monto a pagar\\\",0,0,2000,2)\\n\\n if ok:\\n if monto_a_pagar >= self.total_a_pagar:\\n QtGui.QMessageBox.information(self,\\\"Cobro Efectivo\\\",\\\"Su vuelto es:%.2f\\\" % (monto_a_pagar - self.total_a_pagar))\\n temp = [\\\"Efectivo\\\",monto_a_pagar]\\n self.detalles_cobro[self.tablePagos.rowCount()] = temp\\n self.total_a_pagar = 0\\n elif monto_a_pagar == 0:\\n QtGui.QMessageBox.information(self,\\\"Aviso\\\",\\\"El monto ingresado no puede ser cero\\\")\\n else:\\n temp = [\\\"Efectivo\\\",monto_a_pagar]\\n self.detalles_cobro[self.tablePagos.rowCount()] = temp\\n self.total_a_pagar -= monto_a_pagar\\n\\n self.actualizar_total()\\n self.actualizar_tabla()\",\n \"def comptcptotaltimer(self) :\\n\\t\\ttry :\\n\\t\\t\\treturn self._comptcptotaltimer\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise e\",\n \"def getTime(self) -> float:\\n return self.t\",\n \"def med_t_changed(self):\\n\\t\\tprint \\\"medianus t changed\\\"\\n\\t\\tmed_t_cbox = self.ui.findChild(QWidget, \\\"med_t_cbox\\\")\\t\\n\\t\\tnew_med_t = med_t_cbox.currentText()\\n\\t\\t# todo: calculate new values\",\n \"def test_tema(self):\\n periods = 200\\n tema = qufilab.tema(self.close, periods)\\n tema_talib = talib.TEMA(self.close, periods)\\n np.testing.assert_allclose(tema, tema_talib, rtol = self.tolerance)\",\n \"def get_time(self) -> float:\\n raise NotImplementedError()\",\n \"def tt(self):\\n return self.MJD + self.tt_ut1 + 2400000.5\",\n \"def total_te(self):\\r\\n return sum(map(lambda x: self.times[x]['te'], self.times))\",\n \"def test_TPt(self):\\n\\n test_value = self.portfolio.calculate_total_performance(\\n *self.boarder)[self.test_row_number]\\n calculated_value = self.manual_cumprod(\\n self.portfolio._get_total_portfolio)\\n self.assertAlmostEqual(test_value, calculated_value)\",\n \"def elemento_actual(self):\\n\\t\\tif not self.actual:\\n\\t\\t\\treturn None\\n\\t\\treturn self.actual.dato\",\n \"def time(self):\\r\\n raise NotImplementedError\",\n \"def _get_optuna_time_budget(self):\\n self._validate_optuna_time_budget()\\n\\n if self.optuna_time_budget is None:\\n if self._get_mode() == \\\"Optuna\\\":\\n return 3600\\n return None\\n else:\\n if self._get_mode() != \\\"Optuna\\\":\\n # use only for mode Optuna\\n return None\\n return deepcopy(self.optuna_time_budget)\",\n \"def time(self):\\n raise NotImplementedError()\",\n \"def test_calculate_value(self):\\n user = CustomUser.objects.get(username = \\\"Test User\\\")\\n start_date = timezone.now().replace(day=1,month=8,year=2020)\\n end_date = start_date + timedelta(days=30) \\n expected_result = 720\\n actual_result = calculate_total_user_expense_value_in_timeperiod(user, start_date, end_date)\\n self.assertEquals(expected_result, actual_result)\",\n \"def __get_elapsed__(self):\\n elapsed = (self.__end_time - self.__start_time)\\n unit = \\\"seconds\\\"\\n if elapsed >= 3600:\\n unit = \\\"minutes\\\"\\n hours = elapsed / 3600\\n minutes = hours % 60\\n hours = floor(hours)\\n print(self.name, \\\"took\\\", str(hours), \\\"hours and\\\", \\\"{0:.2f}\\\".format(minutes), unit, \\\"to complete\\\")\\n elif elapsed >= 60:\\n minutes = floor(elapsed / 60)\\n seconds = elapsed % 60\\n print(self.name, \\\"took\\\", str(minutes), \\\"minutes and\\\", \\\"{0:.2f}\\\".format(seconds), unit, \\\"to complete\\\")\\n else:\\n print(self.name, \\\"took\\\", \\\"{0:.2f}\\\".format(elapsed), unit, \\\"to complete\\\")\",\n \"def get_task_time(self, task):\\n task.task_time = TASK_TYPES[task.task_type]\\n print(\\\"Fetched task time\\\")\",\n \"def gettime(self):\\n return self.t\",\n \"def get_time(self):\\n return self.get_timed() / 10.0\",\n \"def ti_func(self):\\n return self.ti.val - self.calc_ti()\",\n \"def get_time_info(self):\\n\\n raise NotImplementedError\",\n \"def actualizar_puntaje(self):\\r\\n pass\",\n \"def mostrar_ultimo(self):\\n participantes = self.__puntuacion_total()\\n podio = self.__armar_podio(participantes)\\n print(\\n f\\\"\\\"\\\"\\n ===================================\\n ========== ULTIMO PUESTO ==========\\n ===================================\\n id disparo: {podio[0]['idDisparo']},\\n Disparos: {podio[0]['disparos']},\\n Numero participante: {podio[0]['nroParticipante']},\\n Nombre: {podio[0]['nombre']},\\n Apellido: {podio[0]['apellido']},\\n Edad: {podio[0]['edad']},\\n sexo: {podio[0]['sexo']},\\n Puntaje: {podio[0]['puntaje_total']}\\n ===================================\\n ===================================\\n \\\"\\\"\\\"\\n )\",\n \"def get_tema(data):\\n if data is None:\\n raise EmptyDataError('[!] Invalid data value')\\n\\n result = TA.TEMA(data)\\n if result is None:\\n raise IndicatorException\\n return result\",\n \"def test_time_field():\",\n \"def test_work_time_saved(self):\\n\\n self.create_page.configure()\\n\\n from_time = '20.10.2014'\\n to_time = '25.10.2014'\\n days_count = 6\\n\\n self.create_page.ad_form.set_work_time_by_input(from_time, to_time)\\n\\n info_page = self.create_page.ad_form.submit()\\n edit_page = info_page.edit_page()\\n\\n text = edit_page.ad_form.get_work_time_line_text()\\n actual_days_count = int(text.split()[0])\\n\\n info_page.delete()\\n\\n self.assertEquals(days_count, actual_days_count)\",\n \"def update_time_base(self, event):\\n print(\\\"TimeBase.update_time_base()\\\")\\n print(\\\"Base de temps : \\\", self.scale_T.get())\\n if not isinstance(self.parent, Tk):\\n self.parent.update_time(self.scale_T.get())\",\n \"def _get_time_info(self, keys: list[str]):\\n if self.is_info_v2:\\n if not self.is_on:\\n return 0\\n return self.int_or_none(self._data.get(keys[1]))\\n return self._data.get(keys[0])\",\n \"def end_time(self) -> float:\\r\\n ...\",\n \"def update_time(self):\\n pass # Do nothing\",\n \"def testEjemploTp(self):\\n azul = [0, 4, 5, 0]\\n rojo = [1, 7, 4, 0]\\n amarillo = [3, 6, 8, 0]\\n negro = [6, 10, 10, 0]\\n magenta = [7, 8, 12, 0]\\n verde = [9, 11, 11, 0]\\n perfiles = []\\n perfiles.append(azul)\\n perfiles.append(rojo)\\n perfiles.append(amarillo)\\n perfiles.append(negro)\\n perfiles.append(magenta)\\n perfiles.append(verde)\\n perfil = Perfil.Perfil()\\n resultadoEsperado = [0, 4, 1, 7, 4, 6, 6, 10, 9, 11, 11, 8, 12]\\n for x in range(10000):\\n inicial = random_integers(6, 0)\\n inicial = inicial*4\\n perfilOriginal = []\\n for i in range (inicial, len(perfiles)+inicial, 1):\\n perfilOriginal += perfiles[i%len(perfiles)]\\n \\n resultado = perfil.calcularPerfil(perfilOriginal, 0)\\n self.assertEqual(resultadoEsperado, resultado)\",\n \"def tt_ut1(self):\\n # return the delta time for the input date converted to days\\n return interpolate_delta_time(_delta_file, self.tide)\",\n \"def test_day_microseconds_now(self):\\n day_microseconds = utils.day_microseconds()\\n self.assertIsInstance(day_microseconds, int)\\n self.assertGreaterEqual(day_microseconds, 0)\\n self.assertLess(day_microseconds, 86400000000)\",\n \"def Tt(s_c, point, system):\\n Tx = tra(s_c, point, system)\\n Tx.get_time()\\n return Tx.time\",\n \"def t(self):\\n return self._t\",\n \"def t(self):\\n return self._t\",\n \"def __get_emptiest (self, person):\\n doubles = []\\n for scheduling_unit in person.get_scheduling_units ( ):\\n doubles.append ((scheduling_unit, self.__calculate_emptiness (scheduling_unit)))\\n \\n doubles.sort (key=lambda trio: trio[1])\\n \\n scheduling_units = []\\n for double in doubles:\\n scheduling_units.append (double[0])\\n \\n return scheduling_units\",\n \"def desired_measurement_entity_response_time(self, status: str) -> int | None:\\n defaults = {\\n \\\"confirmed\\\": 180,\\n \\\"false_positive\\\": 180,\\n \\\"wont_fix\\\": 180,\\n \\\"fixed\\\": 7,\\n }\\n default = defaults.get(status)\\n return int(self.get(\\\"desired_response_times\\\", {}).get(status, default)) if status in defaults else None\",\n \"def computeTm(self):\\n #first step is finding the derivative series of the well\\n x = self.temperatures\\n if self.fluorescence == None:\\n self.Tm = None\\n return\\n y = self.fluorescence\\n \\n xdiff = np.diff(x)\\n dydx = -np.diff(y)/xdiff\\n #the derivative series, has one less index since there is one fewer differences than points\\n seriesDeriv = pandas.Series(dydx, x[:-1])\\n \\n #now that we have the derivative series, we can find the Tm\\n lowestPoint = 0\\n lowestPointIndex = None\\n \\n #gets number of signchanges between max and min of the curve, used to determin if the curve\\n #is complex or not\\n lowestPoint2 = 1\\n lowestIndex2 = None\\n highestPoint = 0\\n highestIndex = None\\n previous = None\\n for i, value in enumerate(self.fluorescence[:-1]):\\n if value > highestPoint:\\n highestPoint = value\\n highestIndex = i\\n if highestIndex == 0 :\\n highestPoint = 0\\n highestIndex = None\\n for i, value in enumerate(self.fluorescence[:-1]):\\n if value<lowestPoint2:\\n lowestPoint2 = value\\n lowestIndex2 = i\\n for i, value in enumerate(self.fluorescence[:-1]):\\n if i < lowestIndex2:\\n continue\\n if value > highestPoint:\\n highestPoint = value\\n highestIndex = i\\n else:\\n for i, value in enumerate(self.fluorescence[:-1]):\\n if i > highestIndex:\\n break\\n if value<lowestPoint2:\\n lowestPoint2 = value\\n lowestIndex2 = i\\n signChange = False\\n for ind in seriesDeriv.index[lowestIndex2+1:highestIndex]:\\n \\n if previous:\\n if seriesDeriv[ind] + SIGN_CHANGE_THRESH < 0 and previous - SIGN_CHANGE_THRESH > 0:\\n signChange = True\\n if seriesDeriv[ind] - SIGN_CHANGE_THRESH > 0 and previous + SIGN_CHANGE_THRESH < 0:\\n signChange = True\\n # if seriesDeriv[ind] == 0:\\n # signChangeCount += 1\\n previous = seriesDeriv[ind]\\n\\n \\n #finding the lowest point and its index on the derivative series\\n #only search for Tm up to 90degrees, since last part is hard to predict\\n #and often gives false positives\\n ignoreNum = int(len(seriesDeriv.index)*0.125)\\n for ind in seriesDeriv.index[:-ignoreNum]:\\n if seriesDeriv[ind]<lowestPoint:\\n lowestPoint = seriesDeriv[ind]\\n lowestPointIndex = ind\\n \\n #TODO working, tms not steep enough added to complex\\n #if the slope is not steep enough, tm remains saved, but curve is grouped with the\\n #complex curves (now known as the unreliable group)\\n #if lowestPoint > -0.000001 / (normalisationFactor / saturation max point of all curves thing):\\n # print self.name, 'lowestpoint too small', lowestPoint\\n # self.complex = True\\n\\n #if lowest point is the first index, then no curve fit is required\\n if lowestPointIndex == seriesDeriv.index[0]:\\n tm = lowestPointIndex\\n self.Tm = tm\\n \\n #set complex to true if curve was complex\\n if signChange:\\n self.complex = True\\n return\\n \\n #could not find any Tm\\n if lowestPointIndex == None:\\n self.Tm = None\\n \\n #if no tm, the curve hopefully be picked up as a monotonic/in the noise/saturated/outlier\\n #however, if this does not happen, the curve remains as complex\\n self.complex = True\\n return \\n \\n #the indices in the series either side of the lowest index\\n #note the first list is indexed e.g. list[i] where i is the section using .index\\n leftIndex = [ind for ind in seriesDeriv.index][[ind for ind in seriesDeriv.index].index(lowestPointIndex)-1]\\n rightIndex = [ind for ind in seriesDeriv.index][[ind for ind in seriesDeriv.index].index(lowestPointIndex)+1]\\n \\n \\n #matrices used to fit a parabola to the 3 points\\n Y=[seriesDeriv[leftIndex],\\n seriesDeriv[lowestPointIndex],\\n seriesDeriv[rightIndex]]\\n \\n A=[[leftIndex**2, leftIndex, 1],\\n [lowestPointIndex**2, lowestPointIndex, 1],\\n [rightIndex**2, rightIndex, 1]]\\n \\n #solve for b, in the form Y=Ab\\n (a,b,c) = np.linalg.solve(A,Y)\\n \\n #initialise tm to left most point of relevant curve\\n tm=seriesDeriv[leftIndex]\\n tmValue=0\\n #make tm the lowest point on the fitted parabola rounded to nearest 0.01\\n for x in np.arange(leftIndex,rightIndex,0.01):\\n point = (a*(x**2) + b*x + c)\\n if tmValue > point:\\n tmValue = point\\n tm = x\\n self.Tm = tm\\n \\n #again check for complex shape before returning\\n if signChange:\\n self.complex = True\\n\\n\\n averagePoint = (lowestPoint2 +highestPoint) / 2\\n i = lowestIndex2\\n while self.fluorescence[i]<averagePoint:\\n i += 1;\\n\\n # estimates tm by another method and if the difference is too large the curve is considred complex\\n if (self.temperatures[i] -self.Tm)**2 > 5**2:\\n self.complex=True\\n return\",\n \"def do_timing(self):\\n sts = datetime.datetime.now()\\n _ = dep.read_env(get_path('good_env.txt'))\\n ets = datetime.datetime.now()\\n print(\\\"%.5f reads per second\\\" % (1. / (ets - sts).total_seconds(),))\\n self.assertEquals(1, 2)\",\n \"def tic(self):\\n return self._timestamp\",\n \"def start_time(self) -> float:\\r\\n ...\",\n \"def current_time(cls) -> float:\",\n \"def time(self) -> int:\\n pass\",\n \"def get_time(self):\\n return self.run_command('get_time')[0]\",\n \"def _get_tb(I, nu, beam):\\n from astropy import units as u\\n return (1222.0*I/(nu**2*(beam.minor/1.0).to(u.arcsecond)*(beam.major/1.0).to(u.arcsecond))).value\",\n \"def actual_time():\\n return _time.time()\",\n \"def calcula_aptitud(self, individuo, costo=None):\",\n \"def get_torsion_info(self):\\n return\",\n \"def test_queryset_total_time_no_records(db):\\n assert models.TimeRecord.objects.total_time() == datetime.timedelta(0)\",\n \"def getTempo():\\r\\n global dauer\\r\\n \\r\\n dauer = 0.0\\r\\n counter = 1\\r\\n\\r\\n for x in midi_data.get_tempo_changes(): #pretty_midi saves the tempo of a midi-file in nested-arrays, therefore a few for-loops and if statements are necessary\\r\\n for e in x:\\r\\n if e > 0:\\r\\n if counter > 0:\\r\\n tempi.append(round(e))\\r\\n counter = 0\\r\\n break\\r\\n \\r\\n dauer = 60000/(e/4)\",\n \"def plotTime(self):\\n plt.figure()\\n t = [i for i in range(len(self.nodes_infected))]\\n print(t)\\n plt.title('Nodos infectados vs Tiempo')\\n plt.xlabel('Instantes de tiempo')\\n plt.ylabel('# de nodos infectados')\\n plt.plot(t, self.nodes_infected)\\n plt.grid(True)\\n plt.show()\",\n \"def cuenta_regresiva(self):\\r\\n digito = 10\\r\\n tiempo = datetime.now()\\r\\n delta_ = timedelta(seconds=1)\\r\\n while digito > 0:\\r\\n if datetime.now() - tiempo > delta_:\\r\\n tiempo = datetime.now()\\r\\n digito -= 1\\r\\n self.counter_signal.emit(digito)\\r\\n self.juguemos()\",\n \"def getTimes():\",\n \"def getTimes():\",\n \"def getTimes():\",\n \"def test_TRit(self):\\n\\n prices = self._convert_df_to_list(self.prices)\\n currency = self._convert_df_to_list(self.currency)\\n\\n manual_total = self.list_multiplication(prices, currency)\\n manual_calculated = list(self._manual_calculate_formal(manual_total))\\n\\n self.portfolio._generate_total()\\n test_column = self._convert_df_to_list(self.portfolio._df_total)\\n\\n self.assertAlmostEqual(self._clear_column(manual_calculated),\\n self._clear_column(test_column))\",\n \"def get_umeastime(self):\\n return self.utime\",\n \"def u_dt(self, H, tim):\\n\\t\\tif self.tb_model:\\n\\t\\t\\t#cond = QnIni(k=self.k,ctrlt=self.ctrlt)\\n\\t\\t\\tdx,dy,dz = self.QnIni.dvec(self.ctrlt[tim]) \\n\\t\\t\\td = np.sqrt(dx**2 + dy**2 + dz**2)*self.dt\\n\\t\\t\\tu = np.cos(d)*self.pau_i -1j*self.dt/d*np.sin(d)*H\\n\\n\\t\\telse:\\n\\t\\t\\tu = expm(-1j*H*self.dt)\\n\\n\\t\\treturn u\",\n \"def test_datetime_microseconds(self):\\n\\n conn = self.connect()\\n c = conn.cursor()\\n dt = datetime.datetime(2013, 11, 12, 9, 9, 9, 123450)\\n c.execute(\\\"create table test_datetime (id int, ts datetime(6))\\\")\\n try:\\n c.execute(\\\"insert into test_datetime values (%s, %s)\\\", (1, dt))\\n c.execute(\\\"select ts from test_datetime\\\")\\n self.assertEqual((dt,), c.fetchone())\\n finally:\\n c.execute(\\\"drop table test_datetime\\\")\",\n \"def test_time(self):\\n conn = self.database.connection()\\n cursor = conn.cursor()\\n dialect = self.database.dialect()\\n dbapi = self.database.dbapi()\\n query = dialect.translate('DROP TABLE test_time')\\n try:\\n cursor.execute(query)\\n except dbapi.Error:\\n conn.rollback()\\n query = dialect.translate('CREATE TABLE test_time ' \\\\\\n '( value TIME NOT NULL )')\\n cursor.execute(query)\\n data = []\\n rr = random.randrange\\n query = 'INSERT INTO test_time VALUES (%s)'\\n for i in range(100):\\n item = datetime.time(rr(0,24), rr(0,60), rr(0,60))\\n data.append(item)\\n cursor.execute(query, (item,))\\n query = 'SELECT * FROM test_time'\\n cursor.execute(query)\\n result = cursor.fetchall()\\n for row in result:\\n item = row[0]\\n assert isinstance(item, datetime.time)\\n assert item in data\\n data.remove(item)\\n query = dialect.translate('DELETE FROM test_time')\\n cursor.execute(query)\\n query = dialect.translate('DROP TABLE test_time')\\n cursor.execute(query)\\n conn.commit()\",\n \"def get_time(self):\\n return self.widget().time()\",\n \"def m_ps_FieldsUpdated(self, sender, e):\\r\\n ltp = e.Fields.GetLastTradedPriceField()\\r\\n ltq = e.Fields.GetLastTradedQuantityField()\\r\\n print(\\\"ltp and ltq success...\\\")\\r\\n if ltp.HasChanged or ltq.HasChanged:\\r\\n print(ltp.Value, ltq.Value)\\r\\n ltp = ltp.Value\\r\\n ltpi = int(ltp.ToTicks())\\r\\n self.process_row({'time' :pd.datetime.now(), 'close' : ltpi}, key = \\\"nk\\\")\",\n \"def get_temporal(self):\\n self.unimpl_base_class()\",\n \"def eta(self):\\n eta = self.fields['eta']\\n if eta >= 0:\\n return datetime.timedelta(seconds=eta)\\n else:\\n ValueError('eta not valid')\",\n \"def test_timesheet_uom(self):\\n # create SO and confirm it\\n uom_days = self.env.ref('product.product_uom_day')\\n sale_order = self.env['sale.order'].create({\\n 'partner_id': self.partner_usd.id,\\n 'partner_invoice_id': self.partner_usd.id,\\n 'partner_shipping_id': self.partner_usd.id,\\n 'order_line': [\\n (0, 0, {\\n 'name': self.product_delivery_timesheet3.name,\\n 'product_id': self.product_delivery_timesheet3.id,\\n 'product_uom_qty': 5,\\n 'product_uom': uom_days.id,\\n 'price_unit': self.product_delivery_timesheet3.list_price\\n })\\n ],\\n 'pricelist_id': self.pricelist_usd.id,\\n })\\n sale_order.action_confirm()\\n task = self.env['project.task'].search([('sale_line_id', '=', sale_order.order_line.id)])\\n\\n # let's log some timesheets\\n self.env['account.analytic.line'].create({\\n 'name': 'Test Line',\\n 'project_id': sale_order.project_project_id.id,\\n 'task_id': task.id,\\n 'unit_amount': 16,\\n 'employee_id': self.employee_manager.id,\\n })\\n self.assertEqual(sale_order.order_line.qty_delivered, 2, 'Sale: uom conversion of timesheets is wrong')\\n\\n self.env['account.analytic.line'].create({\\n 'name': 'Test Line',\\n 'project_id': sale_order.project_project_id.id,\\n 'task_id': task.id,\\n 'unit_amount': 24,\\n 'employee_id': self.employee_user.id,\\n })\\n sale_order.action_invoice_create()\\n self.assertEqual(sale_order.invoice_status, 'invoiced', 'Sale Timesheet: \\\"invoice on delivery\\\" timesheets should not modify the invoice_status of the so')\",\n \"def test_time(self):\\n result = self.test_client.time\\n\\n assert result == \\\"15093049123\\\"\",\n \"def test_fields_effort_time_units_dictionary_success(self, _mock_check):\\n field = EffortField(time_units={\\\"minute\\\": (\\\"minute\\\", \\\"minutes\\\")})\\n\\n errors = field.check()\\n self.assertEqual(len(errors), 0)\",\n \"def compute_iactT(data):\\n\\t# get only the timestamps\\n\\ttime = data[0]\\n\\tprevT = time[0]\\n\\n\\ttotalT = len(time)*0.1\\n\\n\\treturn totalT\",\n \"def Montecarlo(h,porcentaje,nombre):\\n tm = time()\\n print('Se esta procesando el '+str(porcentaje)+'% de particulas')\\n print('\\\\n')\\n redor = Quitar(porcentaje,redhex)\\n Guardar_archivo(redor,nombre + 'original')\\n \\n redopt = Optim(redor,h,1)\\n fin = datetime.now()\\n Guardar_archivo(redopt,nombre +'optim')\\n print('Calculado para '+str(len(redor))+' particulas')\\n Dt2 = time() -tm\\n print('en un tiempo de '+str(Dt2)+'s. \\\\n')\\n print(fin)\\n return()\",\n \"def calculation_time(self) -> float:\\n return self.__calculation_time\",\n \"def info(self):\\n out = f\\\"sec: {self.em_sec()}\\\\nmin: {self.em_min()}\\\"\\n out += f\\\"\\\\nhora: {self.em_hora()}\\\\ndia: {self.em_dia()}\\\"\\n return out\",\n \"def check(self):\\r\\n boto.log.info('checking Task[%s]-now=%s, last=%s' % (self.name, self.now, self.last_executed))\\r\\n\\r\\n if self.hourly and not self.last_executed:\\r\\n return 0\\r\\n \\r\\n if self.daily and not self.last_executed:\\r\\n if int(self.hour) == self.now.hour:\\r\\n return 0\\r\\n else:\\r\\n return max( (int(self.hour)-self.now.hour), (self.now.hour-int(self.hour)) )*60*60\\r\\n\\r\\n delta = self.now - self.last_executed\\r\\n if self.hourly:\\r\\n if delta.seconds >= 60*60:\\r\\n return 0\\r\\n else:\\r\\n return 60*60 - delta.seconds\\r\\n else:\\r\\n if int(self.hour) == self.now.hour:\\r\\n if delta.days >= 1:\\r\\n return 0\\r\\n else:\\r\\n return 82800 # 23 hours, just to be safe\\r\\n else:\\r\\n return max( (int(self.hour)-self.now.hour), (self.now.hour-int(self.hour)) )*60*60\",\n \"def important_time(self):\\n\\t\\twork_s = self.work_time().seconds\\n\\t\\tbreak_s = self.break_time().seconds\\n\\t\\tif self.status():\\n\\t\\t\\tremaining_time_s = tomato(work_s, break_s)\\n\\t\\telse:\\n\\t\\t\\tremaining_time_s = potato(work_s, break_s)\\n\\n\\t\\timp_time = datetime.now() + timedelta(0, remaining_time_s)\\n\\t\\treturn imp_time\",\n \"def get_system_time(self):\\r\\n method = self.public_endpoints['system_time']['method']\\r\\n url = self.base_url + self.public_endpoints['system_time']['url']\\r\\n req = requests.request(method, url)\\r\\n res = req.json()\\r\\n\\r\\n if res['success'] == True:\\r\\n return res[\\\"result\\\"]\\r\\n else:\\r\\n return res\",\n \"def test_estimate_data_time__correct_doy():\\n parser = IMFV283Parser()\\n # BOU aka normal\\n transmission = '17274013121'\\n day = 274\\n minute = 72\\n (data_time, transmit_time, corrected) = \\\\\\n parser._estimate_data_time(transmission, day, minute)\\n assert_equals(data_time, UTCDateTime('2017-10-01T01:12:00Z'))\\n assert_equals(transmit_time, UTCDateTime('2017-10-01T01:31:21Z'))\\n assert_equals(corrected, False)\",\n \"def remaining_ms():\",\n \"def _calculate_tusd_energia_reais(\\n self, company_month_data, company_params, tarifas_repository\\n ):\\n tarifas_month_data_p = self._get_fares_month_data(\\n tarifas_repository, company_params, posto=\\\"Ponta\\\"\\n )\\n\\n tarifas_month_data_fp = self._get_fares_month_data(\\n tarifas_repository, company_params, posto=\\\"Fora Ponta\\\"\\n )\\n\\n tusd_energia_p = tarifas_month_data_p[\\\"tusde\\\"]\\n tusd_energia_fp = tarifas_month_data_fp[\\\"tusde\\\"]\\n\\n consumo_p = company_month_data[\\\"consumo_ponta\\\"]\\n consumo_fp = company_month_data[\\\"consumo_fora_ponta\\\"]\\n\\n tusd_energia_p_reais = consumo_p*tusd_energia_p\\n tusd_energia_fp_reais = consumo_fp*tusd_energia_fp\\n\\n return {\\n \\\"tusd_energia_p_reais\\\": tusd_energia_p_reais,\\n \\\"tusd_energia_fp_reais\\\": tusd_energia_fp_reais\\n }\",\n \"def test_time_status(self):\\n result = self.test_client.time_status\\n\\n assert result == \\\"12312\\\"\",\n \"def test_fund_duration_end(self):\\r\\n with self.client as c:\\r\\n results = c.post(\\r\\n \\\"/duracion-de-fondos\\\",\\r\\n data=json.dumps(DURACION_DE_FONDO_JSON_0),\\r\\n headers=TestRetirementCalculator.request_headers,\\r\\n )\\r\\n data = json.loads(results.data)\\r\\n\\r\\n self.assertDictEqual(data, DURACION_DE_FONDO_RESULT_0)\",\n \"def Ingresar(frm):\\r\\n #se asigna el valor de la variable seguir\\r\\n \\r\\n #se le pide al usuario que ingresa la altura\\r\\n posinicial=float(frm.txtposinicial.GetValue())\\r\\n #posinicial=raw_input(\\\"Ingrese la altura desde donde se va dejar caer (en metros): \\\")\\r\\n #se condiona para que solo permite ingresar numero positivos \\r\\n \\r\\n posinicial=float(posinicial)\\r\\n if posinicial>0:\\r\\n posinicial=posinicial+2\\r\\n return posinicial\",\n \"def get_answer_time(self):\\n sec = (self.updated_at - self.created_at).total_seconds()\\n return f'{int((sec / 60) % 60):02d}:{int(sec):02d}'\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.591941","0.56388557","0.56071705","0.556373","0.55624765","0.5506412","0.5460353","0.5383823","0.5344067","0.5318034","0.52971244","0.5287082","0.52630705","0.5252758","0.5242119","0.5242119","0.5242119","0.5242119","0.5242119","0.5241725","0.5206754","0.52008325","0.51949567","0.51707596","0.51670265","0.5141635","0.5140501","0.5126648","0.51219356","0.51093733","0.51026094","0.50882053","0.5086064","0.5071189","0.5052533","0.50453055","0.50392574","0.5034953","0.5030427","0.50241333","0.50196105","0.5009754","0.5004244","0.5001808","0.5001498","0.49982443","0.4996661","0.49951765","0.49834892","0.4974746","0.49567676","0.49459484","0.4945464","0.4945464","0.4942753","0.49393922","0.49381217","0.49150044","0.49122608","0.49055248","0.49002418","0.48871425","0.4883035","0.48822165","0.48809025","0.4871667","0.48618695","0.48581824","0.48525476","0.4851412","0.48512354","0.48506933","0.48506933","0.48506933","0.4849323","0.4845728","0.48429278","0.48415127","0.4832795","0.48261264","0.4826029","0.48222822","0.4819111","0.48154566","0.48102626","0.4809616","0.4808826","0.48085675","0.4807998","0.48054314","0.48020658","0.47999382","0.4799825","0.47924978","0.47887963","0.47832125","0.47777572","0.47775394","0.47769424","0.4772579"],"string":"[\n \"0.591941\",\n \"0.56388557\",\n \"0.56071705\",\n \"0.556373\",\n \"0.55624765\",\n \"0.5506412\",\n \"0.5460353\",\n \"0.5383823\",\n \"0.5344067\",\n \"0.5318034\",\n \"0.52971244\",\n \"0.5287082\",\n \"0.52630705\",\n \"0.5252758\",\n \"0.5242119\",\n \"0.5242119\",\n \"0.5242119\",\n \"0.5242119\",\n \"0.5242119\",\n \"0.5241725\",\n \"0.5206754\",\n \"0.52008325\",\n \"0.51949567\",\n \"0.51707596\",\n \"0.51670265\",\n \"0.5141635\",\n \"0.5140501\",\n \"0.5126648\",\n \"0.51219356\",\n \"0.51093733\",\n \"0.51026094\",\n \"0.50882053\",\n \"0.5086064\",\n \"0.5071189\",\n \"0.5052533\",\n \"0.50453055\",\n \"0.50392574\",\n \"0.5034953\",\n \"0.5030427\",\n \"0.50241333\",\n \"0.50196105\",\n \"0.5009754\",\n \"0.5004244\",\n \"0.5001808\",\n \"0.5001498\",\n \"0.49982443\",\n \"0.4996661\",\n \"0.49951765\",\n \"0.49834892\",\n \"0.4974746\",\n \"0.49567676\",\n \"0.49459484\",\n \"0.4945464\",\n \"0.4945464\",\n \"0.4942753\",\n \"0.49393922\",\n \"0.49381217\",\n \"0.49150044\",\n \"0.49122608\",\n \"0.49055248\",\n \"0.49002418\",\n \"0.48871425\",\n \"0.4883035\",\n \"0.48822165\",\n \"0.48809025\",\n \"0.4871667\",\n \"0.48618695\",\n \"0.48581824\",\n \"0.48525476\",\n \"0.4851412\",\n \"0.48512354\",\n \"0.48506933\",\n \"0.48506933\",\n \"0.48506933\",\n \"0.4849323\",\n \"0.4845728\",\n \"0.48429278\",\n \"0.48415127\",\n \"0.4832795\",\n \"0.48261264\",\n \"0.4826029\",\n \"0.48222822\",\n \"0.4819111\",\n \"0.48154566\",\n \"0.48102626\",\n \"0.4809616\",\n \"0.4808826\",\n \"0.48085675\",\n \"0.4807998\",\n \"0.48054314\",\n \"0.48020658\",\n \"0.47999382\",\n \"0.4799825\",\n \"0.47924978\",\n \"0.47887963\",\n \"0.47832125\",\n \"0.47777572\",\n \"0.47775394\",\n \"0.47769424\",\n \"0.4772579\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5652158"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":79086,"cells":{"query":{"kind":"string","value":"Mapping a value in a given range to another range"},"document":{"kind":"string","value":"def mapped(val, in_min, in_max, out_min, out_max):\n return (val - in_min) * (out_max - out_min) / \\\n (in_max - in_min) + out_min"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def map_to_range(val, old_min, old_max, new_min, new_max):\n return new_max - (val - old_min) * (new_max - new_min) / (old_max - old_min)","def map(value, in_low, in_high, out_low, out_high):\n # example from /animation_nodes/nodes/number/map_range.py\n # if inMin == inMax:\n # newValue = 0\n # # with clamping\n # if inMin < inMax:\n # _value = min(max(value, inMin), inMax)\n # else:\n # _value = min(max(value, inMax), inMin)\n # with interpolation\n # newValue = outMin + interpolation(\n # (_value - inMin) / (inMax - inMin)\n # ) * (outMax - outMin)\n # without interpolation\n # newValue = outMin + (\n # (_value - inMin) / (inMax - inMin)\n # ) * (outMax - outMin)\n # # without clamping\n # newValue = outMin + (\n # (value - inMin) / (inMax - inMin)\n # ) * (outMax - outMin)\n # # without clamping - reworded\n # result = (\n # (\n # ((value - in_low) / (in_high - in_low)) *\n # (out_high - out_low)\n # ) + out_low\n # )\n\n result = None\n\n # based on http://arduino.cc/en/Reference/Map\n # and http://stackoverflow.com/a/5650012/574981\n result = (\n (\n ((value - in_low) * (out_high - out_low)) /\n (in_high - in_low)\n ) + out_low\n )\n\n return result","def map_range(x, in_min, in_max, out_min, out_max):\n mapped = (x-in_min) * (out_max - out_min) / (in_max-in_min) + out_min\n if out_min <= out_max:\n return max(min(mapped, out_max), out_min)\n return min(max(mapped, out_max), out_min)","def mapRange(num, min1, max1, min2, max2, clamp=True):\n if(clamp and num < min1):\n return min2\n if(clamp and num > max1):\n return max2\n\n num1 = (num - min1) / (max1 - min1)\n num2 = (num1 * (max2 - min2)) + min2\n return num2","def map_between(value, start, stop):\n\n return (stop - start) * value + start","def remap_interval(val, in_start, in_end, out_start, out_end):\n in_range = in_end-in_start\n out_range = out_end-out_start\n return (val-in_start)/in_range*out_range+out_start","def map_range( self, rng ):\n rmap = {\n '2 nA': pac.Ammeter.CurrentRange.N2,\n '20 nA': pac.Ammeter.CurrentRange.N20,\n '200 nA': pac.Ammeter.CurrentRange.N200,\n '2 uA': pac.Ammeter.CurrentRange.U2,\n '20 uA': pac.Ammeter.CurrentRange.U20,\n '200 uA': pac.Ammeter.CurrentRange.U200,\n '2 mA': pac.Ammeter.CurrentRange.M2,\n '20 mA': pac.Ammeter.CurrentRange.M20\n }\n \n if rng in rmap:\n return rmap[ rng ]\n \n else:\n raise ValueError( 'Invalid range' )","def translate(value, from_min, from_max, to_min, to_max):\n # Figure out how 'wide' each range is\n left_span = from_max - from_min\n right_span = to_max - to_min\n\n # Convert the left range into a 0-1 range (float)\n value_scaled = float(value - from_min) / float(left_span)\n\n # Convert the 0-1 range into a value in the right range.\n return to_min + (value_scaled * right_span)","def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\n inputrange = float(input_interval_end) - float(input_interval_start) #finds length or original interval\n outputrange = float(output_interval_end) - float(output_interval_start) #finds length of target interval\n scaledvalue = float(val) - input_interval_start #finds how far through the interval the value is \n value = ( scaledvalue / inputrange ) * outputrange + output_interval_start\n return value","def remap(self, value, from1, to1, from2, to2):\n return from2 + (value - from1) * (to2 - from2) / (to1 - from1)","def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\n # your code goes here","def map_bound(value, in_low, in_high, out_low, out_high):\n result = None\n\n if value <= in_low:\n result = out_low\n else:\n if value >= in_high:\n result = out_high\n else:\n # http://stackoverflow.com/a/5650012/574981\n result = out_low + (\n (out_high - out_low) * (value - in_low) / (in_high - in_low)\n )\n return result","def translate(value, input_min, input_max, output_min, output_max):\n # Figure out how 'wide' each range is\n input_span = input_max - input_min\n output_span = output_max - output_min\n\n # Convert the left range into a 0-1 range (float)\n value_scaled = float(value - input_min) / float(input_span)\n\n # Convert the 0-1 range into a value in the right range.\n return output_min + (value_scaled * output_span)","def remap(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\n weight_end = float(val-input_interval_start)/(input_interval_end-input_interval_start)\n weight_start = float(input_interval_end-val)/(input_interval_end-input_interval_start)\n\n return (weight_end*output_interval_end)+(weight_start*output_interval_start)","def translate(self, value, left_min, left_max, right_min=None, right_max=None):\n if right_min is None:\n right_min = self.values['pulse_min'].data\n if right_max is None:\n right_max = self.values['pulse_max'].data\n # Figure out how 'wide' each range is\n left_span = left_max - left_min\n right_span = right_max - right_min\n # Convert the left range into a 0-1 range (float)\n value_scaled = float(value - left_min) / float(left_span)\n # Convert the 0-1 range into a value in the right range.\n return int(right_min + (value_scaled * right_span))","def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\n return (val - input_interval_start)/float(input_interval_end - input_interval_start)*(\n output_interval_end - output_interval_start) + output_interval_start","def remap(\n n: int, start1: int, stop1: int, start2: int, stop2: int, withinBounds: bool = True\n) -> int:\n newval = (n - start1) / (stop1 - start1) * (stop2 - start2) + start2\n if not withinBounds:\n return newval\n if start2 < stop2:\n return constrain(newval, start2, stop2)\n else:\n return constrain(newval, stop2, start2)","def translate(value, leftMin, leftMax, rightMin, rightMax):\n # Figure out how 'wide' each range is\n leftSpan = leftMax - leftMin\n rightSpan = rightMax - rightMin\n\n # Convert the left range into a 0-1 range (float)\n valueScaled = float(value - leftMin) / float(leftSpan)\n\n # Convert the 0-1 range into a value in the right range.\n return rightMin + (valueScaled * rightSpan)","def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\n \n return ((float(val-input_interval_start) * (output_interval_end-output_interval_start)) / (input_interval_end-input_interval_start)) + output_interval_start","def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\n x=(float(val)-float(input_interval_start))\n y=(float(input_interval_end)-float(input_interval_start))\n z=x/y\n return output_interval_start+(z*(output_interval_end-output_interval_start))","def mapVal(inputPos, in_min, in_max, out_min, out_max):\n \n \n scale = ((out_max - out_min) / (in_max - in_min))\n return float(((inputPos - in_min) * scale) + out_min)","def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\n convert = float (val - input_interval_start) / float ( input_interval_end - input_interval_start)\n output1 = output_interval_start + convert* (output_interval_end - output_interval_start)\n return output1","def merge_ranges():","def newval_from_range_map(v: INT_OR_INTLIST, range_map: Tuple[List[int], List[int]]) -> INT_OR_INTLIST:\n\t# support both int and list-of-int inputs... do basically the same thing, just looped\n\t# if input is list, IT MUST BE IN ASCENDING SORTED ORDER\n\t# core idea: walk BACKWARDS along the range_map until i find the start that is CLOSEST BELOW the input v\n\tif isinstance(v, int):\n\t\t# # bisect_right: same as bisect_left but when matching something already in it it goes one to the right\n\t\tpos = core.bisect_right(range_map[0], v)\n\t\tif pos == 0:\n\t\t\t# if it doesnt find a block starting below v, then the offset is 0\n\t\t\treturn v\n\t\telse:\n\t\t\t# return the input value minus the applicable offset\n\t\t\treturn v - range_map[1][pos-1]\n\telse:\n\t\t# if given a list, the list is ordered so take advantage of that to pick up where the previous item left off\n\t\t# walk backwards along both lists side-by-side\n\t\tretme = []\n\t\tinput_idx = len(v) - 1\n\t\tidx = len(range_map[0]) - 1\n\t\twhile idx >= 0 and input_idx >= 0:\n\t\t\tif range_map[0][idx] <= v[input_idx]:\n\t\t\t\t# return the input value minus the applicable offset\n\t\t\t\tretme.append(v[input_idx] - range_map[1][idx])\n\t\t\t\tinput_idx -= 1\n\t\t\telse:\n\t\t\t\tidx -= 1\n\t\tif input_idx != -1:\n\t\t\t# if it finished walking down the range-list before it finished the input-list, all remaining inputs are unchanged\n\t\t\tretme += reversed(v[0:input_idx+1])\n\t\tretme.reverse()\n\t\treturn retme","def fit_to_range(val: float, a: float, b: float, a1: float, b1: float) -> float:\n new_value = ((val - a) / (b - a)) * (b1 - a1) + a1\n return new_value","def _translate_range(self, len_, start, end):\n start = int(start)\n end = int(end)\n if start < 0:\n start += len_\n start = max(0, min(start, len_))\n if end < 0:\n end += len_\n end = max(-1, min(end, len_ - 1))\n return start, end","def expand_ranges(ranges):\n for low, high in low_high_pairs:\n for j in range(low, high+1):\n yield j","def define_range():\n\n def_range = {'lt': [0.0, 24.0],\n 'lon': [0.0, 360.0],\n 'angle': [0.0, 2.0 * np.pi]}\n\n return def_range","def set_mapping(self, value_min, value_min_raw, value_max, value_max_raw):\n assert value_min <= value_max\n # prevent division by zero.\n if value_min == value_max:\n value_max += 1.\n if value_min_raw == value_max_raw:\n value_max_raw += 1.\n self.value_min = value_min\n self.value_max = value_max\n self.value_min_raw = value_min_raw\n self.value_max_raw = value_max_raw\n self._value_scale = (self.value_max - self.value_min) / (self.value_max_raw - self.value_min_raw)","def m_to_range(self, data):\n return (data - self._min_range_m) / self._total_range","def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\n\n\t# shift the zero\n\tzero = (output_interval_start - input_interval_start)\n\t\n\t# stretch/compress after shifting\n\tchange_factor = float(output_interval_end)/ (input_interval_end + zero)\n\n\t# apply stretching/compression\n\tnew_value = (val+zero)*change_factor\n\n\treturn new_value","def new_range(r):\n if isinstance(r, list) or isinstance(r, tuple) and len(r) == 2:\n lower = r[0]\n upper = r[1]\n else:\n lower = r\n upper = r\n lower = int(lower)\n upper = int(upper)\n return range(lower, upper + 1)","def set_maprange(xmin, ymin, xmax, ymax, epsg_in='epsg:4326'):\n outProj = pyproj.Proj(init='epsg:3857')\n inProj = pyproj.Proj(init=epsg_in)\n xmin,ymin = 75, -55\n xmax,ymax = 175, -5\n x1,y1 = pyproj.transform(inProj,outProj,xmin,ymin)\n x2,y2 = pyproj.transform(inProj,outProj,xmax,ymax)\n return x1, y1, x2, y2","def math_map_list(values, toMin=0, toMax=1):\n minValue = min(values)\n maxValue = max(values)\n delta = maxValue - minValue\n deltaTarget = toMax - toMin\n newValues = [toMin +(value-minValue)*deltaTarget/delta for value in values]\n return newValues","def range_to_m(self, data):\n return data * self._total_range + self._min_range_m","def from_inclusive(a, b):\n c = int(b > a)*2-1\n return range(a, b+c, c)","def new_ranges(rs):\n return tuple(chain(*[new_range(r) for r in rs]))","def normalizeToRange(v, a, b):\n return (v - a) / (b - a)","def domain_range(domain, _range=[0, 1], return_transform=False):\n\n if not return_transform:\n return interp1d([min(domain), max(domain)], [min(_range), max(_range)], bounds_error=False)\n else:\n m = interp1d([min(domain), max(domain)], [min(_range), max(_range)])\n return [float(m(v)) for v in domain] # Take float, else returns weird numpy.ndarray element","def range(self, value):\n self.value_range = tuple([float(x) for x in value.split(':')])","def _adjustRange(self, start, end):\n adjusted_start = start\n if self._start:\n if end < self._start:\n return None\n adjusted_start = max(self._start, start)\n \n adjusted_end = end\n if self._end:\n if self._end < start:\n return None\n adjusted_end = min(self._end, end)\n \n return (adjusted_start, adjusted_end)","def convert_range(g, op, block):\n\n start = g.get_node(op.input(\"Start\")[0])\n stop = g.get_node(op.input(\"End\")[0])\n step = g.get_node(op.input(\"Step\")[0])\n dtype = infer_type(start).checked_type.dtype\n\n params = []\n for param in (start, stop, step):\n param, infered = try_infer_value(param, g.get_params())\n if infered:\n param = param.tolist()\n if isinstance(param, list):\n param = param[0]\n if isinstance(param, _expr.Expr):\n param = _op.squeeze(param)\n else:\n param = _op.const(param, dtype=dtype)\n params.append(param)\n\n out = _op.transform.arange(params[0], params[1], params[2], dtype=dtype)\n g.add_node(op.output(\"Out\")[0], out)","def calcrange(a4lim,data):\r\n a4range=N.intersect1d(N.where(data>a4lim[0])[0],N.where(data<a4lim[1])[0])\r\n return a4range","def _range_func(self, withscores, score_cast_func, decode_value_func=lambda x: x):\n if withscores:\n return lambda score_member: (decode_value_func(score_member[1]), score_cast_func(self._encode(score_member[0]))) # noqa\n else:\n return lambda score_member: decode_value_func(score_member[1])","def _bi_range(start, end):\n if start == end:\n return (start,)\n\n elif end < start:\n return reversed(range(end, start + 1))\n\n else:\n return range(start, end + 1)","def sum_range(lower, upper):\n\n def copies(pmin, pmax):\n if lower <= pmin and pmax <= upper:\n return True\n elif pmax > upper:\n return False\n return copies(pmin+50, pmax+60)\n\n return copies(0, 0)","def str_to_range(lo, hi):\n x = rpki.ipaddrs.parse(lo)\n y = rpki.ipaddrs.parse(hi)\n assert type(x) == type(y)\n if isinstance(x, rpki.ipaddrs.v4addr):\n return rpki.resource_set.resource_range_ipv4(x, y)\n else:\n return rpki.resource_set.resource_range_ipv6(x, y)","def remap_interval(val,\n input_interval_start,\n input_interval_end,\n output_interval_start,\n output_interval_end):\n if val is not None:\n # make sure it stays as a float\n ratio = 1.0*(val - input_interval_start)\n ratio = ratio / (input_interval_end - input_interval_start)\n num = ratio * (output_interval_end - output_interval_start)\n num += output_interval_start\n return num\n else:\n return 0","def adjust_dynamic_range(data, drange_in=(-1, 1), drange_out=(0, 1)):\r\n if drange_in != drange_out:\r\n scale = (np.float32(drange_out[1]) - np.float32(drange_out[0])) / (\r\n np.float32(drange_in[1]) - np.float32(drange_in[0]))\r\n bias = (np.float32(drange_out[0]) - np.float32(drange_in[0]) * scale)\r\n data = data * scale + bias\r\n return torch.clamp(data, min=0, max=1)","def isolate_range(start_addr, end_addr):\n\n split_classification(start_addr)\n split_classification(end_addr)","def range_around(goal_val: int, spread: int, min_val: int = 0, max_val: int = math.inf):\n lower = max(min_val, goal_val - spread)\n upper = min(max_val, goal_val + spread)\n return (lower, upper)","def adjust_dynamic_range(\n data: np.array,\n drange_in: Tuple[int, int],\n drange_out: Tuple[int, int],\n slack: bool = False,\n) -> np.array:\n\n if drange_in != drange_out:\n if not slack:\n old_min, old_max = np.float32(drange_in[0]), np.float32(drange_in[1])\n new_min, new_max = np.float32(drange_out[0]), np.float32(drange_out[1])\n data = (\n (data - old_min) / (old_max - old_min) * (new_max - new_min)\n ) + new_min\n else:\n scale = (np.float32(drange_out[1]) - np.float32(drange_out[0])) / (\n np.float32(drange_in[1]) - np.float32(drange_in[0])\n )\n bias = np.float32(drange_out[0]) - np.float32(drange_in[0]) * scale\n data = data * scale + bias\n data = np.clip(data, a_min=drange_out[0], a_max=drange_out[1])\n return data","def math_map(val, src, dst):\n return ((val - src[0]) / (src[1] - src[0])) * (dst[1] - dst[0]) + dst[0]","def cal(num1, num2, range):\r\n setup(range)\r\n return Andcollections(num1, num2)","def map(self, x, y):\n if near(x[0], xmax) and near(x[1], ymax):\n y[0] = x[0] - xmax\n y[1] = x[1] - ymax\n elif near(x[0], xmax):\n y[0] = x[0] - xmax\n y[1] = x[1]\n elif near(x[1], ymax):\n y[0] = x[0]\n y[1] = x[1] - ymax\n else:\n y[0] = x[0]\n y[1] = x[1]","def get_range(self) -> tuple[int, int]:\n return self.range_from, self.range_to","def sum_range(lower, upper):\n\n def copies(pmin, pmax):\n if lower <= pmin and pmax <= upper:\n return True\n elif pmax > upper:\n return False\n return copies(pmin + 50, pmax + 60) or copies(pmin + 130, pmax + 140)\n\n return copies(0, 0)","def scale_value(value, ip_range, domain=(0,1)):\n x1, x2 = domain\n y1, y2 = ip_range\n\n assert(y1 <= value <= y2)\n\n m = (x2 - x1)/(y2 - y1)\n b = y1 - m * x1\n return m * value - b","def ranges(self, ranges):\n \n self._ranges = ranges","def apply_bound(x, var_min, var_max):\n x.position = np.maximum(x.position, var_min)\n x.position = np.minimum(x.position, var_max)","def age_map(age,cancer):\n ranges = [(0,70),(70,75),(75,80),(80,85),(85,90),(90,95),(95,100),(100,150)]\n scores = [(2,20),(3,19),(4,18),(5,17),(6,15),(7,14),(8,14),(9,13)]\n found = True\n while found:\n for i,r in enumerate(ranges):\n if age in range(ranges[i][0],ranges[i][1]):\n s=scores[i]\n found = False\n break\n return s[cancer]","def _convert_range_boundary(boundary, test_value):\n if _is_string(boundary):\n if boundary.lower() == 'min':\n boundary = test_value - 1\n elif boundary.lower() == 'max':\n boundary = test_value + 1\n else:\n raise error.CommandDescriptionError('Invalid range boundary constant; must be \"min\", \"max\" or integer value')\n \n return boundary","def setRange(self, x_range, y_range):\n pass","def normalise_modular_range(value, min, max):\n return numpy.mod(value-min, max-min)+min","def create_range_map(points_xyz: NDArrayFloat) -> NDArrayByte:\n range = points_xyz[..., 2]\n range = np.round(range).astype(int)\n color = plt.get_cmap(\"turbo\")(np.arange(0, range.max() + 1))\n color = color[range]\n range_cmap: NDArrayByte = (color * 255.0).astype(np.uint8)\n return range_cmap","def setRange(self, x_range, y_range):\n self._pipe.send(\"range,%f,%f,%f,%f\" % (x_range + y_range))","def range(self) -> ty.Tuple[float, float]:\r\n ...","def apply_mapping_func(self, mfunc, domain_taxon_set, range_taxon_set=None):\n self.forward = {}\n self.reverse = {}\n self.domain_taxon_set = domain_taxon_set\n if range_taxon_set is None:\n self.range_taxon_set = TaxonSet()\n else:\n self.range_taxon_set = range_taxon_set\n for dt in self.domain_taxon_set:\n rt = mfunc(dt)\n if rt not in self.range_taxon_set:\n self.range_taxon_set.add(rt)\n self.forward[dt] = rt\n try:\n self.reverse[rt].add(dt)\n except KeyError:\n self.reverse[rt] = set([dt])","def from_range(low, high, step=None, value_name='value'):\n def convert(value):\n if not in_range(low, high, step)(value):\n msg = '{} not in range: {}; must be {} <= {} < {}'.format(\n value_name, value, low, value_name, high\n )\n\n if step is not None:\n msg += ' in steps of {}'.format(step)\n raise ValueError(msg)\n\n if step is not None:\n return (value - low) / step\n return value - low\n return convert","def test_change_min_max(self):\n\n datarange = self.colormap.range\n\n # Perform a dummy mapping.\n a = ArrayDataSource(array([0.0, 0.5, 1.0]))\n datarange.add(a)\n b = self.colormap.map_screen(a.get_data())\n datarange.remove(a)\n\n # Update the min_value.\n datarange.low = -1.0\n\n # Test that the map still works.\n a = ArrayDataSource(array([-1.0, 0.0, 1.0]))\n datarange.add(a)\n b = self.colormap.map_screen(a.get_data())\n datarange.remove(a)\n expected = array([0.0, 0.5, 1.0])\n\n close = allclose(ravel(b[:,:1]), expected, atol=0.02)\n self.assert_(close,\n \"Changing min value broke map. Expected %s. Got %s\" % (expected, b[:,:1]))\n\n # Update the max_value.\n datarange.high = 0.0\n # Test that the map still works.\n a = ArrayDataSource(array([-1.0, -0.5, 0.0]))\n datarange.add(a)\n b = self.colormap.map_screen(a.get_data())\n datarange.remove(a)\n expected = array([0.0, 0.5, 1.0])\n\n close = allclose(ravel(b[:,:1]), expected, atol=0.02)\n self.assert_(close,\n \"Changing min value broke map. Expected %s. Got %s\" % (expected, b[:,:1]))\n\n\n return","def remap(x: float, min_x: float, max_x: float, min_y: float, max_y: float) -> float:\n return min_y + (max_y - min_y) * ((x - min_x) / (max_x - min_x))","def range_overlap(range1, range2):\n return range(max(range1[0], range2[0]), min(range1[1], range2[1]))","def convert_range(option, opt_str, value, parser):\n # Preserve the original option string for print output.\n\n parser.values.ensure_value(\"raw_%s\" % option.dest, value)\n\n # Place the max and min into a single entry for each found\n # threshold. This lets a user see all possible ranges passed by\n # the user, and select a set based on specification order.\n\n for part in value.split(','):\n parser.values.ensure_value(option.dest, []).append(get_range(part))","def test_basic_handling_range_with_variable_bounds(spark_ctx):\n\n dr = Drudge(spark_ctx)\n\n j1, j2 = symbols('j1 j2')\n m1, m2 = symbols('m1, m2')\n j_max = symbols('j_max')\n j = Range('j', 0, j_max)\n m = Range('m')\n dr.set_dumms(j, [j1, j2])\n dr.set_dumms(m, [m1, m2])\n\n v = Vec('v')\n x = IndexedBase('x')\n tensor = dr.sum((j2, j), (m2, m[0, j2]), x[j2, m2] * v[j2, m2])\n\n reset = tensor.reset_dumms()\n assert reset.n_terms == 1\n term = reset.local_terms[0]\n assert len(term.sums) == 2\n if term.sums[0][1].label == 'j':\n j_sum, m_sum = term.sums\n else:\n m_sum, j_sum = term.sums\n assert j_sum[0] == j1\n assert j_sum[1].args == j.args\n assert m_sum[0] == m1\n assert m_sum[1].label == 'm'\n assert m_sum[1].lower == 0\n assert m_sum[1].upper == j1 # Important!\n assert term.amp == x[j1, m1]\n assert term.vecs == (v[j1, m1],)\n\n # Test that functions can be mapped to the bounds.\n repled = reset.map2scalars(\n lambda x: x.xreplace({j_max: 10}), skip_ranges=False\n )\n assert repled.n_terms == 1\n term = repled.local_terms[0]\n checked = False\n for _, i in term.sums:\n if i.label == 'j':\n assert i.lower == 0\n assert i.upper == 10\n checked = True\n continue\n assert checked","def _setBound(self, value):\n if self._colormap is not None:\n if self._index == 0:\n min_ = value\n max_ = self._colormap.getVMax()\n else: # self._index == 1\n min_ = self._colormap.getVMin()\n max_ = value\n\n if max_ is not None and min_ is not None and min_ > max_:\n min_, max_ = max_, min_\n self._colormap.setVRange(min_, max_)","def midrange(lo, hi, mid=0, scale=1.0):\n return [min(mid, (mid + lo) / (1.0 + scale)),\n max(mid, (mid + hi) / (1.0 + scale))]","def range_callback(data):\n global D\n D.ranges = data.ranges","def scale_range(x, input_range, target_range):\n\n range = [np.amin(x), np.amax(x)]\n x_std = (x - input_range[0]) / (1.0*(input_range[1] - input_range[0]))\n x_scaled = x_std * (1.0*(target_range[1] - target_range[0])) + target_range[0]\n return x_scaled, range","def scale_range(data, minTo, maxTo):\n minFrom = np.min(data)\n maxFrom = np.max(data)\n \n scaled_data = []\n \n for point in data:\n new_point = minTo + (maxTo - minTo) * ((point - minFrom)/(maxFrom - minFrom))\n scaled_data.append(new_point)\n \n return scaled_data","def range(series):\n return min(series), max(series)","def _bound(x, min_value, max_value):\n return np.maximum(min_value, np.minimum(x, max_value))","def set_range(\n self,\n axis: Union[int, Sequence[int]],\n _range: Union[\n Sequence[Union[int, float]], Sequence[Sequence[Union[int, float]]]\n ],\n ):\n if isinstance(axis, Integral):\n axis = assert_axis_in_bounds(axis, self.ndim) # type: ignore\n if self.range[axis] != _range:\n full_range = list(self.range)\n full_range[axis] = _range\n self.range = full_range\n else:\n full_range = list(self.range)\n # cast range to list for list comparison below\n _range = list(_range) # type: ignore\n axis = tuple(axis) # type: ignore\n if len(axis) != len(_range):\n raise ValueError(\n trans._(\"axis and _range sequences must have equal length\")\n )\n if _range != full_range:\n for ax, r in zip(axis, _range):\n ax = assert_axis_in_bounds(int(ax), self.ndim)\n full_range[ax] = r\n self.range = full_range","def _range_overapped(self, x, y):\n xs = set( range(x[0], x[1]))\n ys = set( range(y[0], y[1]))\n return xs.intersection(ys)","def __normalize(self, value, lower_bound, upper_bound):\n\n min_max_diff = self.max - self.min\n bound_diff = upper_bound - lower_bound\n return (value - self.min) / min_max_diff * bound_diff + lower_bound","def get_price_range_map(data_map):\n res_map = defaultdict(lambda: deepcopy(static_constants.UNIT_PRICE_DEFAULT))\n for key, list_of_price in data_map.items():\n list_of_price.sort()\n lower_price = np.percentile(list_of_price, 40)\n higher_price = np.percentile(list_of_price, 70)\n median_price = np.percentile(list_of_price, 50)\n res_map[key] = {'lower_price': lower_price, 'median_price': median_price, 'higher_price': higher_price}\n return res_map","def map_range_cats(column):\r\n cats = find_cats(column)\r\n range_means = []\r\n for s in cats:\r\n if s == 'Unknown':\r\n range_means.append(0)\r\n else:\r\n range_means.append(extract_nums(s))\r\n sorted_range_means = np.sort(range_means)\r\n order_idx = np.argsort(range_means)\r\n cats = cats[order_idx]\r\n # Replace the Unknown income with the average of the midpoints\r\n # This could be done with a weighted average (using the frequency counts of other intervals)\r\n sorted_range_means[0] = np.mean(sorted_range_means[1:])\r\n new_order_idx = np.argsort(sorted_range_means)\r\n #income is in units of $10K\r\n return np.sort(sorted_range_means)/10, cats[new_order_idx]","def lmap(v: float, x: Interval, y: Interval) -> float:\n return y[0] + (v - x[0]) * (y[1] - y[0]) / (x[1] - x[0])","def simplebounds(cls, val, lower, upper):\n if val < lower:\n val = lower\n if val > upper:\n val = upper\n return val","def map_axis_interval(axis, start, stop):\n try:\n map = axis.mapInterval((start, stop))\n except Exception:\n raise WPSError('Unabled to map interval {!r} to {!r}', start, stop)\n\n return map","def add_range(bt, ordered, low, high):\n\n if low <= high:\n mid = (low+high)//2\n\n bt.add(ordered[mid])\n add_range(bt, ordered, low, mid-1)\n add_range(bt, ordered, mid+1, high)","def range_match(verifield, ranges):\n return verifield[0] >= ranges[0][0] and verifield[0] <= ranges[0][1] and verifield[1] >= ranges[1][0] and verifield[1] <= ranges[1][1]","def rescale(range1, range2):\n min1, max1, min2, max2 = min(range1), max(range1), min(range2), max(range2)\n def resize(value):\n return (((value - min1) * (max2 - min2)) / (max1 - min1)) + min2\n return resize","def process_pain(x, lb, ub):\n x = x.abs()\n x.loc[(x > ub)] = 8\n x.loc[(x < lb) | (x > ub)] = np.nan\n return x","def process_O2(x, lb, ub):\n x = x.abs()\n x.loc[(x <= 1) & (x > 0)] = x.loc[(x <= 1) & (x > 0)] * 100\n x.loc[(x <= 10) & (x > 1)] = x.loc[(x <= 10) & (x > 1)] * 10\n x.loc[(x <= lb ) | (x > ub)] = np.nan\n return x","def _builtin_between(low, high, value, **k):\n mode = check_mode((low, high, value), ['iii', 'iiv'], functor='between', **k)\n low_v = int(low)\n high_v = int(high)\n if mode == 0: # Check\n value_v = int(value)\n if low_v <= value_v <= high_v:\n return [(low, high, value)]\n else: # Enumerate\n results = []\n for value_v in range(low_v, high_v + 1):\n results.append((low, high, Constant(value_v)))\n return results","def _convert_bound(value, lower_bound, upper_bound):\n # Converts value to 16 bit two's complement integer via bitwise.\n most_sig_bit = 0x8000\n\n # Gets the two least significant bits\n convert_val = value & _BYTE << _BYTE_SIZE | value & _BYTE\n # Extends the most significant bit if it is a 1. This is done by\n # carrying out the most significant bit.\n if bool(convert_val & most_sig_bit):\n convert_val |= ~(_BYTE << _BYTE_SIZE | _BYTE)\n\n # Bounds the converted value\n if convert_val > upper_bound:\n return upper_bound\n elif convert_val < lower_bound:\n return lower_bound\n return convert_val","def set_range(self, new_range):\n self.range = new_range\n if new_range == 2:\n self.i2c.writeto_mem(accel_address, data_format, b'\\x00')\n self.get_offset()\n elif new_range == 4:\n self.i2c.writeto_mem(accel_address, data_format, b'\\x01')\n self.get_offset()\n elif new_range == 8:\n self.i2c.writeto_mem(accel_address, data_format, b'\\x02')\n self.get_offset()\n elif new_range == 16:\n self.i2c.writeto_mem(accel_address, data_format, b'\\x03')\n self.get_offset()\n else:\n print(\"range can be 2, 4, 8, or 16\")","def create(self, range_value):\n return product(range(2), repeat=range_value[0])","def mapping(x, xp, fp):\n xmin, xmax = xp\n fmin, fmax = fp\n slope = (fmax - fmin) / (xmax - xmin)\n return (x - xmin) * slope + fmin","def clamp(num,start,end):\n if num >= start and num <= end: return num\n elif num < start: return start\n elif num > end: return end"],"string":"[\n \"def map_to_range(val, old_min, old_max, new_min, new_max):\\n return new_max - (val - old_min) * (new_max - new_min) / (old_max - old_min)\",\n \"def map(value, in_low, in_high, out_low, out_high):\\n # example from /animation_nodes/nodes/number/map_range.py\\n # if inMin == inMax:\\n # newValue = 0\\n # # with clamping\\n # if inMin < inMax:\\n # _value = min(max(value, inMin), inMax)\\n # else:\\n # _value = min(max(value, inMax), inMin)\\n # with interpolation\\n # newValue = outMin + interpolation(\\n # (_value - inMin) / (inMax - inMin)\\n # ) * (outMax - outMin)\\n # without interpolation\\n # newValue = outMin + (\\n # (_value - inMin) / (inMax - inMin)\\n # ) * (outMax - outMin)\\n # # without clamping\\n # newValue = outMin + (\\n # (value - inMin) / (inMax - inMin)\\n # ) * (outMax - outMin)\\n # # without clamping - reworded\\n # result = (\\n # (\\n # ((value - in_low) / (in_high - in_low)) *\\n # (out_high - out_low)\\n # ) + out_low\\n # )\\n\\n result = None\\n\\n # based on http://arduino.cc/en/Reference/Map\\n # and http://stackoverflow.com/a/5650012/574981\\n result = (\\n (\\n ((value - in_low) * (out_high - out_low)) /\\n (in_high - in_low)\\n ) + out_low\\n )\\n\\n return result\",\n \"def map_range(x, in_min, in_max, out_min, out_max):\\n mapped = (x-in_min) * (out_max - out_min) / (in_max-in_min) + out_min\\n if out_min <= out_max:\\n return max(min(mapped, out_max), out_min)\\n return min(max(mapped, out_max), out_min)\",\n \"def mapRange(num, min1, max1, min2, max2, clamp=True):\\n if(clamp and num < min1):\\n return min2\\n if(clamp and num > max1):\\n return max2\\n\\n num1 = (num - min1) / (max1 - min1)\\n num2 = (num1 * (max2 - min2)) + min2\\n return num2\",\n \"def map_between(value, start, stop):\\n\\n return (stop - start) * value + start\",\n \"def remap_interval(val, in_start, in_end, out_start, out_end):\\n in_range = in_end-in_start\\n out_range = out_end-out_start\\n return (val-in_start)/in_range*out_range+out_start\",\n \"def map_range( self, rng ):\\n rmap = {\\n '2 nA': pac.Ammeter.CurrentRange.N2,\\n '20 nA': pac.Ammeter.CurrentRange.N20,\\n '200 nA': pac.Ammeter.CurrentRange.N200,\\n '2 uA': pac.Ammeter.CurrentRange.U2,\\n '20 uA': pac.Ammeter.CurrentRange.U20,\\n '200 uA': pac.Ammeter.CurrentRange.U200,\\n '2 mA': pac.Ammeter.CurrentRange.M2,\\n '20 mA': pac.Ammeter.CurrentRange.M20\\n }\\n \\n if rng in rmap:\\n return rmap[ rng ]\\n \\n else:\\n raise ValueError( 'Invalid range' )\",\n \"def translate(value, from_min, from_max, to_min, to_max):\\n # Figure out how 'wide' each range is\\n left_span = from_max - from_min\\n right_span = to_max - to_min\\n\\n # Convert the left range into a 0-1 range (float)\\n value_scaled = float(value - from_min) / float(left_span)\\n\\n # Convert the 0-1 range into a value in the right range.\\n return to_min + (value_scaled * right_span)\",\n \"def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\\n inputrange = float(input_interval_end) - float(input_interval_start) #finds length or original interval\\n outputrange = float(output_interval_end) - float(output_interval_start) #finds length of target interval\\n scaledvalue = float(val) - input_interval_start #finds how far through the interval the value is \\n value = ( scaledvalue / inputrange ) * outputrange + output_interval_start\\n return value\",\n \"def remap(self, value, from1, to1, from2, to2):\\n return from2 + (value - from1) * (to2 - from2) / (to1 - from1)\",\n \"def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\\n # your code goes here\",\n \"def map_bound(value, in_low, in_high, out_low, out_high):\\n result = None\\n\\n if value <= in_low:\\n result = out_low\\n else:\\n if value >= in_high:\\n result = out_high\\n else:\\n # http://stackoverflow.com/a/5650012/574981\\n result = out_low + (\\n (out_high - out_low) * (value - in_low) / (in_high - in_low)\\n )\\n return result\",\n \"def translate(value, input_min, input_max, output_min, output_max):\\n # Figure out how 'wide' each range is\\n input_span = input_max - input_min\\n output_span = output_max - output_min\\n\\n # Convert the left range into a 0-1 range (float)\\n value_scaled = float(value - input_min) / float(input_span)\\n\\n # Convert the 0-1 range into a value in the right range.\\n return output_min + (value_scaled * output_span)\",\n \"def remap(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\\n weight_end = float(val-input_interval_start)/(input_interval_end-input_interval_start)\\n weight_start = float(input_interval_end-val)/(input_interval_end-input_interval_start)\\n\\n return (weight_end*output_interval_end)+(weight_start*output_interval_start)\",\n \"def translate(self, value, left_min, left_max, right_min=None, right_max=None):\\n if right_min is None:\\n right_min = self.values['pulse_min'].data\\n if right_max is None:\\n right_max = self.values['pulse_max'].data\\n # Figure out how 'wide' each range is\\n left_span = left_max - left_min\\n right_span = right_max - right_min\\n # Convert the left range into a 0-1 range (float)\\n value_scaled = float(value - left_min) / float(left_span)\\n # Convert the 0-1 range into a value in the right range.\\n return int(right_min + (value_scaled * right_span))\",\n \"def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\\n return (val - input_interval_start)/float(input_interval_end - input_interval_start)*(\\n output_interval_end - output_interval_start) + output_interval_start\",\n \"def remap(\\n n: int, start1: int, stop1: int, start2: int, stop2: int, withinBounds: bool = True\\n) -> int:\\n newval = (n - start1) / (stop1 - start1) * (stop2 - start2) + start2\\n if not withinBounds:\\n return newval\\n if start2 < stop2:\\n return constrain(newval, start2, stop2)\\n else:\\n return constrain(newval, stop2, start2)\",\n \"def translate(value, leftMin, leftMax, rightMin, rightMax):\\n # Figure out how 'wide' each range is\\n leftSpan = leftMax - leftMin\\n rightSpan = rightMax - rightMin\\n\\n # Convert the left range into a 0-1 range (float)\\n valueScaled = float(value - leftMin) / float(leftSpan)\\n\\n # Convert the 0-1 range into a value in the right range.\\n return rightMin + (valueScaled * rightSpan)\",\n \"def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\\n \\n return ((float(val-input_interval_start) * (output_interval_end-output_interval_start)) / (input_interval_end-input_interval_start)) + output_interval_start\",\n \"def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\\n x=(float(val)-float(input_interval_start))\\n y=(float(input_interval_end)-float(input_interval_start))\\n z=x/y\\n return output_interval_start+(z*(output_interval_end-output_interval_start))\",\n \"def mapVal(inputPos, in_min, in_max, out_min, out_max):\\n \\n \\n scale = ((out_max - out_min) / (in_max - in_min))\\n return float(((inputPos - in_min) * scale) + out_min)\",\n \"def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\\n convert = float (val - input_interval_start) / float ( input_interval_end - input_interval_start)\\n output1 = output_interval_start + convert* (output_interval_end - output_interval_start)\\n return output1\",\n \"def merge_ranges():\",\n \"def newval_from_range_map(v: INT_OR_INTLIST, range_map: Tuple[List[int], List[int]]) -> INT_OR_INTLIST:\\n\\t# support both int and list-of-int inputs... do basically the same thing, just looped\\n\\t# if input is list, IT MUST BE IN ASCENDING SORTED ORDER\\n\\t# core idea: walk BACKWARDS along the range_map until i find the start that is CLOSEST BELOW the input v\\n\\tif isinstance(v, int):\\n\\t\\t# # bisect_right: same as bisect_left but when matching something already in it it goes one to the right\\n\\t\\tpos = core.bisect_right(range_map[0], v)\\n\\t\\tif pos == 0:\\n\\t\\t\\t# if it doesnt find a block starting below v, then the offset is 0\\n\\t\\t\\treturn v\\n\\t\\telse:\\n\\t\\t\\t# return the input value minus the applicable offset\\n\\t\\t\\treturn v - range_map[1][pos-1]\\n\\telse:\\n\\t\\t# if given a list, the list is ordered so take advantage of that to pick up where the previous item left off\\n\\t\\t# walk backwards along both lists side-by-side\\n\\t\\tretme = []\\n\\t\\tinput_idx = len(v) - 1\\n\\t\\tidx = len(range_map[0]) - 1\\n\\t\\twhile idx >= 0 and input_idx >= 0:\\n\\t\\t\\tif range_map[0][idx] <= v[input_idx]:\\n\\t\\t\\t\\t# return the input value minus the applicable offset\\n\\t\\t\\t\\tretme.append(v[input_idx] - range_map[1][idx])\\n\\t\\t\\t\\tinput_idx -= 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tidx -= 1\\n\\t\\tif input_idx != -1:\\n\\t\\t\\t# if it finished walking down the range-list before it finished the input-list, all remaining inputs are unchanged\\n\\t\\t\\tretme += reversed(v[0:input_idx+1])\\n\\t\\tretme.reverse()\\n\\t\\treturn retme\",\n \"def fit_to_range(val: float, a: float, b: float, a1: float, b1: float) -> float:\\n new_value = ((val - a) / (b - a)) * (b1 - a1) + a1\\n return new_value\",\n \"def _translate_range(self, len_, start, end):\\n start = int(start)\\n end = int(end)\\n if start < 0:\\n start += len_\\n start = max(0, min(start, len_))\\n if end < 0:\\n end += len_\\n end = max(-1, min(end, len_ - 1))\\n return start, end\",\n \"def expand_ranges(ranges):\\n for low, high in low_high_pairs:\\n for j in range(low, high+1):\\n yield j\",\n \"def define_range():\\n\\n def_range = {'lt': [0.0, 24.0],\\n 'lon': [0.0, 360.0],\\n 'angle': [0.0, 2.0 * np.pi]}\\n\\n return def_range\",\n \"def set_mapping(self, value_min, value_min_raw, value_max, value_max_raw):\\n assert value_min <= value_max\\n # prevent division by zero.\\n if value_min == value_max:\\n value_max += 1.\\n if value_min_raw == value_max_raw:\\n value_max_raw += 1.\\n self.value_min = value_min\\n self.value_max = value_max\\n self.value_min_raw = value_min_raw\\n self.value_max_raw = value_max_raw\\n self._value_scale = (self.value_max - self.value_min) / (self.value_max_raw - self.value_min_raw)\",\n \"def m_to_range(self, data):\\n return (data - self._min_range_m) / self._total_range\",\n \"def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\\n\\n\\t# shift the zero\\n\\tzero = (output_interval_start - input_interval_start)\\n\\t\\n\\t# stretch/compress after shifting\\n\\tchange_factor = float(output_interval_end)/ (input_interval_end + zero)\\n\\n\\t# apply stretching/compression\\n\\tnew_value = (val+zero)*change_factor\\n\\n\\treturn new_value\",\n \"def new_range(r):\\n if isinstance(r, list) or isinstance(r, tuple) and len(r) == 2:\\n lower = r[0]\\n upper = r[1]\\n else:\\n lower = r\\n upper = r\\n lower = int(lower)\\n upper = int(upper)\\n return range(lower, upper + 1)\",\n \"def set_maprange(xmin, ymin, xmax, ymax, epsg_in='epsg:4326'):\\n outProj = pyproj.Proj(init='epsg:3857')\\n inProj = pyproj.Proj(init=epsg_in)\\n xmin,ymin = 75, -55\\n xmax,ymax = 175, -5\\n x1,y1 = pyproj.transform(inProj,outProj,xmin,ymin)\\n x2,y2 = pyproj.transform(inProj,outProj,xmax,ymax)\\n return x1, y1, x2, y2\",\n \"def math_map_list(values, toMin=0, toMax=1):\\n minValue = min(values)\\n maxValue = max(values)\\n delta = maxValue - minValue\\n deltaTarget = toMax - toMin\\n newValues = [toMin +(value-minValue)*deltaTarget/delta for value in values]\\n return newValues\",\n \"def range_to_m(self, data):\\n return data * self._total_range + self._min_range_m\",\n \"def from_inclusive(a, b):\\n c = int(b > a)*2-1\\n return range(a, b+c, c)\",\n \"def new_ranges(rs):\\n return tuple(chain(*[new_range(r) for r in rs]))\",\n \"def normalizeToRange(v, a, b):\\n return (v - a) / (b - a)\",\n \"def domain_range(domain, _range=[0, 1], return_transform=False):\\n\\n if not return_transform:\\n return interp1d([min(domain), max(domain)], [min(_range), max(_range)], bounds_error=False)\\n else:\\n m = interp1d([min(domain), max(domain)], [min(_range), max(_range)])\\n return [float(m(v)) for v in domain] # Take float, else returns weird numpy.ndarray element\",\n \"def range(self, value):\\n self.value_range = tuple([float(x) for x in value.split(':')])\",\n \"def _adjustRange(self, start, end):\\n adjusted_start = start\\n if self._start:\\n if end < self._start:\\n return None\\n adjusted_start = max(self._start, start)\\n \\n adjusted_end = end\\n if self._end:\\n if self._end < start:\\n return None\\n adjusted_end = min(self._end, end)\\n \\n return (adjusted_start, adjusted_end)\",\n \"def convert_range(g, op, block):\\n\\n start = g.get_node(op.input(\\\"Start\\\")[0])\\n stop = g.get_node(op.input(\\\"End\\\")[0])\\n step = g.get_node(op.input(\\\"Step\\\")[0])\\n dtype = infer_type(start).checked_type.dtype\\n\\n params = []\\n for param in (start, stop, step):\\n param, infered = try_infer_value(param, g.get_params())\\n if infered:\\n param = param.tolist()\\n if isinstance(param, list):\\n param = param[0]\\n if isinstance(param, _expr.Expr):\\n param = _op.squeeze(param)\\n else:\\n param = _op.const(param, dtype=dtype)\\n params.append(param)\\n\\n out = _op.transform.arange(params[0], params[1], params[2], dtype=dtype)\\n g.add_node(op.output(\\\"Out\\\")[0], out)\",\n \"def calcrange(a4lim,data):\\r\\n a4range=N.intersect1d(N.where(data>a4lim[0])[0],N.where(data<a4lim[1])[0])\\r\\n return a4range\",\n \"def _range_func(self, withscores, score_cast_func, decode_value_func=lambda x: x):\\n if withscores:\\n return lambda score_member: (decode_value_func(score_member[1]), score_cast_func(self._encode(score_member[0]))) # noqa\\n else:\\n return lambda score_member: decode_value_func(score_member[1])\",\n \"def _bi_range(start, end):\\n if start == end:\\n return (start,)\\n\\n elif end < start:\\n return reversed(range(end, start + 1))\\n\\n else:\\n return range(start, end + 1)\",\n \"def sum_range(lower, upper):\\n\\n def copies(pmin, pmax):\\n if lower <= pmin and pmax <= upper:\\n return True\\n elif pmax > upper:\\n return False\\n return copies(pmin+50, pmax+60)\\n\\n return copies(0, 0)\",\n \"def str_to_range(lo, hi):\\n x = rpki.ipaddrs.parse(lo)\\n y = rpki.ipaddrs.parse(hi)\\n assert type(x) == type(y)\\n if isinstance(x, rpki.ipaddrs.v4addr):\\n return rpki.resource_set.resource_range_ipv4(x, y)\\n else:\\n return rpki.resource_set.resource_range_ipv6(x, y)\",\n \"def remap_interval(val,\\n input_interval_start,\\n input_interval_end,\\n output_interval_start,\\n output_interval_end):\\n if val is not None:\\n # make sure it stays as a float\\n ratio = 1.0*(val - input_interval_start)\\n ratio = ratio / (input_interval_end - input_interval_start)\\n num = ratio * (output_interval_end - output_interval_start)\\n num += output_interval_start\\n return num\\n else:\\n return 0\",\n \"def adjust_dynamic_range(data, drange_in=(-1, 1), drange_out=(0, 1)):\\r\\n if drange_in != drange_out:\\r\\n scale = (np.float32(drange_out[1]) - np.float32(drange_out[0])) / (\\r\\n np.float32(drange_in[1]) - np.float32(drange_in[0]))\\r\\n bias = (np.float32(drange_out[0]) - np.float32(drange_in[0]) * scale)\\r\\n data = data * scale + bias\\r\\n return torch.clamp(data, min=0, max=1)\",\n \"def isolate_range(start_addr, end_addr):\\n\\n split_classification(start_addr)\\n split_classification(end_addr)\",\n \"def range_around(goal_val: int, spread: int, min_val: int = 0, max_val: int = math.inf):\\n lower = max(min_val, goal_val - spread)\\n upper = min(max_val, goal_val + spread)\\n return (lower, upper)\",\n \"def adjust_dynamic_range(\\n data: np.array,\\n drange_in: Tuple[int, int],\\n drange_out: Tuple[int, int],\\n slack: bool = False,\\n) -> np.array:\\n\\n if drange_in != drange_out:\\n if not slack:\\n old_min, old_max = np.float32(drange_in[0]), np.float32(drange_in[1])\\n new_min, new_max = np.float32(drange_out[0]), np.float32(drange_out[1])\\n data = (\\n (data - old_min) / (old_max - old_min) * (new_max - new_min)\\n ) + new_min\\n else:\\n scale = (np.float32(drange_out[1]) - np.float32(drange_out[0])) / (\\n np.float32(drange_in[1]) - np.float32(drange_in[0])\\n )\\n bias = np.float32(drange_out[0]) - np.float32(drange_in[0]) * scale\\n data = data * scale + bias\\n data = np.clip(data, a_min=drange_out[0], a_max=drange_out[1])\\n return data\",\n \"def math_map(val, src, dst):\\n return ((val - src[0]) / (src[1] - src[0])) * (dst[1] - dst[0]) + dst[0]\",\n \"def cal(num1, num2, range):\\r\\n setup(range)\\r\\n return Andcollections(num1, num2)\",\n \"def map(self, x, y):\\n if near(x[0], xmax) and near(x[1], ymax):\\n y[0] = x[0] - xmax\\n y[1] = x[1] - ymax\\n elif near(x[0], xmax):\\n y[0] = x[0] - xmax\\n y[1] = x[1]\\n elif near(x[1], ymax):\\n y[0] = x[0]\\n y[1] = x[1] - ymax\\n else:\\n y[0] = x[0]\\n y[1] = x[1]\",\n \"def get_range(self) -> tuple[int, int]:\\n return self.range_from, self.range_to\",\n \"def sum_range(lower, upper):\\n\\n def copies(pmin, pmax):\\n if lower <= pmin and pmax <= upper:\\n return True\\n elif pmax > upper:\\n return False\\n return copies(pmin + 50, pmax + 60) or copies(pmin + 130, pmax + 140)\\n\\n return copies(0, 0)\",\n \"def scale_value(value, ip_range, domain=(0,1)):\\n x1, x2 = domain\\n y1, y2 = ip_range\\n\\n assert(y1 <= value <= y2)\\n\\n m = (x2 - x1)/(y2 - y1)\\n b = y1 - m * x1\\n return m * value - b\",\n \"def ranges(self, ranges):\\n \\n self._ranges = ranges\",\n \"def apply_bound(x, var_min, var_max):\\n x.position = np.maximum(x.position, var_min)\\n x.position = np.minimum(x.position, var_max)\",\n \"def age_map(age,cancer):\\n ranges = [(0,70),(70,75),(75,80),(80,85),(85,90),(90,95),(95,100),(100,150)]\\n scores = [(2,20),(3,19),(4,18),(5,17),(6,15),(7,14),(8,14),(9,13)]\\n found = True\\n while found:\\n for i,r in enumerate(ranges):\\n if age in range(ranges[i][0],ranges[i][1]):\\n s=scores[i]\\n found = False\\n break\\n return s[cancer]\",\n \"def _convert_range_boundary(boundary, test_value):\\n if _is_string(boundary):\\n if boundary.lower() == 'min':\\n boundary = test_value - 1\\n elif boundary.lower() == 'max':\\n boundary = test_value + 1\\n else:\\n raise error.CommandDescriptionError('Invalid range boundary constant; must be \\\"min\\\", \\\"max\\\" or integer value')\\n \\n return boundary\",\n \"def setRange(self, x_range, y_range):\\n pass\",\n \"def normalise_modular_range(value, min, max):\\n return numpy.mod(value-min, max-min)+min\",\n \"def create_range_map(points_xyz: NDArrayFloat) -> NDArrayByte:\\n range = points_xyz[..., 2]\\n range = np.round(range).astype(int)\\n color = plt.get_cmap(\\\"turbo\\\")(np.arange(0, range.max() + 1))\\n color = color[range]\\n range_cmap: NDArrayByte = (color * 255.0).astype(np.uint8)\\n return range_cmap\",\n \"def setRange(self, x_range, y_range):\\n self._pipe.send(\\\"range,%f,%f,%f,%f\\\" % (x_range + y_range))\",\n \"def range(self) -> ty.Tuple[float, float]:\\r\\n ...\",\n \"def apply_mapping_func(self, mfunc, domain_taxon_set, range_taxon_set=None):\\n self.forward = {}\\n self.reverse = {}\\n self.domain_taxon_set = domain_taxon_set\\n if range_taxon_set is None:\\n self.range_taxon_set = TaxonSet()\\n else:\\n self.range_taxon_set = range_taxon_set\\n for dt in self.domain_taxon_set:\\n rt = mfunc(dt)\\n if rt not in self.range_taxon_set:\\n self.range_taxon_set.add(rt)\\n self.forward[dt] = rt\\n try:\\n self.reverse[rt].add(dt)\\n except KeyError:\\n self.reverse[rt] = set([dt])\",\n \"def from_range(low, high, step=None, value_name='value'):\\n def convert(value):\\n if not in_range(low, high, step)(value):\\n msg = '{} not in range: {}; must be {} <= {} < {}'.format(\\n value_name, value, low, value_name, high\\n )\\n\\n if step is not None:\\n msg += ' in steps of {}'.format(step)\\n raise ValueError(msg)\\n\\n if step is not None:\\n return (value - low) / step\\n return value - low\\n return convert\",\n \"def test_change_min_max(self):\\n\\n datarange = self.colormap.range\\n\\n # Perform a dummy mapping.\\n a = ArrayDataSource(array([0.0, 0.5, 1.0]))\\n datarange.add(a)\\n b = self.colormap.map_screen(a.get_data())\\n datarange.remove(a)\\n\\n # Update the min_value.\\n datarange.low = -1.0\\n\\n # Test that the map still works.\\n a = ArrayDataSource(array([-1.0, 0.0, 1.0]))\\n datarange.add(a)\\n b = self.colormap.map_screen(a.get_data())\\n datarange.remove(a)\\n expected = array([0.0, 0.5, 1.0])\\n\\n close = allclose(ravel(b[:,:1]), expected, atol=0.02)\\n self.assert_(close,\\n \\\"Changing min value broke map. Expected %s. Got %s\\\" % (expected, b[:,:1]))\\n\\n # Update the max_value.\\n datarange.high = 0.0\\n # Test that the map still works.\\n a = ArrayDataSource(array([-1.0, -0.5, 0.0]))\\n datarange.add(a)\\n b = self.colormap.map_screen(a.get_data())\\n datarange.remove(a)\\n expected = array([0.0, 0.5, 1.0])\\n\\n close = allclose(ravel(b[:,:1]), expected, atol=0.02)\\n self.assert_(close,\\n \\\"Changing min value broke map. Expected %s. Got %s\\\" % (expected, b[:,:1]))\\n\\n\\n return\",\n \"def remap(x: float, min_x: float, max_x: float, min_y: float, max_y: float) -> float:\\n return min_y + (max_y - min_y) * ((x - min_x) / (max_x - min_x))\",\n \"def range_overlap(range1, range2):\\n return range(max(range1[0], range2[0]), min(range1[1], range2[1]))\",\n \"def convert_range(option, opt_str, value, parser):\\n # Preserve the original option string for print output.\\n\\n parser.values.ensure_value(\\\"raw_%s\\\" % option.dest, value)\\n\\n # Place the max and min into a single entry for each found\\n # threshold. This lets a user see all possible ranges passed by\\n # the user, and select a set based on specification order.\\n\\n for part in value.split(','):\\n parser.values.ensure_value(option.dest, []).append(get_range(part))\",\n \"def test_basic_handling_range_with_variable_bounds(spark_ctx):\\n\\n dr = Drudge(spark_ctx)\\n\\n j1, j2 = symbols('j1 j2')\\n m1, m2 = symbols('m1, m2')\\n j_max = symbols('j_max')\\n j = Range('j', 0, j_max)\\n m = Range('m')\\n dr.set_dumms(j, [j1, j2])\\n dr.set_dumms(m, [m1, m2])\\n\\n v = Vec('v')\\n x = IndexedBase('x')\\n tensor = dr.sum((j2, j), (m2, m[0, j2]), x[j2, m2] * v[j2, m2])\\n\\n reset = tensor.reset_dumms()\\n assert reset.n_terms == 1\\n term = reset.local_terms[0]\\n assert len(term.sums) == 2\\n if term.sums[0][1].label == 'j':\\n j_sum, m_sum = term.sums\\n else:\\n m_sum, j_sum = term.sums\\n assert j_sum[0] == j1\\n assert j_sum[1].args == j.args\\n assert m_sum[0] == m1\\n assert m_sum[1].label == 'm'\\n assert m_sum[1].lower == 0\\n assert m_sum[1].upper == j1 # Important!\\n assert term.amp == x[j1, m1]\\n assert term.vecs == (v[j1, m1],)\\n\\n # Test that functions can be mapped to the bounds.\\n repled = reset.map2scalars(\\n lambda x: x.xreplace({j_max: 10}), skip_ranges=False\\n )\\n assert repled.n_terms == 1\\n term = repled.local_terms[0]\\n checked = False\\n for _, i in term.sums:\\n if i.label == 'j':\\n assert i.lower == 0\\n assert i.upper == 10\\n checked = True\\n continue\\n assert checked\",\n \"def _setBound(self, value):\\n if self._colormap is not None:\\n if self._index == 0:\\n min_ = value\\n max_ = self._colormap.getVMax()\\n else: # self._index == 1\\n min_ = self._colormap.getVMin()\\n max_ = value\\n\\n if max_ is not None and min_ is not None and min_ > max_:\\n min_, max_ = max_, min_\\n self._colormap.setVRange(min_, max_)\",\n \"def midrange(lo, hi, mid=0, scale=1.0):\\n return [min(mid, (mid + lo) / (1.0 + scale)),\\n max(mid, (mid + hi) / (1.0 + scale))]\",\n \"def range_callback(data):\\n global D\\n D.ranges = data.ranges\",\n \"def scale_range(x, input_range, target_range):\\n\\n range = [np.amin(x), np.amax(x)]\\n x_std = (x - input_range[0]) / (1.0*(input_range[1] - input_range[0]))\\n x_scaled = x_std * (1.0*(target_range[1] - target_range[0])) + target_range[0]\\n return x_scaled, range\",\n \"def scale_range(data, minTo, maxTo):\\n minFrom = np.min(data)\\n maxFrom = np.max(data)\\n \\n scaled_data = []\\n \\n for point in data:\\n new_point = minTo + (maxTo - minTo) * ((point - minFrom)/(maxFrom - minFrom))\\n scaled_data.append(new_point)\\n \\n return scaled_data\",\n \"def range(series):\\n return min(series), max(series)\",\n \"def _bound(x, min_value, max_value):\\n return np.maximum(min_value, np.minimum(x, max_value))\",\n \"def set_range(\\n self,\\n axis: Union[int, Sequence[int]],\\n _range: Union[\\n Sequence[Union[int, float]], Sequence[Sequence[Union[int, float]]]\\n ],\\n ):\\n if isinstance(axis, Integral):\\n axis = assert_axis_in_bounds(axis, self.ndim) # type: ignore\\n if self.range[axis] != _range:\\n full_range = list(self.range)\\n full_range[axis] = _range\\n self.range = full_range\\n else:\\n full_range = list(self.range)\\n # cast range to list for list comparison below\\n _range = list(_range) # type: ignore\\n axis = tuple(axis) # type: ignore\\n if len(axis) != len(_range):\\n raise ValueError(\\n trans._(\\\"axis and _range sequences must have equal length\\\")\\n )\\n if _range != full_range:\\n for ax, r in zip(axis, _range):\\n ax = assert_axis_in_bounds(int(ax), self.ndim)\\n full_range[ax] = r\\n self.range = full_range\",\n \"def _range_overapped(self, x, y):\\n xs = set( range(x[0], x[1]))\\n ys = set( range(y[0], y[1]))\\n return xs.intersection(ys)\",\n \"def __normalize(self, value, lower_bound, upper_bound):\\n\\n min_max_diff = self.max - self.min\\n bound_diff = upper_bound - lower_bound\\n return (value - self.min) / min_max_diff * bound_diff + lower_bound\",\n \"def get_price_range_map(data_map):\\n res_map = defaultdict(lambda: deepcopy(static_constants.UNIT_PRICE_DEFAULT))\\n for key, list_of_price in data_map.items():\\n list_of_price.sort()\\n lower_price = np.percentile(list_of_price, 40)\\n higher_price = np.percentile(list_of_price, 70)\\n median_price = np.percentile(list_of_price, 50)\\n res_map[key] = {'lower_price': lower_price, 'median_price': median_price, 'higher_price': higher_price}\\n return res_map\",\n \"def map_range_cats(column):\\r\\n cats = find_cats(column)\\r\\n range_means = []\\r\\n for s in cats:\\r\\n if s == 'Unknown':\\r\\n range_means.append(0)\\r\\n else:\\r\\n range_means.append(extract_nums(s))\\r\\n sorted_range_means = np.sort(range_means)\\r\\n order_idx = np.argsort(range_means)\\r\\n cats = cats[order_idx]\\r\\n # Replace the Unknown income with the average of the midpoints\\r\\n # This could be done with a weighted average (using the frequency counts of other intervals)\\r\\n sorted_range_means[0] = np.mean(sorted_range_means[1:])\\r\\n new_order_idx = np.argsort(sorted_range_means)\\r\\n #income is in units of $10K\\r\\n return np.sort(sorted_range_means)/10, cats[new_order_idx]\",\n \"def lmap(v: float, x: Interval, y: Interval) -> float:\\n return y[0] + (v - x[0]) * (y[1] - y[0]) / (x[1] - x[0])\",\n \"def simplebounds(cls, val, lower, upper):\\n if val < lower:\\n val = lower\\n if val > upper:\\n val = upper\\n return val\",\n \"def map_axis_interval(axis, start, stop):\\n try:\\n map = axis.mapInterval((start, stop))\\n except Exception:\\n raise WPSError('Unabled to map interval {!r} to {!r}', start, stop)\\n\\n return map\",\n \"def add_range(bt, ordered, low, high):\\n\\n if low <= high:\\n mid = (low+high)//2\\n\\n bt.add(ordered[mid])\\n add_range(bt, ordered, low, mid-1)\\n add_range(bt, ordered, mid+1, high)\",\n \"def range_match(verifield, ranges):\\n return verifield[0] >= ranges[0][0] and verifield[0] <= ranges[0][1] and verifield[1] >= ranges[1][0] and verifield[1] <= ranges[1][1]\",\n \"def rescale(range1, range2):\\n min1, max1, min2, max2 = min(range1), max(range1), min(range2), max(range2)\\n def resize(value):\\n return (((value - min1) * (max2 - min2)) / (max1 - min1)) + min2\\n return resize\",\n \"def process_pain(x, lb, ub):\\n x = x.abs()\\n x.loc[(x > ub)] = 8\\n x.loc[(x < lb) | (x > ub)] = np.nan\\n return x\",\n \"def process_O2(x, lb, ub):\\n x = x.abs()\\n x.loc[(x <= 1) & (x > 0)] = x.loc[(x <= 1) & (x > 0)] * 100\\n x.loc[(x <= 10) & (x > 1)] = x.loc[(x <= 10) & (x > 1)] * 10\\n x.loc[(x <= lb ) | (x > ub)] = np.nan\\n return x\",\n \"def _builtin_between(low, high, value, **k):\\n mode = check_mode((low, high, value), ['iii', 'iiv'], functor='between', **k)\\n low_v = int(low)\\n high_v = int(high)\\n if mode == 0: # Check\\n value_v = int(value)\\n if low_v <= value_v <= high_v:\\n return [(low, high, value)]\\n else: # Enumerate\\n results = []\\n for value_v in range(low_v, high_v + 1):\\n results.append((low, high, Constant(value_v)))\\n return results\",\n \"def _convert_bound(value, lower_bound, upper_bound):\\n # Converts value to 16 bit two's complement integer via bitwise.\\n most_sig_bit = 0x8000\\n\\n # Gets the two least significant bits\\n convert_val = value & _BYTE << _BYTE_SIZE | value & _BYTE\\n # Extends the most significant bit if it is a 1. This is done by\\n # carrying out the most significant bit.\\n if bool(convert_val & most_sig_bit):\\n convert_val |= ~(_BYTE << _BYTE_SIZE | _BYTE)\\n\\n # Bounds the converted value\\n if convert_val > upper_bound:\\n return upper_bound\\n elif convert_val < lower_bound:\\n return lower_bound\\n return convert_val\",\n \"def set_range(self, new_range):\\n self.range = new_range\\n if new_range == 2:\\n self.i2c.writeto_mem(accel_address, data_format, b'\\\\x00')\\n self.get_offset()\\n elif new_range == 4:\\n self.i2c.writeto_mem(accel_address, data_format, b'\\\\x01')\\n self.get_offset()\\n elif new_range == 8:\\n self.i2c.writeto_mem(accel_address, data_format, b'\\\\x02')\\n self.get_offset()\\n elif new_range == 16:\\n self.i2c.writeto_mem(accel_address, data_format, b'\\\\x03')\\n self.get_offset()\\n else:\\n print(\\\"range can be 2, 4, 8, or 16\\\")\",\n \"def create(self, range_value):\\n return product(range(2), repeat=range_value[0])\",\n \"def mapping(x, xp, fp):\\n xmin, xmax = xp\\n fmin, fmax = fp\\n slope = (fmax - fmin) / (xmax - xmin)\\n return (x - xmin) * slope + fmin\",\n \"def clamp(num,start,end):\\n if num >= start and num <= end: return num\\n elif num < start: return start\\n elif num > end: return end\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7836962","0.7620629","0.7571556","0.7556224","0.7549925","0.7233073","0.7195118","0.7172923","0.7053617","0.70404553","0.70280063","0.6952438","0.6834101","0.68230766","0.67514455","0.6728961","0.67074573","0.6705688","0.66193485","0.6614623","0.66119456","0.65726894","0.6570191","0.65298295","0.6487484","0.646411","0.6430022","0.6326014","0.62785643","0.62764186","0.627121","0.62492377","0.6233819","0.6216739","0.6202686","0.619517","0.6192949","0.6187031","0.6161917","0.6160425","0.6096558","0.60568964","0.6054418","0.6032649","0.602208","0.6012012","0.6005891","0.60012686","0.6001066","0.59958833","0.59690493","0.59510666","0.59497947","0.5942178","0.59394294","0.59079313","0.58527184","0.5836934","0.5835131","0.5833228","0.5825602","0.5818694","0.58183455","0.58032733","0.5803185","0.5782172","0.5781214","0.57756495","0.57662374","0.57647395","0.5761607","0.57476157","0.57447165","0.5740835","0.5733388","0.57296443","0.57093644","0.5686194","0.56814456","0.5669118","0.5659826","0.56473213","0.5642484","0.5640837","0.56396556","0.5634509","0.5632005","0.562629","0.56228185","0.56189823","0.56146604","0.5608172","0.55927604","0.5592655","0.5589324","0.5586958","0.558249","0.5581915","0.5579426","0.5577086"],"string":"[\n \"0.7836962\",\n \"0.7620629\",\n \"0.7571556\",\n \"0.7556224\",\n \"0.7549925\",\n \"0.7233073\",\n \"0.7195118\",\n \"0.7172923\",\n \"0.7053617\",\n \"0.70404553\",\n \"0.70280063\",\n \"0.6952438\",\n \"0.6834101\",\n \"0.68230766\",\n \"0.67514455\",\n \"0.6728961\",\n \"0.67074573\",\n \"0.6705688\",\n \"0.66193485\",\n \"0.6614623\",\n \"0.66119456\",\n \"0.65726894\",\n \"0.6570191\",\n \"0.65298295\",\n \"0.6487484\",\n \"0.646411\",\n \"0.6430022\",\n \"0.6326014\",\n \"0.62785643\",\n \"0.62764186\",\n \"0.627121\",\n \"0.62492377\",\n \"0.6233819\",\n \"0.6216739\",\n \"0.6202686\",\n \"0.619517\",\n \"0.6192949\",\n \"0.6187031\",\n \"0.6161917\",\n \"0.6160425\",\n \"0.6096558\",\n \"0.60568964\",\n \"0.6054418\",\n \"0.6032649\",\n \"0.602208\",\n \"0.6012012\",\n \"0.6005891\",\n \"0.60012686\",\n \"0.6001066\",\n \"0.59958833\",\n \"0.59690493\",\n \"0.59510666\",\n \"0.59497947\",\n \"0.5942178\",\n \"0.59394294\",\n \"0.59079313\",\n \"0.58527184\",\n \"0.5836934\",\n \"0.5835131\",\n \"0.5833228\",\n \"0.5825602\",\n \"0.5818694\",\n \"0.58183455\",\n \"0.58032733\",\n \"0.5803185\",\n \"0.5782172\",\n \"0.5781214\",\n \"0.57756495\",\n \"0.57662374\",\n \"0.57647395\",\n \"0.5761607\",\n \"0.57476157\",\n \"0.57447165\",\n \"0.5740835\",\n \"0.5733388\",\n \"0.57296443\",\n \"0.57093644\",\n \"0.5686194\",\n \"0.56814456\",\n \"0.5669118\",\n \"0.5659826\",\n \"0.56473213\",\n \"0.5642484\",\n \"0.5640837\",\n \"0.56396556\",\n \"0.5634509\",\n \"0.5632005\",\n \"0.562629\",\n \"0.56228185\",\n \"0.56189823\",\n \"0.56146604\",\n \"0.5608172\",\n \"0.55927604\",\n \"0.5592655\",\n \"0.5589324\",\n \"0.5586958\",\n \"0.558249\",\n \"0.5581915\",\n \"0.5579426\",\n \"0.5577086\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7085316"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":79087,"cells":{"query":{"kind":"string","value":"Terms are equal if their strings are the same"},"document":{"kind":"string","value":"def __eq__(self, other):\n return str(self) == str(other)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def distance_unigrams_same(t1, t2):\n t1_terms = make_terms_from_string(t1)\n t2_terms = make_terms_from_string(t2)\n terms1 = set(t1_terms)\n terms2 = set(t2_terms)\n shared_terms = terms1.intersection(terms2)\n #print(shared_terms)\n all_terms = terms1.union(terms2)\n #print(all_terms)\n dist = 1.0 - (len(shared_terms) / float(len(all_terms)))\n return dist","def arrayStringsAreEqual1(self, word1: List[str], word2: List[str]) -> bool:\n word1str = ''.join(word1)\n word2str = ''.join(word2)\n return word1str == word2str","def compare_words(self, word1, word2):\n return Counter(word1) == Counter(word2)","def distance_bigrams_same(t1, t2):\n t1_terms = make_terms_from_string(t1)\n t2_terms = make_terms_from_string(t2)\n terms1 = set(ngrams(t1_terms, 2)) # was using nltk.bigrams\n terms2 = set(ngrams(t2_terms, 2))\n shared_terms = terms1.intersection(terms2)\n #print(shared_terms)\n all_terms = terms1.union(terms2)\n #print(all_terms)\n dist = 1.0\n if len(all_terms) > 0:\n dist = 1.0 - (len(shared_terms) / float(len(all_terms)))\n return dist","def _strings_are_equal(self, value1, value2):\n if value1.lower().strip().replace('_', ' ') == value2.lower().strip().replace('_', ' '):\n return 1\n return 0","def __eq__(self,other):\n if type(other)==type(\"\"):\n return self.word == other\n return self.word == other.word","def test_dtm_equal(self):\n new_dtm = self.dtm1.copy()\n nose.assert_true(self.dtm1 == new_dtm, 'DTMs are not equal')","def test_term_list_removes_duplicates():\n term = SplineTerm(0)\n term_list = term + term\n\n assert isinstance(term_list, TermList)\n assert len(term_list) == 1","def assertSpacelessEqual(self, first, second):\n self.assertEqual(set(first.split()), set(second.split()))","def arrayStringsAreEqual2(self, word1: List[str], word2: List[str]) -> bool:\n \n # i for list idx, j for str idx\n i1 = 0\n j1 = 0\n i2 = 0\n j2 = 0\n \n while i1 < len(word1) and i2 < len(word2):\n if word1[i1][j1] != word2[i2][j2]:\n return False\n \n # update word1 indexes\n if j1 < len(word1[i1])-1:\n j1 += 1\n else:\n i1 += 1\n j1 = 0\n \n # update word2 indexes\n if j2 < len(word2[i2])-1:\n j2 += 1\n else:\n i2 += 1\n j2 = 0\n \n if i1 == len(word1) and i2 == len(word2):\n return True\n \n return False","def test_strings_are_equal(self):\n string1 = 'this is the first string'\n string2 = 'this is the first string' # ==, !is\n string3 = 'this is the second string'\n self.assertEqual(True, comparator.strings_are_equal(string1, string2))\n self.assertEqual(False, comparator.strings_are_equal(string1, string3))","def permutations_equal(str_a, str_b):\n if not isinstance(str_a, str) or not isinstance(str_b, str):\n raise AttributeError(\"inputs must be valid str\")\n if len(str_a) != len(str_b):\n return False\n\n return Counter(str_a) == Counter(str_b)","def check_permutation_of(string1,string2):\n if len(string1) != len(string2): #O(1)\n return False\n return collections.Counter(string1) == collections.Counter(string2) #O(n+n) to make the dictionaries\n #O(n+n) to compare equality?\n #so O(4n) == O(n).","def similarL1(a, b):\n if len(b) > 0:\n for x in b:\n if x == a:\n return True\n return False","def testSynonymDuplicate(self):\n\t\t\t\tone = spinner.Word.objects.get_single('mac', True)\n\t\t\t\ttwo = spinner.Word.objects.get_single('macintosh', True)\n\t\n\t\t\t\tsyn = spinner.Synonym.objects.get_single(one, two, True)\n\t\t\t\t\n\t\t\t\tsyn2 = spinner.Synonym.objects.get_single(two, one, True)\n\n\t\t\t\tassert syn == syn2\n\n\t\t\t\tsyn.delete()\n\t\t\t\tone.delete()\n\t\t\t\ttwo.delete()","def test_dtm_not_equal(self):\n new_dtm = self.dtm1.copy()\n new_dtm.final_states.add('q2')\n nose.assert_true(self.dtm1 != new_dtm, 'DTMs are equal')","def all_equals(solution1, solution2, tol=0.001):\n tokens1 = solution1.split()\n tokens2 = solution2.split()\n\n for token1, token2 in zip(tokens1, tokens2):\n if not equals(token1, token2, tol=tol):\n print(token1, token2)\n return False\n\n return True","def similarL1a(a, b):\n for x in b:\n if x.lower() in a.lower():\n return True\n return False","def similar_strings(s1, s2):\n w1 = set(re.split(r'\\W+', s1))\n w2 = set(re.split(r'\\W+', s2))\n threshold = len(w1) // 2 + 1\n return len(w1 & w2) >= threshold","def _values_is_equal(self, a, b):\n if a is None or b is None:\n return False\n\n a = a.split()\n b = b.split()\n\n if len(a) != len(b):\n return False\n\n return len([i for i, j in zip(a, b) if i == j]) == len(a)","def wordSimilarityRatio(sent_1,sent_2):","def test__same_text_correlation(self):\n \n _log.info('-'*80)\n \n # arrange \n text1 = \"love is rain as long story short\"\n text2 = text1\n\n dump_file = getInputFile(\"swiki_knowledge_output.xml\")\n parsed_file = getOutputFile(\"swiki_knowledge_output.parsed.xml\")\n #wdb_file = getOutputFile(\"swiki_knowledge_output.wdb\")\n\n articles = ['Rain', 'Love', 'Tree'] \n \n # act\n wn.make_dump(dump_file, articles, compress=False)\n wn.parse_dump(dump_file, parsed_file)\n db_wrapper = wn.build_database_wrapper(parsed_file, StopWordsStemmer([]))\n \n #self.addCleanup(os.remove, self.tmp_dump_file)\n \n comparer = SemanticComparer(db_wrapper)\n correlation = comparer.compare(text1, text2)\n _log.info(test_utils.get_texts_correlation_message(text1, text2, correlation))\n self.assertAlmostEqual(correlation, 1.0, msg=\"for same text correlation should be 1\")","def __eq__(self, other):\n for (ngram, value) in self.items():\n if ngram not in other or other[ngram] != value:\n return False\n for (ngram, value) in other.items():\n if ngram not in self or self[ngram] != value:\n return False\n return True","def compare(self,l):\r\n\t\t\r\n\t\t# assume equality\r\n\t\tq = True\r\n\t\t\r\n\t\t# test term by term\r\n\t\tfor i,j in zip(self,l):\r\n\t\t\t\r\n\t\t\t# break at first mismatch\r\n\t\t\tif not i.compare(j):\r\n\t\t\t\tq = False\r\n\t\t\t\tbreak\r\n\t\t\t\t\r\n\t\t# make sure lengths are also equal\r\n\t\tif len(self) != len(l):\r\n\t\t\tq = False\r\n\t\t\t\t\r\n\t\treturn q","def testRandomWord(self):\n word1 = self.searcher.randomWord()\n word2 = self.searcher.randomWord()\n self.assertTrue(len(word1) > 1, 'Word length too short')\n self.assertTrue(len(word2) > 1, 'Word length too short')\n self.assertNotEqual(word1, word2, 'Found the same word')","def test_similarity(self):\n self.assertTrue(np.allclose(self.vectors.similarity('dog.n.01', 'dog.n.01'), 1))\n self.assertTrue(np.allclose(self.vectors.similarity('dog.n.01', 'mammal.n.01'), 0.180901358))","def testEquality(self):\n pass","def same_frequency(num1, num2):\n str1 = str(num1)\n str2 = str(num2)\n\n digits1 = set(str1)\n digits2 = set(str2)\n if digits1 == digits2:\n for digit in digits1:\n if str1.count(digit) != str2.count(digit):\n return False\n return True\n else:\n return False","def verify_anagrams(first_word, second_word):\n first = prep_dict(first_word)\n second = prep_dict(second_word)\n #print first, second\n for k,v in first.iteritems():\n try:\n if second[k] == v:\n pass\n else:\n return False\n except:\n return False\n return True","def string_similarity(a, b):\n return SequenceMatcher(a=a, b=b).ratio()","def match(self, words):\n return words == self.words(len(words))","def test_combine_multiple(self):\n inv_search = 'author:\"gattringer, c*\" keyword:chiral keyword:symmetry -title:chiral'\n spi_search = \"find a c gattringer and k chiral symmetry and not title chiral\"\n self._compare_searches(inv_search, spi_search)","def verify_anagrams(first_word, second_word):\n first_word = sorted(first_word.lower().replace(' ', '')) # list of lower letter in word without\n second_word = sorted(second_word.lower().replace(' ', '')) # whitespaces, sorted ascending\n\n if len(first_word) != len(second_word):\n return False\n else:\n if first_word != second_word:\n return False\n else:\n return True","def string_similarity(item_1, item_2):\n return SequenceMatcher(None, item_1.lower(), item_2.lower()).ratio()","def _alternative(words):\n wordlist = list(words)\n counter = []\n for word in wordlist:\n used = set()\n counter.append(__geterate_tree(word, wordlist, used, 1))\n return max(counter) == len(wordlist)","def text_compare(t1, t2):\n if not t1 and not t2:\n return True\n if t1 == '*' or t2 == '*':\n return True\n return (t1 or '').strip() == (t2 or '').strip()","def __eq__(self, other):\n return (\n isinstance(other, self.__class__)\n and len(self) == len(other)\n and all(term in self for term in other)\n )","def checkPermutation(s, t):\n\n # Count each unique letter in both strings and compare the two dicts.\n s_count = {}\n t_count = {}\n for character in s:\n s_count[character] = s_count.get(character, 0) + 1\n\n for character in t:\n t_count[character] = t_count.get(character, 0) + 1\n\n return s_count == t_count\n\n # Time Complexity: O(n)\n # Space Complexity: O(n)","def similarity(self, e1, e2):\n\t\tpass","def are_similar(left, right):\n left = left.lower()\n right = right.lower()\n if left == right:\n return True\n if left and left in right:\n return True\n if right and right in left:\n return True\n return False","def test_consistent_ids(self) -> None:\n bnode = BNode()\n g0_ts: _TripleSet = {\n (bnode, FOAF.name, Literal(\"Golan Trevize\")),\n (bnode, RDF.type, FOAF.Person),\n }\n bnode = BNode()\n g1_ts: _TripleSet = {\n (bnode, FOAF.name, Literal(\"Janov Pelorat\")),\n (bnode, RDF.type, FOAF.Person),\n }\n\n g0 = Graph()\n g0 += g0_ts\n cg0 = to_canonical_graph(g0)\n cg0_ts = GraphHelper.triple_set(cg0)\n\n g1 = Graph()\n g1 += g1_ts\n cg1 = to_canonical_graph(g1)\n cg1_ts = GraphHelper.triple_set(cg1)\n\n assert cg0_ts.issubset(\n cg1_ts\n ), \"canonical triple set cg0_ts should be a subset of canonical triple set cg1_ts\"","def check_equal_sequence(sup_token_list, entity_token_list):\n import operator as op\n for i in range(0, len(entity_token_list)):\n if op.eq(sup_token_list[i].lower(), entity_token_list[i].lower()):\n continue\n else:\n return False\n return True","def compare_vectors(word_vector1, word_vector2):\n all_words = list(set(word_vector1).union(set(word_vector2)))\n frequency_dict1 = word_frequencies(word_vector1)\n frequency_dict2 = word_frequencies(word_vector2)\n\n frequency_vector1 = [frequency_dict1.get(word, 0) for word in all_words]\n frequency_vector2 = [frequency_dict2.get(word, 0) for word in all_words]\n\n return similarity(frequency_vector1, frequency_vector2)","def values_eq(self, a, b):\r\n return a == b","def test_distribution_with_many_clauses(self):\n spi_search = \"find a mele and brooks and holtkamp and o'connell\"\n inv_search = \"author:mele author:brooks author:holtkamp author:o'connell\"\n self._compare_searches(inv_search, spi_search)","def strings_equal(s1, s2):\n s1 = unicodedata.normalize('NFKC', s1)\n s2 = unicodedata.normalize('NFKC', s2)\n return compare_digest(s1, s2)","def check_strings(aword, anotherword):\n if aword == anotherword:\n return True\n else:\n return False","def check_anagram_with_dict(self, str1, str2):\n str1 = str1.lower()\n str2 = str2.lower()\n str1 = StripText.strip(self, str1)\n str2 = StripText.strip(self, str2)\n str1_count = {}\n str2_count = {}\n for each in str1:\n try:\n if str1_count[each]:\n str1_count[each] += 1\n except:\n str1_count[each] = 1\n for each in str2:\n try:\n if str2_count[each]:\n str2_count[each] += 1\n except:\n str2_count[each] = 1\n for each in str1_count:\n if str1_count[each] == str2_count[each]:\n pass\n else:\n return False\n return True","def isIsomorphic(self, s: str, t: str) -> bool:\n if len(s) != len(t):\n return False\n alphabet = {}\n used = {}\n for i in range(len(s)):\n char = alphabet.get(s[i])\n if char and char != t[i]:\n return False\n if not char and t[i] in used:\n return False\n alphabet[s[i]] = t[i]\n used[t[i]] = True\n return True","def similar(text, database):\n # TODO\n pass","def isEqual(string1, string2):\n return (True)","def exactMatch(self, mention):\n w1 = self.allWords()\n w2 = mention.allWords()\n if len(w1) == len(w2) and w1 == w2:\n return True\n else:\n return False","def test_words_closer_than(self):\n self.assertEqual(self.vectors.words_closer_than('dog.n.01', 'dog.n.01'), [])\n expected = set(['canine.n.02', 'hunting_dog.n.01'])\n self.assertEqual(set(self.vectors.words_closer_than('dog.n.01', 'carnivore.n.01')), expected)","def test_first_equal(self):\n self.assertEqual(heaviest_word(\"man i need a taxi up to ubud\"), \"taxi\")","def _does_words_matches(original_word: str, encoded_word: str) -> bool:\n return(\n len(original_word) == len(encoded_word) and\n original_word[0] == encoded_word[0] and\n original_word[-1] == encoded_word[-1] and\n sorted(original_word[1:-1]) == sorted(encoded_word[1:-1])\n )","def test_equals(self):\n self.assertEqual(cmp(u\"a\", u\"a\"), 0)\n self.assertEqual(cmp(1, 1), 0)\n self.assertEqual(cmp([1], [1]), 0)","def is_same_song(a, b):\n\n for k in 'album', 'title', 'artists':\n if a[k] != b[k]:\n return False\n\n return True","def _equals(a: Union[str, Iterable[str]], b: Union[str, Iterable[str]]) -> bool:\n if isinstance(a, str) and isinstance(b, str):\n return a.replace(' ', '') == b.replace(' ', '')\n elif isinstance(a, Iterable) and isinstance(b, Iterable):\n return all(_equals(a_, b_) for a_, b_ in zip(a, b))\n else:\n raise TypeError(f'arguments must be both strings or both lists, not {type(a)}, {type(b)}')","def test_keys_eq(self):\n self.assertListEqual(self.result, self.expected)","def __eq__(self, other):\n if isinstance(other, Token):\n return self.text == other.text\n else:\n return self.text == other","def total_char_similarity(a,b):\n\ta_words, b_words = map(norm.set_clean_tokens, [a,b])\n\n\ttotal_score = 0\n\tfor ai in a_words:\n\t\tfor bi in b_words:\n\t\t\ttotal_score += similar(ai, bi)\n\treturn total_score","def test_string_similarity_constraint():\n f = SimilarityConstraint(func=LevenshteinDistance(), pred=GreaterThan(0.5))\n assert f('BROOKLYN', 'BROKLYN')\n assert not f('BROOKLYN', 'QUEENS')","def testTwoWords(self):\n\n\t\t\t\twords = ['business', 'directory']\n\t\t\t\tsynonyms = spinner.Synonym.objects.get_synonyms(words)\n\n\t\t\t\tassert len(synonyms)","def string_permutation(self, a,b):\n for c in a:\n if c not in b:\n return False\n return True","def __eq__(self, other):\n if not isinstance(other, Corpus):\n raise NotImplementedError(\"Only a Corpus can be compared to another Corpus.\")\n\n if len(self) != len(other):\n return False\n\n for i in range(len(self)):\n if self.documents[i] != other.documents[i]:\n return False\n\n return True","def shared_words(text1, text2):\r\n\r\n list1 = tokenize(text1.strip(' '))\r\n list2 = tokenize(text2.strip(' '))\r\n\r\n list3 = set(list1) & set(list2)\r\n list3.remove(' ');\r\n\r\n return list3","def is_isomorphic(self, s1, s2):\n # encode strings\n enc1, enc2 = [], []\n count1, count2 = 0, 0\n dict1, dict2 = dict(), dict()\n for i in range(len(s1)):\n char1, char2 = s1[i], s2[i]\n if char1 in dict1:\n enc1.append(dict1[char1])\n else:\n count1 += 1\n dict1[char1] = count1\n enc1.append(dict1[char1])\n if char2 in dict2:\n enc2.append(dict2[char2])\n else:\n count2 += 1\n dict2[char2] = count2\n enc2.append(dict2[char2])\n return enc1 == enc2 # compare encodings","def isduplicate(self, a, b):\n db = bibtexparser.loads(a+'\\n'+b)\n e1, e2 = db.entries\n refs = Biblio(similarity=self.similarity)\n return refs.eq(e1, e2)","def question1b(s,t):\n\n # check if they are no empty strings\n if t and s:\n\n # count char frequency for t\n frequency_t = Counter()\n for char in t:\n frequency_t[char] += 1\n\n # get number of substrings in s with length same as t\n length_t = len(t)\n n_substrings_s = len(s) - length_t + 1\n\n # loop through substrings in s\n for i in range(n_substrings_s):\n # define substring\n substring_s = s[i:length_t+i]\n # count char frequency for s substring\n frequency_subs = Counter()\n for char in substring_s:\n frequency_subs[char]+=1\n # compare frequency. \n # break any time the frequency of a char does not match\n found = True\n for char, count in frequency_t.items():\n if frequency_subs[char] != count:\n found = False\n break\n # return True if all true\n if found:\n return True\n\n return False","def meets(self, s2):\n return set(self.keys()).intersection(list(s2.keys())) != set()","def test_equals_sign(self):\n inv_search = \"author:beacom year:2000\"\n spi_search = \"find a beacom and date = 2000\"\n self._compare_searches(inv_search, spi_search)","def compare_texts(text1, text2):\n return compare_vectors(vectorize_text(text1), vectorize_text(text2))","def compare_token(got, expected):\n if len(got) != len(expected):\n return False\n for i in range(len(got)):\n if not compare_character(got[i], expected[i]):\n return False\n # just to be extra sure, also compare the hashes (yes, we're cheating\n # here to make it easier to guess the last character)\n got_enc = (''.join(got)).encode('utf-8')\n expected_enc = (''.join(expected)).encode('utf-8')\n return hashlib.sha1(got_enc).digest() == hashlib.sha1(expected_enc).digest()","def assert_strings_equal(a, b):\n assert len(a) == len(b)\n for x, y in zip(a, b):\n assert x == y","def similar_string_fast(first_string, second_string):\n partial_score = fuzz.ratio(first_string, second_string)\n token_score = fuzz.token_set_ratio(first_string, second_string)\n\n if max(partial_score, token_score) >= SCORE_THRESHOLD_FAST:\n return True\n\n return False","def checkPermutation(string1, string2):\n string1_content = {}\n # Hash the first string\n for i in string1:\n if string1_content.get(i) is None:\n string1_content[i] = 1\n else:\n string1_content[i] += 1\n\n # For each character in the section string, search for it\n for i in string2:\n if string1_content.get(i) is None:\n return False\n string1_content[i] -= 1\n\n # Make sure every character in the first string had a matching character in the second string\n for key, value in string1_content.items():\n if value != 0:\n return False\n return True","def sentences(a, b):\n\n # uses tokenize to separate input by sentences and puts into a list\n seta = sent_tokenize(a)\n setb = sent_tokenize(b)\n identical = set()\n\n # iteration same as before\n for i in range(len(seta)):\n if seta[i] in setb:\n identical.add(seta[i])\n\n return identical","def __eq__(self, *args):\n return _libsbml.string___eq__(self, *args)","def term_similarity(node_a, node_b, embeddings):\n try:\n similarity = embeddings.similarity(node_a.__str__(), node_b.__str__())\n except Exception as e:\n # If term(s) does not occur in embedding similarity is always 0.\n similarity = 0\n logging.info(e)\n return similarity","def is_anagram(string1, string2):\r\n list1 = list(string1)\r\n list2 = list(string2)\r\n list1.sort()\r\n list2.sort()\r\n return list1 == list2","def consistent(self, assignment):\n for node1 in assignment:\n for node2 in assignment:\n\n if node1 != node2:\n #returns False if any assignmed words are the same\n if assignment[node1] == assignment[node2]:\n return False\n\n overlap= self.crossword.overlaps[node1,node2]\n if overlap != None:\n #checks if words assigned to node overlaps are the same letter\n if assignment[node1][overlap[0]] != assignment[node2][overlap[1]]:\n return False\n\n return True","def isIsomorphic(s: str, t: str) -> bool:\n\n def encode(s):\n m = {}\n r = []\n for char in s:\n if char not in m:\n m[char] = len(m) # increasing index\n r.append(m[char])\n return str(r)\n\n return encode(s) == encode(t)","def Stringchecker(s1, s2):\r\n\r\n if len(s1) != len(s2) or len(set(s1)) < len(set(s2)):\r\n return False\r\n d = dict()\r\n for idx,c in enumerate(s1):\r\n if not d.get(c):\r\n d[c] = s2[idx]\r\n elif d[c] != s2[idx]:\r\n return False\r\n return True","def eq_elements(a, b):\r\n if ((isinstance(a, int) == True) or (isinstance(a, str) == True)):\r\n return a == b\r\n if ((isinstance(a[0], int) == True) or (isinstance(a[0], str) == True)):\r\n return (set() == set(a).difference(set(b)))\r\n else: \r\n for i in range(len(a)):\r\n test = False \r\n for j in range(len(b)):\r\n if (eq_elements(a[i],b[j]) == True):\r\n test = True\r\n if (test == False):\r\n return False\r\n else:\r\n return True","def test_identical(self):\n write this test!","def word_order_similarity(self,sentence_1, sentence_2):\n\t words_1 = sentence_1.getList_of_words()\n\t words_2 = sentence_2.getList_of_words()\n\t joint_words = list(set(words_1).union(set(words_2)))\n\t windex = {x[1]: x[0] for x in enumerate(joint_words)}\n\t r1 = self.word_order_vector(words_1, joint_words, windex)\n\t r2 = self.word_order_vector(words_2, joint_words, windex)\n\t return 1.0 - (np.linalg.norm(r1 - r2) / np.linalg.norm(r1 + r2))","def test_cases_same_prefix_return_both(self):\n self.create_testdata()\n res = self.filter([u\"moz\"])\n\n self.assertEqual(\n Set([x.name for x in res.all()]),\n Set([\"CV 3\", \"CV 4\"]),\n )","def similarity(text1, text2):\n\n clean1 = clean(text1)\n clean2 = clean(text2)\n count_meas = src.utils.nlp.prompt_similarity(clean1, clean2, vectorizer=CountVectorizer)\n tfidt_meas = src.utils.nlp.prompt_similarity(clean1, clean2, vectorizer=TfidfVectorizer)\n similarity_dict = {'count': count_meas, 'tfidf': tfidt_meas}\n return similarity_dict","def jaccard_similarity(text1, text2):\r\n\r\n set1 = set(text1.split());\r\n set2 = set(text2.split());\r\n\r\n num = set.intersection(set1, set2);\r\n denom = set.union(set1, set2);\r\n\r\n return len(num)/len(denom);","def similarity(self, wSet1, wSet2, idf): \n if len(wSet1) == 0 or len(wSet2) == 0:\n return 0.0\n else:\n defaultIDF = idf['unknownToken']\n intersection = wSet1.intersection(wSet2)\n# intersection = self.synonymIntersection(wSet1, wSet2, idf)\n if len(intersection) == 0:\n return 0\n sum1 = 0\n sum2 = 0\n intersectionSum = 0\n for word in wSet1:\n sum1 += (idf.get(word, defaultIDF))**2\n for word in wSet2:\n sum2 += (idf.get(word, defaultIDF))**2\n for word in intersection:\n intersectionSum += (idf.get(word, defaultIDF))**2\n \n if sum1 == 0 or sum2 == 0:\n return 0.0\n else:\n return intersectionSum/(math.sqrt(sum1) * math.sqrt(sum2))","def jaccard_similarity(string1, string2):\n\n a = set(string1.split())\n b = set(string2.split())\n\n similarity = float(\n len(a.intersection(b)) * 1.0\n / len(a.union(b)))\n\n return similarity","def equal_vowel_and_consonant(words):\n # print(words)\n vowel_consonant_equal = []\n for word in words:\n vowel_counts, consonant_counts = 0, 0\n for char in word:\n if char in 'aeiou':\n vowel_counts += 1\n elif char in 'bcdfghjklmnpqrstvwxyz':\n consonant_counts += 1\n\n if vowel_counts == consonant_counts:\n vowel_consonant_equal.append(word)\n return vowel_consonant_equal","def _compare_unordered(self, other):\n self_token_set = set(self.tokens)\n other_token_set = set(other.tokens)\n\n if len(self_token_set.intersection(other_token_set)) == 0:\n return MatchResult(\"NO\", 0.0)\n\n if self.address_type != other.address_type:\n return MatchResult(\"NO\", 0.0)\n\n if len(self_token_set) != len(other_token_set):\n return MatchResult(\"NO\", 0.0)\n\n self_tokens = self_token_set - other_token_set\n other_tokens = other_token_set - self_token_set\n\n if len(self_tokens) != len(other_tokens):\n return MatchResult(\"NO\", 0.0)\n\n if len(self_tokens) == 0 and len(other_tokens) == 0:\n if self.has_number and self.address_number == other.address_number:\n return MatchResult(\"A2\", 1.0)\n else:\n return MatchResult(\"A4\", 1.0)\n\n result, self_unmatched, other_unmatched, _ = self._match_short_names(self_tokens, other_tokens)\n\n if not result:\n return MatchResult(\"NO\", 0.0)\n\n result, other_unmatched, self_unmatched, _ = self._match_short_names(other_unmatched, self_unmatched)\n\n if not result:\n return MatchResult(\"NO\", 0.0)\n\n if len(self_unmatched) != 0 or len(other_unmatched) != 0:\n return MatchResult(\"NO\", 0.0)\n else:\n if self.has_number and self.address_number == other.address_number:\n return MatchResult(\"A2\", 1.0)\n else:\n return MatchResult(\"A4\", 1.0)","def check_anagram(self, str1, str2):\n str1 = StripText.strip(self, str1).lower()\n str1 = [i for i in str1]\n str2 = StripText.strip(self, str2).lower()\n str2 = [i for i in str2]\n chars_holder = Stack()\n index = 0\n for i in str1:\n if chars_holder.is_empty():\n chars_holder.push(i)\n for j in str2:\n stored_char = chars_holder.peek()\n if j == stored_char:\n chars_holder.pop()\n break\n if chars_holder.is_empty():\n return True\n else:\n return False","def _is_duplicate(a: str, b: str) -> bool:\n la = len(a)\n lb = len(b)\n diff = abs(la - lb)\n if diff > 50:\n return False\n denom = min(la, lb) + diff / 2\n ratio = levenshtein(a.casefold(), b.casefold()) / denom\n return ratio < 0.1","def check_equivalent(self, a, b):\n assert set(a) == set(b)\n for key in a:\n assert self.is_equal(a[key], b[key])","def sentences(a, b):\n sentences_of_a = sent_tokenize(a)\n sentences_of_b = sent_tokenize(b)\n\n equal_sentences = set()\n\n # Compare sentences\n for sentence_of_a in sentences_of_a:\n if sentence_of_a in sentences_of_b:\n equal_sentences.add(sentence_of_a)\n\n # TODO\n return equal_sentences","def __flt_eq_trs(self, other):\n if self.tears is None:\n return True\n\n return self.tears == other.tears","def removeSameTerms(lines):\r\n flag_main = 0\r\n line_depth = find_depth(lines)\r\n\r\n i = 0\r\n while i < len(lines):\r\n subst_dict = {}\r\n j = i + 1\r\n while j < len(lines):\r\n if set(lines[i][1:3]) == set(lines[j][1:3]): # same function detected\r\n flag_main = 1\r\n if 'y' in lines[j][0]: # taking care of the special case\r\n subst_dict[lines[i][0]] = lines[j][0]\r\n else: # 'y' in lines[i][0] is covered in this case too\r\n subst_dict[lines[j][0]] = lines[i][0]\r\n \r\n # deletion\r\n if line_depth[i] < line_depth[j]:\r\n del lines[j]\r\n else:\r\n del lines[i]\r\n \r\n # substitution\r\n for k in range(len(lines)):\r\n if lines[k][0] in subst_dict.keys():\r\n lines[k][0] = subst_dict[lines[k][0]]\r\n elif lines[k][1] in subst_dict.keys():\r\n lines[k][1] = subst_dict[lines[k][1]]\r\n elif lines[k][2] in subst_dict.keys():\r\n lines[k][2] = subst_dict[lines[k][2]]\r\n \r\n # restart the whole loop after substitution\r\n i = -1\r\n break\r\n j += 1\r\n i += 1\r\n \r\n # reorganise the order\r\n reorgOrder(lines)\r\n # renaming in order\r\n renaming(lines)\r\n \r\n return flag_main","def twoStrings(s1, s2):\n\n set1 = set(s1)\n set2 = set(s2)\n\n for char in set1:\n if char in set2:\n return True\n\n return False","def my_strcomp(str1, str2):\n str2 = ''.join(ch for ch in str2 if ch.isalnum() or ch == \",\")\n str1 = ''.join(ch for ch in str1 if ch.isalnum())\n if len(str2) > len(str1):\n return False\n if str1.upper() == str2.upper():\n return True\n same_chars = 0\n for char1, char2 in zip(str1, str2):\n if char1.upper() == char2.upper():\n same_chars += 1\n # if same_chars == len(str2): return True\n return (same_chars / len(str1)) > 0.7 # If more than 80% of chars are equals, return true"],"string":"[\n \"def distance_unigrams_same(t1, t2):\\n t1_terms = make_terms_from_string(t1)\\n t2_terms = make_terms_from_string(t2)\\n terms1 = set(t1_terms)\\n terms2 = set(t2_terms)\\n shared_terms = terms1.intersection(terms2)\\n #print(shared_terms)\\n all_terms = terms1.union(terms2)\\n #print(all_terms)\\n dist = 1.0 - (len(shared_terms) / float(len(all_terms)))\\n return dist\",\n \"def arrayStringsAreEqual1(self, word1: List[str], word2: List[str]) -> bool:\\n word1str = ''.join(word1)\\n word2str = ''.join(word2)\\n return word1str == word2str\",\n \"def compare_words(self, word1, word2):\\n return Counter(word1) == Counter(word2)\",\n \"def distance_bigrams_same(t1, t2):\\n t1_terms = make_terms_from_string(t1)\\n t2_terms = make_terms_from_string(t2)\\n terms1 = set(ngrams(t1_terms, 2)) # was using nltk.bigrams\\n terms2 = set(ngrams(t2_terms, 2))\\n shared_terms = terms1.intersection(terms2)\\n #print(shared_terms)\\n all_terms = terms1.union(terms2)\\n #print(all_terms)\\n dist = 1.0\\n if len(all_terms) > 0:\\n dist = 1.0 - (len(shared_terms) / float(len(all_terms)))\\n return dist\",\n \"def _strings_are_equal(self, value1, value2):\\n if value1.lower().strip().replace('_', ' ') == value2.lower().strip().replace('_', ' '):\\n return 1\\n return 0\",\n \"def __eq__(self,other):\\n if type(other)==type(\\\"\\\"):\\n return self.word == other\\n return self.word == other.word\",\n \"def test_dtm_equal(self):\\n new_dtm = self.dtm1.copy()\\n nose.assert_true(self.dtm1 == new_dtm, 'DTMs are not equal')\",\n \"def test_term_list_removes_duplicates():\\n term = SplineTerm(0)\\n term_list = term + term\\n\\n assert isinstance(term_list, TermList)\\n assert len(term_list) == 1\",\n \"def assertSpacelessEqual(self, first, second):\\n self.assertEqual(set(first.split()), set(second.split()))\",\n \"def arrayStringsAreEqual2(self, word1: List[str], word2: List[str]) -> bool:\\n \\n # i for list idx, j for str idx\\n i1 = 0\\n j1 = 0\\n i2 = 0\\n j2 = 0\\n \\n while i1 < len(word1) and i2 < len(word2):\\n if word1[i1][j1] != word2[i2][j2]:\\n return False\\n \\n # update word1 indexes\\n if j1 < len(word1[i1])-1:\\n j1 += 1\\n else:\\n i1 += 1\\n j1 = 0\\n \\n # update word2 indexes\\n if j2 < len(word2[i2])-1:\\n j2 += 1\\n else:\\n i2 += 1\\n j2 = 0\\n \\n if i1 == len(word1) and i2 == len(word2):\\n return True\\n \\n return False\",\n \"def test_strings_are_equal(self):\\n string1 = 'this is the first string'\\n string2 = 'this is the first string' # ==, !is\\n string3 = 'this is the second string'\\n self.assertEqual(True, comparator.strings_are_equal(string1, string2))\\n self.assertEqual(False, comparator.strings_are_equal(string1, string3))\",\n \"def permutations_equal(str_a, str_b):\\n if not isinstance(str_a, str) or not isinstance(str_b, str):\\n raise AttributeError(\\\"inputs must be valid str\\\")\\n if len(str_a) != len(str_b):\\n return False\\n\\n return Counter(str_a) == Counter(str_b)\",\n \"def check_permutation_of(string1,string2):\\n if len(string1) != len(string2): #O(1)\\n return False\\n return collections.Counter(string1) == collections.Counter(string2) #O(n+n) to make the dictionaries\\n #O(n+n) to compare equality?\\n #so O(4n) == O(n).\",\n \"def similarL1(a, b):\\n if len(b) > 0:\\n for x in b:\\n if x == a:\\n return True\\n return False\",\n \"def testSynonymDuplicate(self):\\n\\t\\t\\t\\tone = spinner.Word.objects.get_single('mac', True)\\n\\t\\t\\t\\ttwo = spinner.Word.objects.get_single('macintosh', True)\\n\\t\\n\\t\\t\\t\\tsyn = spinner.Synonym.objects.get_single(one, two, True)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tsyn2 = spinner.Synonym.objects.get_single(two, one, True)\\n\\n\\t\\t\\t\\tassert syn == syn2\\n\\n\\t\\t\\t\\tsyn.delete()\\n\\t\\t\\t\\tone.delete()\\n\\t\\t\\t\\ttwo.delete()\",\n \"def test_dtm_not_equal(self):\\n new_dtm = self.dtm1.copy()\\n new_dtm.final_states.add('q2')\\n nose.assert_true(self.dtm1 != new_dtm, 'DTMs are equal')\",\n \"def all_equals(solution1, solution2, tol=0.001):\\n tokens1 = solution1.split()\\n tokens2 = solution2.split()\\n\\n for token1, token2 in zip(tokens1, tokens2):\\n if not equals(token1, token2, tol=tol):\\n print(token1, token2)\\n return False\\n\\n return True\",\n \"def similarL1a(a, b):\\n for x in b:\\n if x.lower() in a.lower():\\n return True\\n return False\",\n \"def similar_strings(s1, s2):\\n w1 = set(re.split(r'\\\\W+', s1))\\n w2 = set(re.split(r'\\\\W+', s2))\\n threshold = len(w1) // 2 + 1\\n return len(w1 & w2) >= threshold\",\n \"def _values_is_equal(self, a, b):\\n if a is None or b is None:\\n return False\\n\\n a = a.split()\\n b = b.split()\\n\\n if len(a) != len(b):\\n return False\\n\\n return len([i for i, j in zip(a, b) if i == j]) == len(a)\",\n \"def wordSimilarityRatio(sent_1,sent_2):\",\n \"def test__same_text_correlation(self):\\n \\n _log.info('-'*80)\\n \\n # arrange \\n text1 = \\\"love is rain as long story short\\\"\\n text2 = text1\\n\\n dump_file = getInputFile(\\\"swiki_knowledge_output.xml\\\")\\n parsed_file = getOutputFile(\\\"swiki_knowledge_output.parsed.xml\\\")\\n #wdb_file = getOutputFile(\\\"swiki_knowledge_output.wdb\\\")\\n\\n articles = ['Rain', 'Love', 'Tree'] \\n \\n # act\\n wn.make_dump(dump_file, articles, compress=False)\\n wn.parse_dump(dump_file, parsed_file)\\n db_wrapper = wn.build_database_wrapper(parsed_file, StopWordsStemmer([]))\\n \\n #self.addCleanup(os.remove, self.tmp_dump_file)\\n \\n comparer = SemanticComparer(db_wrapper)\\n correlation = comparer.compare(text1, text2)\\n _log.info(test_utils.get_texts_correlation_message(text1, text2, correlation))\\n self.assertAlmostEqual(correlation, 1.0, msg=\\\"for same text correlation should be 1\\\")\",\n \"def __eq__(self, other):\\n for (ngram, value) in self.items():\\n if ngram not in other or other[ngram] != value:\\n return False\\n for (ngram, value) in other.items():\\n if ngram not in self or self[ngram] != value:\\n return False\\n return True\",\n \"def compare(self,l):\\r\\n\\t\\t\\r\\n\\t\\t# assume equality\\r\\n\\t\\tq = True\\r\\n\\t\\t\\r\\n\\t\\t# test term by term\\r\\n\\t\\tfor i,j in zip(self,l):\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t# break at first mismatch\\r\\n\\t\\t\\tif not i.compare(j):\\r\\n\\t\\t\\t\\tq = False\\r\\n\\t\\t\\t\\tbreak\\r\\n\\t\\t\\t\\t\\r\\n\\t\\t# make sure lengths are also equal\\r\\n\\t\\tif len(self) != len(l):\\r\\n\\t\\t\\tq = False\\r\\n\\t\\t\\t\\t\\r\\n\\t\\treturn q\",\n \"def testRandomWord(self):\\n word1 = self.searcher.randomWord()\\n word2 = self.searcher.randomWord()\\n self.assertTrue(len(word1) > 1, 'Word length too short')\\n self.assertTrue(len(word2) > 1, 'Word length too short')\\n self.assertNotEqual(word1, word2, 'Found the same word')\",\n \"def test_similarity(self):\\n self.assertTrue(np.allclose(self.vectors.similarity('dog.n.01', 'dog.n.01'), 1))\\n self.assertTrue(np.allclose(self.vectors.similarity('dog.n.01', 'mammal.n.01'), 0.180901358))\",\n \"def testEquality(self):\\n pass\",\n \"def same_frequency(num1, num2):\\n str1 = str(num1)\\n str2 = str(num2)\\n\\n digits1 = set(str1)\\n digits2 = set(str2)\\n if digits1 == digits2:\\n for digit in digits1:\\n if str1.count(digit) != str2.count(digit):\\n return False\\n return True\\n else:\\n return False\",\n \"def verify_anagrams(first_word, second_word):\\n first = prep_dict(first_word)\\n second = prep_dict(second_word)\\n #print first, second\\n for k,v in first.iteritems():\\n try:\\n if second[k] == v:\\n pass\\n else:\\n return False\\n except:\\n return False\\n return True\",\n \"def string_similarity(a, b):\\n return SequenceMatcher(a=a, b=b).ratio()\",\n \"def match(self, words):\\n return words == self.words(len(words))\",\n \"def test_combine_multiple(self):\\n inv_search = 'author:\\\"gattringer, c*\\\" keyword:chiral keyword:symmetry -title:chiral'\\n spi_search = \\\"find a c gattringer and k chiral symmetry and not title chiral\\\"\\n self._compare_searches(inv_search, spi_search)\",\n \"def verify_anagrams(first_word, second_word):\\n first_word = sorted(first_word.lower().replace(' ', '')) # list of lower letter in word without\\n second_word = sorted(second_word.lower().replace(' ', '')) # whitespaces, sorted ascending\\n\\n if len(first_word) != len(second_word):\\n return False\\n else:\\n if first_word != second_word:\\n return False\\n else:\\n return True\",\n \"def string_similarity(item_1, item_2):\\n return SequenceMatcher(None, item_1.lower(), item_2.lower()).ratio()\",\n \"def _alternative(words):\\n wordlist = list(words)\\n counter = []\\n for word in wordlist:\\n used = set()\\n counter.append(__geterate_tree(word, wordlist, used, 1))\\n return max(counter) == len(wordlist)\",\n \"def text_compare(t1, t2):\\n if not t1 and not t2:\\n return True\\n if t1 == '*' or t2 == '*':\\n return True\\n return (t1 or '').strip() == (t2 or '').strip()\",\n \"def __eq__(self, other):\\n return (\\n isinstance(other, self.__class__)\\n and len(self) == len(other)\\n and all(term in self for term in other)\\n )\",\n \"def checkPermutation(s, t):\\n\\n # Count each unique letter in both strings and compare the two dicts.\\n s_count = {}\\n t_count = {}\\n for character in s:\\n s_count[character] = s_count.get(character, 0) + 1\\n\\n for character in t:\\n t_count[character] = t_count.get(character, 0) + 1\\n\\n return s_count == t_count\\n\\n # Time Complexity: O(n)\\n # Space Complexity: O(n)\",\n \"def similarity(self, e1, e2):\\n\\t\\tpass\",\n \"def are_similar(left, right):\\n left = left.lower()\\n right = right.lower()\\n if left == right:\\n return True\\n if left and left in right:\\n return True\\n if right and right in left:\\n return True\\n return False\",\n \"def test_consistent_ids(self) -> None:\\n bnode = BNode()\\n g0_ts: _TripleSet = {\\n (bnode, FOAF.name, Literal(\\\"Golan Trevize\\\")),\\n (bnode, RDF.type, FOAF.Person),\\n }\\n bnode = BNode()\\n g1_ts: _TripleSet = {\\n (bnode, FOAF.name, Literal(\\\"Janov Pelorat\\\")),\\n (bnode, RDF.type, FOAF.Person),\\n }\\n\\n g0 = Graph()\\n g0 += g0_ts\\n cg0 = to_canonical_graph(g0)\\n cg0_ts = GraphHelper.triple_set(cg0)\\n\\n g1 = Graph()\\n g1 += g1_ts\\n cg1 = to_canonical_graph(g1)\\n cg1_ts = GraphHelper.triple_set(cg1)\\n\\n assert cg0_ts.issubset(\\n cg1_ts\\n ), \\\"canonical triple set cg0_ts should be a subset of canonical triple set cg1_ts\\\"\",\n \"def check_equal_sequence(sup_token_list, entity_token_list):\\n import operator as op\\n for i in range(0, len(entity_token_list)):\\n if op.eq(sup_token_list[i].lower(), entity_token_list[i].lower()):\\n continue\\n else:\\n return False\\n return True\",\n \"def compare_vectors(word_vector1, word_vector2):\\n all_words = list(set(word_vector1).union(set(word_vector2)))\\n frequency_dict1 = word_frequencies(word_vector1)\\n frequency_dict2 = word_frequencies(word_vector2)\\n\\n frequency_vector1 = [frequency_dict1.get(word, 0) for word in all_words]\\n frequency_vector2 = [frequency_dict2.get(word, 0) for word in all_words]\\n\\n return similarity(frequency_vector1, frequency_vector2)\",\n \"def values_eq(self, a, b):\\r\\n return a == b\",\n \"def test_distribution_with_many_clauses(self):\\n spi_search = \\\"find a mele and brooks and holtkamp and o'connell\\\"\\n inv_search = \\\"author:mele author:brooks author:holtkamp author:o'connell\\\"\\n self._compare_searches(inv_search, spi_search)\",\n \"def strings_equal(s1, s2):\\n s1 = unicodedata.normalize('NFKC', s1)\\n s2 = unicodedata.normalize('NFKC', s2)\\n return compare_digest(s1, s2)\",\n \"def check_strings(aword, anotherword):\\n if aword == anotherword:\\n return True\\n else:\\n return False\",\n \"def check_anagram_with_dict(self, str1, str2):\\n str1 = str1.lower()\\n str2 = str2.lower()\\n str1 = StripText.strip(self, str1)\\n str2 = StripText.strip(self, str2)\\n str1_count = {}\\n str2_count = {}\\n for each in str1:\\n try:\\n if str1_count[each]:\\n str1_count[each] += 1\\n except:\\n str1_count[each] = 1\\n for each in str2:\\n try:\\n if str2_count[each]:\\n str2_count[each] += 1\\n except:\\n str2_count[each] = 1\\n for each in str1_count:\\n if str1_count[each] == str2_count[each]:\\n pass\\n else:\\n return False\\n return True\",\n \"def isIsomorphic(self, s: str, t: str) -> bool:\\n if len(s) != len(t):\\n return False\\n alphabet = {}\\n used = {}\\n for i in range(len(s)):\\n char = alphabet.get(s[i])\\n if char and char != t[i]:\\n return False\\n if not char and t[i] in used:\\n return False\\n alphabet[s[i]] = t[i]\\n used[t[i]] = True\\n return True\",\n \"def similar(text, database):\\n # TODO\\n pass\",\n \"def isEqual(string1, string2):\\n return (True)\",\n \"def exactMatch(self, mention):\\n w1 = self.allWords()\\n w2 = mention.allWords()\\n if len(w1) == len(w2) and w1 == w2:\\n return True\\n else:\\n return False\",\n \"def test_words_closer_than(self):\\n self.assertEqual(self.vectors.words_closer_than('dog.n.01', 'dog.n.01'), [])\\n expected = set(['canine.n.02', 'hunting_dog.n.01'])\\n self.assertEqual(set(self.vectors.words_closer_than('dog.n.01', 'carnivore.n.01')), expected)\",\n \"def test_first_equal(self):\\n self.assertEqual(heaviest_word(\\\"man i need a taxi up to ubud\\\"), \\\"taxi\\\")\",\n \"def _does_words_matches(original_word: str, encoded_word: str) -> bool:\\n return(\\n len(original_word) == len(encoded_word) and\\n original_word[0] == encoded_word[0] and\\n original_word[-1] == encoded_word[-1] and\\n sorted(original_word[1:-1]) == sorted(encoded_word[1:-1])\\n )\",\n \"def test_equals(self):\\n self.assertEqual(cmp(u\\\"a\\\", u\\\"a\\\"), 0)\\n self.assertEqual(cmp(1, 1), 0)\\n self.assertEqual(cmp([1], [1]), 0)\",\n \"def is_same_song(a, b):\\n\\n for k in 'album', 'title', 'artists':\\n if a[k] != b[k]:\\n return False\\n\\n return True\",\n \"def _equals(a: Union[str, Iterable[str]], b: Union[str, Iterable[str]]) -> bool:\\n if isinstance(a, str) and isinstance(b, str):\\n return a.replace(' ', '') == b.replace(' ', '')\\n elif isinstance(a, Iterable) and isinstance(b, Iterable):\\n return all(_equals(a_, b_) for a_, b_ in zip(a, b))\\n else:\\n raise TypeError(f'arguments must be both strings or both lists, not {type(a)}, {type(b)}')\",\n \"def test_keys_eq(self):\\n self.assertListEqual(self.result, self.expected)\",\n \"def __eq__(self, other):\\n if isinstance(other, Token):\\n return self.text == other.text\\n else:\\n return self.text == other\",\n \"def total_char_similarity(a,b):\\n\\ta_words, b_words = map(norm.set_clean_tokens, [a,b])\\n\\n\\ttotal_score = 0\\n\\tfor ai in a_words:\\n\\t\\tfor bi in b_words:\\n\\t\\t\\ttotal_score += similar(ai, bi)\\n\\treturn total_score\",\n \"def test_string_similarity_constraint():\\n f = SimilarityConstraint(func=LevenshteinDistance(), pred=GreaterThan(0.5))\\n assert f('BROOKLYN', 'BROKLYN')\\n assert not f('BROOKLYN', 'QUEENS')\",\n \"def testTwoWords(self):\\n\\n\\t\\t\\t\\twords = ['business', 'directory']\\n\\t\\t\\t\\tsynonyms = spinner.Synonym.objects.get_synonyms(words)\\n\\n\\t\\t\\t\\tassert len(synonyms)\",\n \"def string_permutation(self, a,b):\\n for c in a:\\n if c not in b:\\n return False\\n return True\",\n \"def __eq__(self, other):\\n if not isinstance(other, Corpus):\\n raise NotImplementedError(\\\"Only a Corpus can be compared to another Corpus.\\\")\\n\\n if len(self) != len(other):\\n return False\\n\\n for i in range(len(self)):\\n if self.documents[i] != other.documents[i]:\\n return False\\n\\n return True\",\n \"def shared_words(text1, text2):\\r\\n\\r\\n list1 = tokenize(text1.strip(' '))\\r\\n list2 = tokenize(text2.strip(' '))\\r\\n\\r\\n list3 = set(list1) & set(list2)\\r\\n list3.remove(' ');\\r\\n\\r\\n return list3\",\n \"def is_isomorphic(self, s1, s2):\\n # encode strings\\n enc1, enc2 = [], []\\n count1, count2 = 0, 0\\n dict1, dict2 = dict(), dict()\\n for i in range(len(s1)):\\n char1, char2 = s1[i], s2[i]\\n if char1 in dict1:\\n enc1.append(dict1[char1])\\n else:\\n count1 += 1\\n dict1[char1] = count1\\n enc1.append(dict1[char1])\\n if char2 in dict2:\\n enc2.append(dict2[char2])\\n else:\\n count2 += 1\\n dict2[char2] = count2\\n enc2.append(dict2[char2])\\n return enc1 == enc2 # compare encodings\",\n \"def isduplicate(self, a, b):\\n db = bibtexparser.loads(a+'\\\\n'+b)\\n e1, e2 = db.entries\\n refs = Biblio(similarity=self.similarity)\\n return refs.eq(e1, e2)\",\n \"def question1b(s,t):\\n\\n # check if they are no empty strings\\n if t and s:\\n\\n # count char frequency for t\\n frequency_t = Counter()\\n for char in t:\\n frequency_t[char] += 1\\n\\n # get number of substrings in s with length same as t\\n length_t = len(t)\\n n_substrings_s = len(s) - length_t + 1\\n\\n # loop through substrings in s\\n for i in range(n_substrings_s):\\n # define substring\\n substring_s = s[i:length_t+i]\\n # count char frequency for s substring\\n frequency_subs = Counter()\\n for char in substring_s:\\n frequency_subs[char]+=1\\n # compare frequency. \\n # break any time the frequency of a char does not match\\n found = True\\n for char, count in frequency_t.items():\\n if frequency_subs[char] != count:\\n found = False\\n break\\n # return True if all true\\n if found:\\n return True\\n\\n return False\",\n \"def meets(self, s2):\\n return set(self.keys()).intersection(list(s2.keys())) != set()\",\n \"def test_equals_sign(self):\\n inv_search = \\\"author:beacom year:2000\\\"\\n spi_search = \\\"find a beacom and date = 2000\\\"\\n self._compare_searches(inv_search, spi_search)\",\n \"def compare_texts(text1, text2):\\n return compare_vectors(vectorize_text(text1), vectorize_text(text2))\",\n \"def compare_token(got, expected):\\n if len(got) != len(expected):\\n return False\\n for i in range(len(got)):\\n if not compare_character(got[i], expected[i]):\\n return False\\n # just to be extra sure, also compare the hashes (yes, we're cheating\\n # here to make it easier to guess the last character)\\n got_enc = (''.join(got)).encode('utf-8')\\n expected_enc = (''.join(expected)).encode('utf-8')\\n return hashlib.sha1(got_enc).digest() == hashlib.sha1(expected_enc).digest()\",\n \"def assert_strings_equal(a, b):\\n assert len(a) == len(b)\\n for x, y in zip(a, b):\\n assert x == y\",\n \"def similar_string_fast(first_string, second_string):\\n partial_score = fuzz.ratio(first_string, second_string)\\n token_score = fuzz.token_set_ratio(first_string, second_string)\\n\\n if max(partial_score, token_score) >= SCORE_THRESHOLD_FAST:\\n return True\\n\\n return False\",\n \"def checkPermutation(string1, string2):\\n string1_content = {}\\n # Hash the first string\\n for i in string1:\\n if string1_content.get(i) is None:\\n string1_content[i] = 1\\n else:\\n string1_content[i] += 1\\n\\n # For each character in the section string, search for it\\n for i in string2:\\n if string1_content.get(i) is None:\\n return False\\n string1_content[i] -= 1\\n\\n # Make sure every character in the first string had a matching character in the second string\\n for key, value in string1_content.items():\\n if value != 0:\\n return False\\n return True\",\n \"def sentences(a, b):\\n\\n # uses tokenize to separate input by sentences and puts into a list\\n seta = sent_tokenize(a)\\n setb = sent_tokenize(b)\\n identical = set()\\n\\n # iteration same as before\\n for i in range(len(seta)):\\n if seta[i] in setb:\\n identical.add(seta[i])\\n\\n return identical\",\n \"def __eq__(self, *args):\\n return _libsbml.string___eq__(self, *args)\",\n \"def term_similarity(node_a, node_b, embeddings):\\n try:\\n similarity = embeddings.similarity(node_a.__str__(), node_b.__str__())\\n except Exception as e:\\n # If term(s) does not occur in embedding similarity is always 0.\\n similarity = 0\\n logging.info(e)\\n return similarity\",\n \"def is_anagram(string1, string2):\\r\\n list1 = list(string1)\\r\\n list2 = list(string2)\\r\\n list1.sort()\\r\\n list2.sort()\\r\\n return list1 == list2\",\n \"def consistent(self, assignment):\\n for node1 in assignment:\\n for node2 in assignment:\\n\\n if node1 != node2:\\n #returns False if any assignmed words are the same\\n if assignment[node1] == assignment[node2]:\\n return False\\n\\n overlap= self.crossword.overlaps[node1,node2]\\n if overlap != None:\\n #checks if words assigned to node overlaps are the same letter\\n if assignment[node1][overlap[0]] != assignment[node2][overlap[1]]:\\n return False\\n\\n return True\",\n \"def isIsomorphic(s: str, t: str) -> bool:\\n\\n def encode(s):\\n m = {}\\n r = []\\n for char in s:\\n if char not in m:\\n m[char] = len(m) # increasing index\\n r.append(m[char])\\n return str(r)\\n\\n return encode(s) == encode(t)\",\n \"def Stringchecker(s1, s2):\\r\\n\\r\\n if len(s1) != len(s2) or len(set(s1)) < len(set(s2)):\\r\\n return False\\r\\n d = dict()\\r\\n for idx,c in enumerate(s1):\\r\\n if not d.get(c):\\r\\n d[c] = s2[idx]\\r\\n elif d[c] != s2[idx]:\\r\\n return False\\r\\n return True\",\n \"def eq_elements(a, b):\\r\\n if ((isinstance(a, int) == True) or (isinstance(a, str) == True)):\\r\\n return a == b\\r\\n if ((isinstance(a[0], int) == True) or (isinstance(a[0], str) == True)):\\r\\n return (set() == set(a).difference(set(b)))\\r\\n else: \\r\\n for i in range(len(a)):\\r\\n test = False \\r\\n for j in range(len(b)):\\r\\n if (eq_elements(a[i],b[j]) == True):\\r\\n test = True\\r\\n if (test == False):\\r\\n return False\\r\\n else:\\r\\n return True\",\n \"def test_identical(self):\\n write this test!\",\n \"def word_order_similarity(self,sentence_1, sentence_2):\\n\\t words_1 = sentence_1.getList_of_words()\\n\\t words_2 = sentence_2.getList_of_words()\\n\\t joint_words = list(set(words_1).union(set(words_2)))\\n\\t windex = {x[1]: x[0] for x in enumerate(joint_words)}\\n\\t r1 = self.word_order_vector(words_1, joint_words, windex)\\n\\t r2 = self.word_order_vector(words_2, joint_words, windex)\\n\\t return 1.0 - (np.linalg.norm(r1 - r2) / np.linalg.norm(r1 + r2))\",\n \"def test_cases_same_prefix_return_both(self):\\n self.create_testdata()\\n res = self.filter([u\\\"moz\\\"])\\n\\n self.assertEqual(\\n Set([x.name for x in res.all()]),\\n Set([\\\"CV 3\\\", \\\"CV 4\\\"]),\\n )\",\n \"def similarity(text1, text2):\\n\\n clean1 = clean(text1)\\n clean2 = clean(text2)\\n count_meas = src.utils.nlp.prompt_similarity(clean1, clean2, vectorizer=CountVectorizer)\\n tfidt_meas = src.utils.nlp.prompt_similarity(clean1, clean2, vectorizer=TfidfVectorizer)\\n similarity_dict = {'count': count_meas, 'tfidf': tfidt_meas}\\n return similarity_dict\",\n \"def jaccard_similarity(text1, text2):\\r\\n\\r\\n set1 = set(text1.split());\\r\\n set2 = set(text2.split());\\r\\n\\r\\n num = set.intersection(set1, set2);\\r\\n denom = set.union(set1, set2);\\r\\n\\r\\n return len(num)/len(denom);\",\n \"def similarity(self, wSet1, wSet2, idf): \\n if len(wSet1) == 0 or len(wSet2) == 0:\\n return 0.0\\n else:\\n defaultIDF = idf['unknownToken']\\n intersection = wSet1.intersection(wSet2)\\n# intersection = self.synonymIntersection(wSet1, wSet2, idf)\\n if len(intersection) == 0:\\n return 0\\n sum1 = 0\\n sum2 = 0\\n intersectionSum = 0\\n for word in wSet1:\\n sum1 += (idf.get(word, defaultIDF))**2\\n for word in wSet2:\\n sum2 += (idf.get(word, defaultIDF))**2\\n for word in intersection:\\n intersectionSum += (idf.get(word, defaultIDF))**2\\n \\n if sum1 == 0 or sum2 == 0:\\n return 0.0\\n else:\\n return intersectionSum/(math.sqrt(sum1) * math.sqrt(sum2))\",\n \"def jaccard_similarity(string1, string2):\\n\\n a = set(string1.split())\\n b = set(string2.split())\\n\\n similarity = float(\\n len(a.intersection(b)) * 1.0\\n / len(a.union(b)))\\n\\n return similarity\",\n \"def equal_vowel_and_consonant(words):\\n # print(words)\\n vowel_consonant_equal = []\\n for word in words:\\n vowel_counts, consonant_counts = 0, 0\\n for char in word:\\n if char in 'aeiou':\\n vowel_counts += 1\\n elif char in 'bcdfghjklmnpqrstvwxyz':\\n consonant_counts += 1\\n\\n if vowel_counts == consonant_counts:\\n vowel_consonant_equal.append(word)\\n return vowel_consonant_equal\",\n \"def _compare_unordered(self, other):\\n self_token_set = set(self.tokens)\\n other_token_set = set(other.tokens)\\n\\n if len(self_token_set.intersection(other_token_set)) == 0:\\n return MatchResult(\\\"NO\\\", 0.0)\\n\\n if self.address_type != other.address_type:\\n return MatchResult(\\\"NO\\\", 0.0)\\n\\n if len(self_token_set) != len(other_token_set):\\n return MatchResult(\\\"NO\\\", 0.0)\\n\\n self_tokens = self_token_set - other_token_set\\n other_tokens = other_token_set - self_token_set\\n\\n if len(self_tokens) != len(other_tokens):\\n return MatchResult(\\\"NO\\\", 0.0)\\n\\n if len(self_tokens) == 0 and len(other_tokens) == 0:\\n if self.has_number and self.address_number == other.address_number:\\n return MatchResult(\\\"A2\\\", 1.0)\\n else:\\n return MatchResult(\\\"A4\\\", 1.0)\\n\\n result, self_unmatched, other_unmatched, _ = self._match_short_names(self_tokens, other_tokens)\\n\\n if not result:\\n return MatchResult(\\\"NO\\\", 0.0)\\n\\n result, other_unmatched, self_unmatched, _ = self._match_short_names(other_unmatched, self_unmatched)\\n\\n if not result:\\n return MatchResult(\\\"NO\\\", 0.0)\\n\\n if len(self_unmatched) != 0 or len(other_unmatched) != 0:\\n return MatchResult(\\\"NO\\\", 0.0)\\n else:\\n if self.has_number and self.address_number == other.address_number:\\n return MatchResult(\\\"A2\\\", 1.0)\\n else:\\n return MatchResult(\\\"A4\\\", 1.0)\",\n \"def check_anagram(self, str1, str2):\\n str1 = StripText.strip(self, str1).lower()\\n str1 = [i for i in str1]\\n str2 = StripText.strip(self, str2).lower()\\n str2 = [i for i in str2]\\n chars_holder = Stack()\\n index = 0\\n for i in str1:\\n if chars_holder.is_empty():\\n chars_holder.push(i)\\n for j in str2:\\n stored_char = chars_holder.peek()\\n if j == stored_char:\\n chars_holder.pop()\\n break\\n if chars_holder.is_empty():\\n return True\\n else:\\n return False\",\n \"def _is_duplicate(a: str, b: str) -> bool:\\n la = len(a)\\n lb = len(b)\\n diff = abs(la - lb)\\n if diff > 50:\\n return False\\n denom = min(la, lb) + diff / 2\\n ratio = levenshtein(a.casefold(), b.casefold()) / denom\\n return ratio < 0.1\",\n \"def check_equivalent(self, a, b):\\n assert set(a) == set(b)\\n for key in a:\\n assert self.is_equal(a[key], b[key])\",\n \"def sentences(a, b):\\n sentences_of_a = sent_tokenize(a)\\n sentences_of_b = sent_tokenize(b)\\n\\n equal_sentences = set()\\n\\n # Compare sentences\\n for sentence_of_a in sentences_of_a:\\n if sentence_of_a in sentences_of_b:\\n equal_sentences.add(sentence_of_a)\\n\\n # TODO\\n return equal_sentences\",\n \"def __flt_eq_trs(self, other):\\n if self.tears is None:\\n return True\\n\\n return self.tears == other.tears\",\n \"def removeSameTerms(lines):\\r\\n flag_main = 0\\r\\n line_depth = find_depth(lines)\\r\\n\\r\\n i = 0\\r\\n while i < len(lines):\\r\\n subst_dict = {}\\r\\n j = i + 1\\r\\n while j < len(lines):\\r\\n if set(lines[i][1:3]) == set(lines[j][1:3]): # same function detected\\r\\n flag_main = 1\\r\\n if 'y' in lines[j][0]: # taking care of the special case\\r\\n subst_dict[lines[i][0]] = lines[j][0]\\r\\n else: # 'y' in lines[i][0] is covered in this case too\\r\\n subst_dict[lines[j][0]] = lines[i][0]\\r\\n \\r\\n # deletion\\r\\n if line_depth[i] < line_depth[j]:\\r\\n del lines[j]\\r\\n else:\\r\\n del lines[i]\\r\\n \\r\\n # substitution\\r\\n for k in range(len(lines)):\\r\\n if lines[k][0] in subst_dict.keys():\\r\\n lines[k][0] = subst_dict[lines[k][0]]\\r\\n elif lines[k][1] in subst_dict.keys():\\r\\n lines[k][1] = subst_dict[lines[k][1]]\\r\\n elif lines[k][2] in subst_dict.keys():\\r\\n lines[k][2] = subst_dict[lines[k][2]]\\r\\n \\r\\n # restart the whole loop after substitution\\r\\n i = -1\\r\\n break\\r\\n j += 1\\r\\n i += 1\\r\\n \\r\\n # reorganise the order\\r\\n reorgOrder(lines)\\r\\n # renaming in order\\r\\n renaming(lines)\\r\\n \\r\\n return flag_main\",\n \"def twoStrings(s1, s2):\\n\\n set1 = set(s1)\\n set2 = set(s2)\\n\\n for char in set1:\\n if char in set2:\\n return True\\n\\n return False\",\n \"def my_strcomp(str1, str2):\\n str2 = ''.join(ch for ch in str2 if ch.isalnum() or ch == \\\",\\\")\\n str1 = ''.join(ch for ch in str1 if ch.isalnum())\\n if len(str2) > len(str1):\\n return False\\n if str1.upper() == str2.upper():\\n return True\\n same_chars = 0\\n for char1, char2 in zip(str1, str2):\\n if char1.upper() == char2.upper():\\n same_chars += 1\\n # if same_chars == len(str2): return True\\n return (same_chars / len(str1)) > 0.7 # If more than 80% of chars are equals, return true\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6751587","0.6636538","0.6448691","0.6327863","0.62453604","0.6222981","0.6178543","0.59960103","0.59914863","0.59817404","0.5977805","0.59240603","0.59124815","0.59050536","0.58854413","0.5883479","0.5878619","0.58726865","0.5872482","0.5862645","0.5845876","0.58286446","0.5798391","0.57773703","0.5761368","0.5739017","0.57311535","0.57202834","0.5718749","0.5716095","0.57094413","0.57001233","0.5686181","0.5684708","0.5674461","0.5673693","0.566918","0.5657984","0.5645023","0.56273896","0.562368","0.5613604","0.56058294","0.5596882","0.5596854","0.5578092","0.5577753","0.55773455","0.5575799","0.5575332","0.5568767","0.55656654","0.5563127","0.5561028","0.5560396","0.555653","0.55555356","0.5538647","0.5538256","0.55354846","0.55332625","0.5528457","0.5525931","0.5514703","0.5513736","0.55109406","0.5510229","0.55097574","0.5489215","0.54852456","0.5484444","0.54828775","0.54798734","0.5471136","0.54686266","0.54585165","0.5458241","0.5449769","0.54486924","0.54427326","0.54415697","0.54335445","0.54321057","0.5431334","0.54180866","0.5413209","0.5412785","0.5411698","0.5408591","0.5407654","0.5400363","0.5396561","0.53928363","0.5388246","0.5384719","0.53782284","0.53733444","0.53708947","0.53707695","0.5363938","0.5361407"],"string":"[\n \"0.6751587\",\n \"0.6636538\",\n \"0.6448691\",\n \"0.6327863\",\n \"0.62453604\",\n \"0.6222981\",\n \"0.6178543\",\n \"0.59960103\",\n \"0.59914863\",\n \"0.59817404\",\n \"0.5977805\",\n \"0.59240603\",\n \"0.59124815\",\n \"0.59050536\",\n \"0.58854413\",\n \"0.5883479\",\n \"0.5878619\",\n \"0.58726865\",\n \"0.5872482\",\n \"0.5862645\",\n \"0.5845876\",\n \"0.58286446\",\n \"0.5798391\",\n \"0.57773703\",\n \"0.5761368\",\n \"0.5739017\",\n \"0.57311535\",\n \"0.57202834\",\n \"0.5718749\",\n \"0.5716095\",\n \"0.57094413\",\n \"0.57001233\",\n \"0.5686181\",\n \"0.5684708\",\n \"0.5674461\",\n \"0.5673693\",\n \"0.566918\",\n \"0.5657984\",\n \"0.5645023\",\n \"0.56273896\",\n \"0.562368\",\n \"0.5613604\",\n \"0.56058294\",\n \"0.5596882\",\n \"0.5596854\",\n \"0.5578092\",\n \"0.5577753\",\n \"0.55773455\",\n \"0.5575799\",\n \"0.5575332\",\n \"0.5568767\",\n \"0.55656654\",\n \"0.5563127\",\n \"0.5561028\",\n \"0.5560396\",\n \"0.555653\",\n \"0.55555356\",\n \"0.5538647\",\n \"0.5538256\",\n \"0.55354846\",\n \"0.55332625\",\n \"0.5528457\",\n \"0.5525931\",\n \"0.5514703\",\n \"0.5513736\",\n \"0.55109406\",\n \"0.5510229\",\n \"0.55097574\",\n \"0.5489215\",\n \"0.54852456\",\n \"0.5484444\",\n \"0.54828775\",\n \"0.54798734\",\n \"0.5471136\",\n \"0.54686266\",\n \"0.54585165\",\n \"0.5458241\",\n \"0.5449769\",\n \"0.54486924\",\n \"0.54427326\",\n \"0.54415697\",\n \"0.54335445\",\n \"0.54321057\",\n \"0.5431334\",\n \"0.54180866\",\n \"0.5413209\",\n \"0.5412785\",\n \"0.5411698\",\n \"0.5408591\",\n \"0.5407654\",\n \"0.5400363\",\n \"0.5396561\",\n \"0.53928363\",\n \"0.5388246\",\n \"0.5384719\",\n \"0.53782284\",\n \"0.53733444\",\n \"0.53708947\",\n \"0.53707695\",\n \"0.5363938\",\n \"0.5361407\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":79088,"cells":{"query":{"kind":"string","value":"Determine if it is an atomic term (e.g. \"A\") or a statement/compound term (e.g. (&&,A,B,..) or (A > B)) or variable term and creates the corresponding Term."},"document":{"kind":"string","value":"def from_string(cls, term_string):\n term_string = term_string.replace(\" \", \"\")\n\n if term_string in cls.term_dict:\n return cls.term_dict[term_string]\n\n if term_string[0] == NALSyntax.StatementSyntax.Start.value:\n \"\"\"\n Compound or Statement Term\n \"\"\"\n assert (term_string[-1] == NALSyntax.StatementSyntax.End.value), \"Compound/Statement term must have ending parenthesis: \" + term_string\n\n copula, copula_idx = NALSyntax.Copula.get_top_level_copula(term_string)\n if copula is None:\n # compound term\n term = CompoundTerm.from_string(term_string)\n else:\n term = StatementTerm.from_string(term_string)\n elif NALSyntax.TermConnector.is_set_bracket_start(term_string[0]):\n # set term\n term = CompoundTerm.from_string(term_string)\n elif term_string[0] == NALSyntax.TermConnector.Array.value:\n if NALSyntax.StatementSyntax.ArrayElementIndexStart.value in term_string:\n term = ArrayTermElementTerm.from_string(term_string)\n else:\n term = ArrayTerm.from_string(term_string)\n elif term_string[0] == VariableTerm.VARIABLE_SYM or term_string[0] == VariableTerm.QUERY_SYM:\n # variable term\n dependency_list_start_idx = term_string.find(\"(\")\n if dependency_list_start_idx == -1:\n variable_name = term_string[1:]\n dependency_list_string = \"\"\n else:\n variable_name = term_string[1:dependency_list_start_idx]\n dependency_list_string = term_string[term_string.find(\"(\") + 1:term_string.find(\")\")]\n\n term = VariableTerm.from_string(variable_name=variable_name,\n variable_type_symbol=term_string[0],\n dependency_list_string=dependency_list_string)\n else:\n term_string = re.sub(\",\\d+\", \"\", term_string)\n term = AtomicTerm(term_string)\n\n cls.term_dict[term_string] = term\n\n return term"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def parse_term(s, ctx, mctx, ops):\n s = strip_parens(s.strip())\n if re.search(\"^\\w*$\",s): # If a single word, either a variable or a constant\n if s in ops:\n return Con(ops[s], [], ctx, mctx)\n elif s in ctx:\n return Var(s, ctx, mctx)\n elif s in mctx:\n return MVar(s, [], ctx, mctx)\n elif s.startswith(\"O\") and s[1:] in mctx:\n return MVar(s, [], ctx, mctx, is_hole=True)\n else:\n raise Exception(\"Unbound variable: \" + \"'\" + s + \"'\")\n\n elif re.search(\"^\\w*\\[.*\\]$\", s): # If a metavariable\n m = re.search(\"^(\\w)*\\[(.*)\\]$\", s)\n mvar = m.group(1)\n env = m.group(2)\n if not env:\n return MVar(mvar, [], ctx, mctx, is_hole=mvar.startswith(\"O\"))\n else:\n return MVar(mvar, [Term.parse_term(t, ctx, mctx, ops) for t in split_tuple(env)], ctx, mctx)\n\n elif re.search(\"^([\\w ]*)\\.(.*)$\", s): # If a variable under binders\n m = re.search(\"^([\\w ]*)\\.(.*)$\", s)\n bound = m.group(1).split()\n tm = m.group(2)\n return Term.parse_term(tm, bound + ctx, mctx, ops)\n\n elif re.search(\"^(\\w*) *\\((.*)\\)$\", s): # If an expression\n m = re.search(\"^(\\w*) *\\((.*)\\)$\", s)\n op = m.group(1)\n args = m.group(2)\n return Con(ops[op], [Term.parse_term(t, ctx, mctx, ops) for t in split_tuple(args)], ctx, mctx)\n else:\n raise Exception(\"Can't parse: \" + s)","def convert_term(var_map, s, t):\n def convert(t):\n if t.head in var_map:\n if len(t.args) == 0:\n return s(Ident(to_binary(var_map[t.head])))\n elif len(t.args) == 1:\n return s(Para(Ident(to_binary(var_map[t.head])), t.arg))\n else:\n raise NotImplementedError\n elif t.is_equals():\n return Term.mk_equals(convert(t.arg1), convert(t.arg))\n elif logic.is_neg(t):\n return logic.neg(convert(t.arg))\n elif logic.is_conj(t):\n return logic.conj(convert(t.arg1), convert(t.arg))\n elif logic.is_disj(t):\n return logic.disj(convert(t.arg1), convert(t.arg))\n elif t.get_type() == boolT:\n return BoolV(t)\n elif t.get_type() == natT:\n return NatV(t)\n else:\n raise NotImplementedError\n\n return convert(t)","def term( ):\n\n\ttok = tokens.peek( )\n\tif debug: print (\"Term: \", tok)\n\tleft = factor( )\n\ttok = tokens.peek( )\n\twhile tok == \"*\" or tok == \"/\":\n\t\ttokens.next()\n\t\tright = factor( )\n\t\tleft = BinaryExpr( tok, left, right )\n\t\ttok = tokens.peek( )\n\treturn left","def makeVarOrKeyword(it):\n s = \"\"\n helper = AlphabetHelper()\n while it.hasNext():\n c = it.peek()\n if helper.isLiteral(c):\n s += c\n else:\n break\n it.next()\n\n if s in Keywords:\n return Token(KEYWORD, s)\n if s == \"true\" or s == \"false\":\n return Token(BOOLEAN, s)\n return Token(VARIABLE, s)","def parse_term(self) -> SyntaxNode:\n return self._parse_cat_binary(\"M\", self.parse_value)","def Term(self, paren=False):\n left = self.Factor()\n while self.currtok[1].name in {\"TIMES\", \"DIVISION\", \"MOD\"}:\n op = self.currtok[0]\n self.currtok = next(self.tg)\n right = self.Factor()\n left = BinaryExpr(op, left, right, paren)\n return left","def compile_term(self) -> None:\n token_type = self.tokenizer.token_type()\n\n if token_type == TokenTypes.IDENTIFIER:\n curr_token = self._get_current_token()\n self.tokenizer.advance()\n if self._get_current_token() in ('(', '.'):\n self.compile_subroutine_call(curr_token)\n elif self._get_current_token() == '[':\n self._consume('[')\n self.compile_expression()\n self._consume(']')\n\n kind = convert_kind(self.table.kind_of(curr_token))\n index = self.table.index_of(curr_token)\n\n self.writer.write_push(kind, index)\n self.writer.write_arithmetic('ADD')\n self.writer.write_pop('POINTER', 1)\n self.writer.write_push('THAT', 0)\n\n else:\n kind = convert_kind(self.table.kind_of(curr_token))\n index = self.table.index_of(curr_token)\n self.writer.write_push(kind, index)\n\n elif token_type == token_type.INT_CONST:\n self.writer.write_push('CONST', int(self._get_current_token()))\n self._consume(token_type)\n\n elif token_type == token_type.KEYWORD:\n curr_token = self._get_current_token()\n if curr_token in ['true', 'false', 'null']:\n self.writer.write_push('CONST', 0)\n if curr_token == 'true':\n self.writer.write_arithmetic('NOT')\n if curr_token == 'this':\n self.writer.write_push('POINTER', 0)\n self._consume(token_type)\n\n elif token_type == token_type.STRING_CONST:\n const_str = ''\n first = True\n while const_str.count('\"') < 2:\n if first:\n const_str += self._get_current_token()\n first = False\n else:\n const_str += ' ' + self._get_current_token()\n if self.tokenizer.has_more_tokens():\n self.tokenizer.advance()\n const_str = const_str.replace('\"', '')\n\n self.writer.write_push('CONST', len(const_str))\n self.writer.write_call('String.new', 1)\n\n for char in const_str:\n self.writer.write_push('CONST', ord(char))\n self.writer.write_call('String.appendChar', 2)\n\n else:\n if self._get_current_token() == '(':\n self._consume('(')\n self.compile_expression()\n self._consume(')')\n else:\n op = self._get_current_token()\n self._consume(['-', '~']) # unaryOp term\n self.compile_term()\n if op == '-':\n self.writer.write_arithmetic('NEG')\n else:\n self.writer.write_arithmetic('NOT')","def from_term(term):\n if term is None:\n return term\n elif isinstance(term, (six.string_types, int, float)):\n return term\n elif isinstance(term, dict):\n return {k: from_term(v) for k, v in term.items()}\n elif isinstance(term, list):\n return [from_term(t) for i, t in enumerate(term)]\n elif issubclass(term.__class__, (Matcher,)):\n return term.generate()\n else:\n raise ValueError('Unknown type: %s' % type(term))","def compile_term(self):\n\n\t\tself.outfile.write('<term>\\n')\n\n\t\tcount = 0\n\n\t\twhile(self.tokenizer.get_token() not in [')',']',';',',', '/', '|', '<', '>', '=', '*', '+', '&']):\n\t\t\tif self.tokenizer.get_token().isdigit():\n\t\t\t\tself.outfile.write(self.tokenizer.int_value())\n\t\t\telif '\"' in self.tokenizer.get_token():\n\t\t\t\tself.outfile.write(self.tokenizer.str_value())\n\t\t\telif self.tokenizer.get_token() in ['true', 'false', 'null', 'this']:\n\t\t\t\tself.outfile.write(self.tokenizer.keyword())\n\t\t\telif self.tokenizer.get_token() == '-' and count == 0:\n\t\t\t\tself.outfile.write(self.tokenizer.symbol())\n\t\t\t\tself.compile_term()\n\t\t\telif self.tokenizer.get_token() == '-' and count > 0:\n\t\t\t\tbreak\n\t\t\telif self.tokenizer.get_token() == '~':\n\t\t\t\tself.outfile.write(self.tokenizer.symbol())\n\n\t\t\t\tif self.tokenizer.get_token() != '(':\n\t\t\t\t\tself.compile_term()\n\n\t\t\t\telse:\n\t\t\t\t\tself.outfile.write('<term>\\n' + self.tokenizer.symbol())\n\t\t\t\t\tself.compile_expression()\n\t\t\t\t\txml = self.tokenizer.symbol() + '</term>\\n'\n\t\t\t\t\tself.outfile.write(xml)\n\n\t\t\telif self.tokenizer.get_token() == '(':\n\n\t\t\t\tself.outfile.write(self.tokenizer.symbol())\n\t\t\t\tself.compile_expression()\n\t\t\t\tself.outfile.write(self.tokenizer.symbol())\n\n\t\t\telif self.tokenizer.get_token() == '[':\n\t\t\t\txml = self.tokenizer.symbol()\n\t\t\t\tself.outfile.write(xml)\n\n\t\t\t\tself.compile_expression()\n\n\t\t\t\tself.outfile.write(self.tokenizer.symbol())\n\n\t\t\telif self.tokenizer.get_token() == '.':\n\t\t\t\txml = self.tokenizer.symbol() + self.tokenizer.identifier() + self.tokenizer.symbol() + '<expressionList>\\n'\n\t\t\t\tself.outfile.write(xml)\n\n\t\t\t\tif self.tokenizer.get_token() != ')':\n\t\t\t\t\tself.compile_expression_list()\n\n\t\t\t\tself.outfile.write('</expressionList>\\n' + self.tokenizer.symbol())\n\t\t\n\t\t\telse:\n\t\t\t\tself.outfile.write(self.tokenizer.identifier())\n\n\t\t\tcount = count + 1\n\n\t\tself.outfile.write('</term>\\n')\n\n\t\tif self.tokenizer.get_token() in self.tokenizer._operands:\n\t\t\tif self.tokenizer.get_token() in ['<', '>', '\"', '&']:\n\t\t\t\txml = '<symbol> ' + CompilationEngine._operands.get(self.tokenizer.get_token()) + ' </symbol>\\n'\n\t\t\t\tself.tokenizer.advance()\n\t\t\telse:\n\t\t\t\txml = self.tokenizer.symbol()\n\n\t\t\tself.outfile.write(xml)\n\t\t\tself.compile_term()","def fold_term(self, init_repr, term):\n if isinstance(term, Var):\n return self.var(init_repr, term.name)\n elif isinstance(term, Const):\n return self.const(init_repr, term.name)\n elif isinstance(term, Dist):\n return self.dist(init_repr, term.name)\n elif isinstance(term, Func):\n return self.func(\n init_repr,\n term.funcname,\n [ self.fold_term(init_repr, x)\n for x in term.args ])\n elif isinstance(term, Eq):\n return self.eq(\n init_repr,\n term.pos,\n self.fold_term(init_repr, term.t1),\n self.fold_term(init_repr, term.t2))\n elif isinstance(term, Disj):\n return self.disj(\n init_repr,\n term.role,\n [ self.fold_term(init_repr, eq)\n for eq in term.eqs ])\n elif isinstance(term, Conj):\n return self.conj(\n init_repr,\n [ self.fold_term(init_repr, disj)\n for disj in term.disjs ])","def parseTerm(element):\n tag, text = element.tag, element.text\n if tag == RESULTS_NS_ET + 'literal':\n if text is None:\n text = ''\n datatype = None\n lang = None\n if element.get('datatype', None):\n datatype = URIRef(element.get('datatype'))\n elif element.get(\"{%s}lang\" % XML_NAMESPACE, None):\n lang = element.get(\"{%s}lang\" % XML_NAMESPACE)\n\n ret = Literal(text, datatype=datatype, lang=lang)\n\n return ret\n elif tag == RESULTS_NS_ET + 'uri':\n return URIRef(text)\n elif tag == RESULTS_NS_ET + 'bnode':\n return BNode(text)\n else:\n raise TypeError(\"unknown binding type %r\" % element)","def term_to_rdflib(term: str) -> Term:\n if term.startswith('?'):\n return Variable(term[1:])\n elif term.startswith(\"\\\"\"):\n return from_n3(term)\n else:\n return URIRef(term)","def simplify(term):\n simplified_term = term\n\n if isinstance(term,StatementTerm):\n simplified_term = StatementTerm(subject_term=simplify(term.get_subject_term()),\n predicate_term=simplify(term.get_predicate_term()),\n copula=term.get_copula(),\n interval=term.interval)\n elif isinstance(term,CompoundTerm):\n if term.connector == NALSyntax.TermConnector.Negation and \\\n len(term.subterms) == 1 and \\\n isinstance(term.subterms[0],CompoundTerm) and \\\n term.subterms[0].connector == NALSyntax.TermConnector.Negation :\n # (--,(--,(S --> P)) <====> (S --> P)\n # Double negation theorem. 2 Negations cancel out\n simplified_term = simplify(term.subterms[0].subterms[0]) # get the inner statement\n # elif NALSyntax.TermConnector.is_conjunction(term.connector):\n # #(&&,A,B..C)\n # new_subterms = []\n # new_intervals = []\n # for i in range(len(term.subterms)):\n # subterm = simplify(term.subterms[i])\n # if i < len(term.intervals): new_intervals.append(term.intervals[i])\n # if isinstance(subterm, CompoundTerm) and subterm.connector == term.connector:\n # # inner conjunction\n # new_subterms.extend(subterm.subterms)\n # new_intervals.extend(subterm.intervals)\n # else:\n # new_subterms.append(subterm)\n #\n # simplified_term = CompoundTerm(subterms=new_subterms,\n # term_connector=term.connector,\n # intervals=new_intervals)\n elif term.connector is NALSyntax.TermConnector.ExtensionalDifference:\n pass\n elif term.connector is NALSyntax.TermConnector.IntensionalDifference:\n pass\n elif term.connector is NALSyntax.TermConnector.ExtensionalImage:\n pass\n elif term.connector is NALSyntax.TermConnector.IntensionalImage:\n pass\n\n\n return simplified_term","def T(logic_formula):\n global counter, p_base\n # p_base: (str) A string which is important to creating new variable without coincide with the existing variables.\n # counter: (int) The counter that increment when new variable is created.\n \n if logic_formula.isliteral:\n return (logic_formula, TRUE)\n else:\n args = logic_formula.args\n operator = OR if logic_formula.operator == '|' else AND if logic_formula.operator == '&' else NOT\n if operator == NOT:\n f = args[0]\n p_prime, c_prime = T(f)\n return (NOT(p_prime), c_prime)\n else:\n f1 = args[0]\n f2 = operator(*args[1:len(args)]) if (len(args) > 2) else args[1]\n\n p = p_base.__str__() + str(counter)\n p = algebra.Symbol(p)\n counter = counter + 1\n\n p1, c1 = T(f1)\n p2, c2 = T(f2)\n\n return (p, (AND(OR(NOT(p), p1, p2), OR(p, NOT(p1)), OR(p, NOT(p2)), c1, c2)).simplify()) if (\n operator == OR) else \\\n (p, (AND(OR(p, NOT(p1), NOT(p2)), OR(NOT(p), p1), OR(NOT(p), p2), c1, c2).simplify()))","def var_or_atomics():\n return Parse.plus(var_or_atomic())","def parse_terminal(node, ty=None):\n if ty == \"METHOD_CALL\":\n return Terminal(\"var\", None)\n elif ty:\n return Terminal(\"var\", ty)\n else:\n return Terminal(\"var\", get_type(node))","def ontology_term(self, term=None, parent_ID=None, specified=None, vtype=None,\n desc=None, units=None, **kwargs):\n if specified:\n specified=str2bool(specified)\n\n payload={\"name\":term,\"description\":desc,\"type\":vtype,\"specified\":specified,\"units\":units}\n r=self.post(self.ONTOLOGY_TERM_RT,None,parent_ID,payload,**kwargs)\n return r","def parse(s):\n Term.str = s\n new_term = None\n while Term.str != '':\n new_term, Term.str = Term.parse_prefix(Term.str)\n return new_term","def parse_prefix(s):\n\n Term.str = replace_string(s) # replace operators with more than one letter to be one letter\n second = None\n\n # if there is a left parentheses it means that we are having an operator that is enclosed by parenthesis\n if is_left_parenthese(Term.str[0]):\n Term.eat() # eat left parentheses\n first, Term.str = Formula.parse_prefix(Term.str) # take first formula of the operator\n root = switch_root_to_str(Term.str[0]) # take the root\n Term.eat() # eat the root\n second, Term.str = Formula.parse_prefix(Term.str) # take second formula of the operator\n Term.eat() # eat right parentheses\n\n # if first letter is a quantifier ('A' or 'E')\n elif is_quantifier(Term.str[0]):\n root = Term.str[0] # take the quantifier as root\n Term.eat() # eat the root ( quantifier)\n first = Term.get_whole_name() # take the name of the variable\n Term.eat() # eat the left bracket\n second, Term.str = Formula.parse_prefix(Term.str) # take the formula\n Term.eat() # eat the right bracket\n\n # if first letter is a relation (starts with capital letter)\n elif is_relation(Term.str[0]):\n root = Term.get_whole_name() # take the name of the relation\n first = []\n Term.eat() # eat left parentheses\n\n # if we didn't find closing parenthesis - than there must be at least one Term inside the parenthesis.\n # take it.\n if not is_right_parenthese(Term.str[0]):\n term_obj, Term.str = Term.parse_prefix(Term.str)\n first.append(term_obj)\n\n # while there is a comma, take the next term\n while is_comma(Term.str[0]):\n Term.eat() # eat left parentheses\n term_obj, Term.str = Term.parse_prefix(Term.str)\n first.append(term_obj)\n Term.eat() # eat right parentheses\n\n # else , it is an operator\n else:\n\n # if it's an unary operator\n if is_unary(Term.str[0]):\n root = Term.str[0]\n Term.eat()\n first, Term.str = Formula.parse_prefix(Term.str)\n\n # else , the operator is binary or equaluty\n else:\n first, Term.str = Term.parse_prefix(Term.str)\n # if it's a binary operator\n if is_binary(Term.str[0]):\n root = Term.str[0:2]\n Term.eat()\n\n # if it's an equal operator\n else:\n root = Term.str[0]\n Term.eat()\n second, Term.str = Term.parse_prefix(Term.str)\n returned_formula = Formula(root, first, second)\n return returned_formula, Term.str","def fromTerm(cls, term, swipl):\n\n if isinstance(term, Term):\n term = term.handle\n elif not isinstance(term, (c_void_p, int)):\n raise ArgumentTypeError((str(Term), str(c_void_p)), str(type(term)))\n\n a = atom_t()\n if swipl.PL_get_atom(term, byref(a)):\n return cls(a.value, swipl)","def __generate_object_term__(self, datatype, value):\n if datatype == NS_MGR.xsd.anyURI.rdflib:\n term = rdflib.URIRef(value)\n elif datatype:\n term = rdflib.Literal(value, datatype=datatype)\n else:\n term = rdflib.Literal(value)\n return term","def __init__(self, ty, base_ty):\n\t\t\tassert isinstance(ty, Term)\n\t\t\tassert isinstance(base_ty, Term)\n\t\t\tself.ty = ty\n\t\t\tself.base_ty = ty","def BNF():\n\n sect_begin = Literal(\"{\").suppress()\n sect_end = Literal(\"}\").suppress()\n array_begin = Literal(\"[\").suppress()\n array_end = Literal(\"]\").suppress()\n tag_begin = Literal(\"<\").suppress()\n tag_end = Literal(\">\").suppress()\n eql = Literal(\"=\").suppress()\n dmark = Literal('$').suppress()\n end_data = Literal('$end').suppress()\n prtable = alphanums + r'!$%&*+-./<>?@^_|~'\n int_t = Regex('[-]?\\d+')\n float_t = Regex('-?\\d+\\.\\d*([eE]?[+-]?\\d+)?')\n bool_t = Regex('([Yy]es|[Nn]o|[Tt]rue|[Ff]alse|[Oo]n|[Oo]ff)')\n\n # Helper definitions\n kstr = quotedString.setParseAction(\n removeQuotes) ^ float_t ^ int_t ^ bool_t ^ Word(prtable)\n name = Word(alphas + \"_\", alphanums + \"_\")\n vec = array_begin + delimitedList(\n float_t ^ int_t ^ bool_t ^ Word(prtable) ^ Literal(\"\\n\").suppress() ^\n quotedString.setParseAction(removeQuotes)) + array_end\n sect = name + sect_begin\n tag_sect = name + Group(tag_begin + name + tag_end) + sect_begin\n\n # Grammar\n keyword = name + eql + kstr\n vector = name + eql + vec\n data = Combine(dmark + name) + SkipTo(end_data) + end_data\n #section = Forward()\n sect_def = (sect | tag_sect)\n #input = section | data | vector | keyword\n input = sect_def | data | vector | keyword | sect_end\n #section << sect_def + ZeroOrMore(input) + sect_end\n\n # Parsing actions\n int_t.setParseAction(token_actions.to_int)\n float_t.setParseAction(token_actions.to_float)\n bool_t.setParseAction(token_actions.to_bool)\n keyword.setParseAction(token_actions.to_scalar)\n vector.setParseAction(token_actions.to_array)\n data.setParseAction(token_actions.to_data)\n sect.setParseAction(token_actions.to_section)\n tag_sect.setParseAction(token_actions.to_section)\n sect_end.setParseAction(token_actions.end_of_section)\n\n bnf = ZeroOrMore(input) + StringEnd().setFailAction(\n token_actions.parse_error)\n bnf.ignore(pythonStyleComment)\n\n return Dict(bnf)","def determine_term_type(term):\n \n NOMINALS = [\"ation\", \"ition\", \"ption\", \"ing\", \"sis\", \"lism\", \"ment\", \"sion\"]\n EVENT_KEYWORDS = [\"process\", \"cycle\"]\n \n # key words that indicate events despite being nouns \n if any([ek in term.text.lower() for ek in EVENT_KEYWORDS]):\n term_type = \"event\"\n # key endings indicating a nominalized form of an event \n elif any([term[i].text.endswith(ne) for ne in NOMINALS for i in range(len(term))]):\n term_type = \"event\"\n # POS = Verb implies event \n elif any([t.pos_ == \"VERB\" for t in term]):\n term_type = \"event\"\n # default is otherwise entity \n else:\n term_type = \"entity\"\n \n return term_type","def fold_term(self, term):\n if isinstance(term, Var):\n return self.var(term.name)\n elif isinstance(term, Const):\n return self.const(term.name)\n elif isinstance(term, Dist):\n return self.dist(term.name)\n elif isinstance(term, Func):\n return self.func(\n term.funcname,\n tuple( self.fold_term(x)\n for x in term.args ))\n elif isinstance(term, Eq):\n return self.encode_eq(term)\n elif isinstance(term, Disj):\n return self.encode_disj(term)\n elif isinstance(term, Conj):\n return self.encode_conj(term)\n raise RuntimeError('Invalid term {}'.format(term))","def makeTermType(tag, keyword, G):\n string = \"<%s>\" % tag\n\n l = G(\"%sLSL\" % keyword)\n lsym = G(\"%sLSLSymbol\" % keyword)\n s = G(\"%sS\" % keyword)\n mult = G(\"%sLSMultiplicity\" % keyword)\n senior = G(\"%sLSSeniority\" % keyword)\n\n if l and s:\n string += \"<LS>\"\n string += \"<L><Value>%s</Value>\"% l\n if lsym: string += \"<Symbol>%s</Symbol>\" % lsym\n string += \"</L><S>%s</S>\" % s\n if mult: string += \"<Multiplicity>%s</Multiplicity>\" % mult\n if senior: string += \"<Seniority>%s</Seniority>\" % senior\n string += \"</LS>\"\n\n jj = makeiter(G(\"%sJJ\" % keyword))\n if jj:\n string += \"<jj>\"\n for j in jj:\n string += \"<j>%s</j>\" % j\n string += \"</jj>\"\n j1j2 = makeiter(G(\"%sJ1J2\" % keyword))\n if j1j2:\n string += \"<j1j2>\"\n for j in j1j2:\n string += \"<j>%s</j>\" % j\n string += \"</j1j2>\"\n K = G(\"%sK\" % keyword)\n if K:\n string += \"<jK>\"\n j = G(\"%sJKJ\" % keyword)\n if j:\n string += \"<j>%s</j>\" % j\n S2 = G(\"%sJKS\" % keyword)\n if S2:\n string += \"<S2>%s</S2>\" % S2\n string += \"<K>%s</K>\" % K\n string += \"</jK>\"\n l = G(\"%sLKL\" % keyword)\n k = G(\"%sLKK\" % keyword)\n if l and k:\n string += \"<LK>\"\n string += \"<L><Value>%s</Value><Symbol>%s</Symbol></L>\" % (l, G(\"%sLKLSymbol\" % keyword))\n string += \"<K>%s</K>\" % k\n string += \"<S2>%s</S2>\" % G(\"%sLKS2\" % keyword)\n string += \"</LK>\"\n tlabel = G(\"%sLabel\" % keyword)\n if tlabel:\n string += \"<TermLabel>%s</TermLabel>\" % tlabel\n string += \"</%s>\" % tag\n return string","def assign_term(urs):\n\n if isinstance(urs, six.string_types):\n return MAPPING.get(urs, UNKNOWN)\n return assign_term(urs.get_rna_type())","def visit_term(self, node, children):\n if self.debug:\n print(\"Term {}\".format(children))\n term = children[0]\n for i in range(2, len(children), 2):\n if children[i-1] == \"*\":\n term *= children[i]\n else:\n term /= children[i]\n if self.debug:\n print(\"Term = {}\".format(term))\n return term","def parse(s: str):\n Term.str = s\n new_Formula = None\n while Term.str != '':\n new_Formula, Term.str = Formula.parse_prefix(Term.str)\n return new_Formula\n # Task 7.4.2","def apply_rule(term: Term, rule: Rule):\n if isinstance(term, rule.type):\n substitution = term.match(rule.left)\n if substitution is not None:\n new_t = subst(rule.right, substitution)\n if isinstance(new_t, Term):\n new_t = term.__class__(new_t.function, new_t.arguments, new_t.static)\n return new_t\n return term","def __call__(self, *args: TermLike) -> 'Term':\n return Term(self, args)","def atomic():\n #I forget why I am converting integers.\n def f(item):\n item1 = Parse.next_token().process(item)\n result = item1.tok\n if result.type == 'INTEGER' or result.type == 'WORD':\n tok = copy.copy(result)\n if tok.type == 'WORD':\n tok.value = c.synonymize(tok.value)\n tok.type = 'ATOMIC_IDENTIFIER'\n return (tok,item1)\n if result.type == 'ATOMIC_IDENTIFIER':\n return result\n raise ParseError(item)\n return Parse(f).expect('atomic')","def mk_VAR(v):\n if not v.is_var():\n raise InvalidDerivationException(\"mk_VAR\")\n return Thm([], Const(\"_VAR\", TFun(v.T, BoolType))(v))","def is_term():\n global _STATIC_VARS\n return _STATIC_VARS.term","def format_term(term: Union[BNode, Literal, URIRef, Variable]) -> str:\n if isinstance(term, URIRef):\n return str(term)\n elif isinstance(term, BNode):\n return '?v_' + str(term)\n elif isinstance(term, Literal):\n return format_literal(term)\n else:\n return term.n3()","def _make_transition(token_namespace, reserved_syntax_strings, label):\n if label[0].isalpha():\n # A named token (e.g. NAME, NUMBER, STRING)\n return getattr(token_namespace, label)\n else:\n # Either a keyword or an operator\n assert label[0] in ('\"', \"'\"), label\n assert not label.startswith('\"\"\"') and not label.startswith(\"'''\")\n value = literal_eval(label)\n try:\n return reserved_syntax_strings[value]\n except KeyError:\n r = reserved_syntax_strings[value] = ReservedString(value)\n return r","def act_on_literal(self, *, value):\n assert not isinstance(value, PolarsTerm)\n if isinstance(value, (Dict, List, Set)):\n return PolarsTerm(polars_term=None, is_literal=True, lit_value=value)\n else:\n return PolarsTerm(polars_term=_build_lit(value), is_literal=True, lit_value=value)","def get_or_create_term(self, term):\n term_id = self.get_term_id(term)\n if term_id is not None:\n return term_id\n\n term_id = self.db.execute('INSERT INTO terms(term) VALUES (?) ', (term,)).lastrowid\n postings_table = 'term_%d' % term_id\n\n info(\"creating table for term \" + term)\n\n self.db.execute('''CREATE TABLE %s (document_id INT NOT NULL,\n hits INT NOT NULL,\n FOREIGN KEY (document_id) REFERENCES documents(rowid));''' % postings_table)\n\n return term_id","def generate_term(self, **kwargs):\n term_map = kwargs.pop('term_map')\n if hasattr(term_map, \"termType\") and\\\n term_map.termType == NS_MGR.rr.BlankNode.rdflib:\n return rdflib.BNode()\n if not hasattr(term_map, 'datatype'):\n term_map.datatype = NS_MGR.xsd.anyURI.rdflib\n if hasattr(term_map, \"template\") and term_map.template is not None:\n template_vars = kwargs\n template_vars.update(self.constants)\n # Call any functions to generate values\n for key, value in template_vars.items():\n if hasattr(value, \"__call__\"):\n template_vars[key] = value()\n raw_value = term_map.template.format(**template_vars)\n if term_map.datatype == NS_MGR.xsd.anyURI.rdflib:\n return rdflib.URIRef(raw_value)\n return rdflib.Literal(raw_value,\n datatype=term_map.datatype)\n if term_map.reference is not None:\n # Each child will have different mechanisms for referencing the\n # source based\n return self.__generate_reference__(term_map, **kwargs)","def fromTerm(cls, term, swipl):\n\n if isinstance(term, Term):\n term = term.handle\n elif not isinstance(term, (c_void_p, int)):\n raise ArgumentTypeError((str(Term), str(int)), str(type(term)))\n\n f = functor_t()\n if swipl.PL_get_functor(term, byref(f)):\n # get args\n args = []\n arity = swipl.PL_functor_arity(f.value)\n # let's have all args be consecutive\n a0 = swipl.PL_new_term_refs(arity)\n for i, a in enumerate(range(1, arity + 1)):\n if swipl.PL_get_arg(a, term, a0 + i):\n args.append(getTerm(a0 + i, swipl))\n\n return cls(f.value, swipl, args=args, a0=a0)","def temp_var_or_literal(self, name, var, init):\n if var[0]:\n # Literal\n return var[1]\n temp = self.make_temp_var(name)\n init.append('%s = %s' % (temp, var[1]))\n return temp","def create() -> 'Tokenizer':\n token_op_table = [\n EOS,\n op.Concat,\n op.ConstStr,\n op.SubStr,\n op.GetSpan,\n op.Trim,\n ]\n\n # Nesting operators and their args get \"compacted\" into\n # \"primitive\" tokens\n\n for type_ in op.Type:\n for index in op.INDEX:\n token_op_table.append((op.GetToken, type_, index))\n\n for case in op.Case:\n token_op_table.append((op.ToCase, case))\n\n for delim1 in op.DELIMITER:\n for delim2 in op.DELIMITER:\n token_op_table.append((op.Replace, delim1, delim2))\n\n for dsl_regex in list(op.Type) + list(op.DELIMITER):\n token_op_table.append((op.GetUpto, dsl_regex))\n\n for dsl_regex in list(op.Type) + list(op.DELIMITER):\n token_op_table.append((op.GetFrom, dsl_regex))\n\n for type_ in op.Type:\n for index in op.INDEX:\n token_op_table.append((op.GetFirst, type_, index))\n\n for type_ in op.Type:\n token_op_table.append((op.GetAll, type_))\n\n # Primitive types\n\n for type_ in op.Type:\n token_op_table.append(type_)\n\n for boundary in op.Boundary:\n token_op_table.append(boundary)\n\n # Covers op.INDEX\n for position in range(op.POSITION[0], op.POSITION[1]+1):\n token_op_table.append(position)\n\n # This covers op.DELIMITER\n for character in op.CHARACTER:\n token_op_table.append(character)\n\n token_op_table = {\n token: op\n for token, op in enumerate(token_op_table)\n }\n\n op_token_table = {\n op: token\n for token, op in token_op_table.items()\n }\n\n assert len(token_op_table) == len(op_token_table)\n\n string_token_table = {\n char: token\n for token, char in enumerate(op.CHARACTER)\n }\n\n return Tokenizer(\n token_op_table=token_op_table,\n op_token_table=op_token_table,\n string_token_table=string_token_table,\n )","def _read_terminal_node(cls, elements):\n \n # TODO: add option to read lemma, pos if the input come from ccg\n label = elements[0]\n word = elements[1]\n return SyntacticNode(label, word=word, pos=label)","def __init__(self, \r\n atomicTermExpr=None, \r\n composedTermNodeLabels=None, \r\n generatedTermLabel=None):\r\n self.__ate = atomicTermExpr if atomicTermExpr is not None else Never()\r\n self.__ctnls = composedTermNodeLabels\r\n self.__gtl = generatedTermLabel","def expression( ):#DOUBLE CHECK THIS\n\t\n\ttok = tokens.peek( )\n\tif debug: print(\"Expression: \", tok)\n\tleft = andExpr( ) #does the left side of the grammar \n\ttok = tokens.peek( )\n\twhile tok == \"or\": #checks to see if there is the token or and will preform what is inside the curly bracket since it is a series \n\t\ttokens.next()\n\t\tright = andExpr( )\n\t\tleft = BinaryExpr(tok, left, right) # MIGHT HAVE TO CHANGE THIS TO STRING CAUSE ITS \"or\"\n\t\ttok = tokens.peek( )\n\treturn left","def parse(operators, *term_strs):\n scope = Scope()\n rvs = []\n for ts in term_strs:\n p = Parser(operators, ts, scope)\n try:\n term = p.parse()\n except SyntaxError:\n print 'While parsing: %s' % ts\n raise\n rvs.append(term)\n rvs.append(scope)\n return tuple(rvs)","def __transform_term(self, term: ast.TermASTNode) -> ast.TermASTNode:\n # TODO: expansion cycle detection\n if isinstance(term, ast.FunctionApplicationASTNode) \\\n and isinstance(term.get_declaration().get_declaring_ast_node(), ast.DefineFunCommandASTNode):\n definition = term.get_declaration().get_declaring_ast_node()\n result = self.__create_expansion(term, definition)\n else:\n result = term\n\n # Transform child nodes.\n children = result.get_child_nodes()\n for i, child_node in enumerate(children):\n result.set_child_node(i, self.__transform_term(child_node))\n\n return result","def atom(token):\n try:\n return int(token)\n except ValueError:\n try:\n return float(token)\n except ValueError:\n return Symbol(token)","def act_on_literal(self, *, value):\n assert not isinstance(value, PolarsTerm)","def AddTerm(con, cur, term, parent='na', ontologyname='scdb', synonyms=[], commit=True):\n try:\n # convert everything to lower case before interacting with the database\n term = term.lower()\n parent = parent.lower()\n ontologyname = ontologyname.lower()\n synonyms = [csyn.lower() for csyn in synonyms]\n\n # add/get the ontology term\n err, termid = dbidval.AddItem(con, cur, table='OntologyTable', description=term, commit=False)\n if err:\n return err, None\n # add/get the ontology parent term\n err, parentid = dbidval.AddItem(con, cur, table='OntologyTable', description=parent, commit=False)\n if err:\n return err, None\n # add/get the ontology name\n err, ontologynameid = dbidval.AddItem(con, cur, table='OntologyNamesTable', description=ontologyname, commit=False)\n if err:\n return err, None\n # add the tree info\n err, treeid = AddTreeTerm(con, cur, termid, parentid, ontologynameid, commit=False)\n if err:\n return err, None\n # add the synonyms\n if synonyms:\n for csyn in synonyms:\n err, cid = AddSynonym(con, cur, termid, csyn, commit=False)\n debug(2, 'added ontology term %s. id is %d' % (term, termid))\n if commit:\n con.commit()\n return '', termid\n\n except psycopg2.DatabaseError as e:\n debug(7, \"error %s enountered in ontology.AddTerm\" % e)\n return \"error %s enountered in ontology.AddTerm\" % e, -2","def eval(node):\n if node.id == '(literal)':\n return node.value\n elif node.id == '(name)':\n return scope[node.value]\n elif node.id == '(':\n name, args = node.children\n name = eval(name)\n args = map(eval, args)\n return name(*args)\n elif node.id == 'and':\n assert len(node.children) == 2\n first = eval(node.children[0])\n if first:\n return eval(node.children[1])\n else:\n return first\n elif node.id == 'or':\n assert len(node.children) == 2\n first = eval(node.children[0])\n if first:\n return first\n else:\n return eval(node.children[1])\n elif node.id == 'not':\n assert len(node.children) == 1\n return not eval(node.children[0])\n elif node.id in prefix_operators and len(node.children) == 1:\n value = eval(node.children[0])\n return prefix_operators[node.id](value)\n elif node.id in operators:\n values = [eval(v) for v in node.children]\n return operators[node.id](*values)\n else:\n raise ValueError('unknown node type', node)","def literal():\n return Literal()","def atom(token):\n try:\n return int(token)\n except ValueError:\n try:\n return float(token)\n except ValueError:\n return Symbol(token) # Equivalent to str(token)","def factor( ):\n\n\ttok = tokens.peek( )\n\tif debug: print (\"Factor: \", tok)\n\tif re.match( Lexer.number, tok ):\n\t\texpr = Number(tok)\n\t\ttokens.next( )\n\t\ttok = tokens.peek( )\n\t\treturn expr\n\tif tok == \"(\":\n\t\ttokens.next( ) # or match( tok )\n\t\texpr = addExpr( )#might need to change to expression( )\n\t\ttokens.peek( )\n\t\ttok = match( \")\" )\n\t\treturn expr\n\tif re.match( Lexer.identifier, tok ): # added this to take into accout identifiers\n\t\texpr = VarRef(tok)\n\t\ttokens.next( )\n\t\treturn expr\n\tif re.match( Lexer.String, tok ): # added this to take into account strings\n\t\texpr = String( tok )\n\t\treturn expr\n\n\terror( \"Invalid operand\" )\n\treturn","def proc(form, term, idx):\n assert term == tensor.local_terms[idx]\n assert form == expected_terms[idx]\n return 'N'","def declare_variable(var, bound_variables):\n varname = var.name\n vartype = var.vartype\n\n # check if it is bound and has already been seen\n if bound_variables is not None and varname in bound_variables:\n yvar = bound_variables[varname].yices_term\n var.bound = True\n return yvar\n\n # check if it has already been seen\n yvar = Terms.get_by_name(varname)\n if yvar is not None:\n #now we need to see if it is free or bound\n tag = Terms.constructor(yvar)\n if tag == Constructor.VARIABLE:\n var.bound = True\n bound_variables[varname] = var\n return yvar\n\n type_term = vartype.yices_term\n type_name = vartype.name\n\n var_term = None\n\n if bound_variables is not None:\n # we need to make a yices variable not an uninterpreted term\n var_term = Terms.new_variable(type_term, varname)\n if var_term is None:\n sys.stderr.write(f'declare_variable: Term.new_variable failed {Yices.error_string()}\\n')\n return None\n bound_variables[varname] = var\n var.bound = True\n else:\n var_term = Terms.new_uninterpreted_term(type_term, varname)\n if var_term is None:\n sys.stderr.write(f'declare_variable: Term.new_uninterpreted_term failed {Yices.error_string()}\\n')\n return None\n\n YicesSignature.types_to_variables[type_name].add(var)\n\n return var_term","def terms(self) -> Tuple[Term, ...]:\n ...","def get_atom_type(self, atom):\n if self.check_if_keyword(atom):\n # 1 for keyword\n return 1\n if self.check_if_var(atom):\n # 2 for identifier\n return 2\n if self.check_if_const(atom):\n # 3 for constant\n return 3\n if atom == \" \" or atom == \"\" or atom == '' or atom == \"\\n\" or atom.isspace():\n # 4 for generic separators\n return 4\n return 0","def term_from_uri(uri):\n if uri is None:\n return None\n # This insures that if we get a Literal with an integer value (as we\n # do for modification positions), it will get converted to a string,\n # not an integer.\n if isinstance(uri, rdflib.Literal):\n uri = str(uri.toPython())\n # This is to handle URIs like\n # http://www.openbel.org/bel/namespace//MAPK%20Erk1/3%20Family\n # or\n # http://www.openbel.org/bel/namespace/MAPK%20Erk1/3%20Family\n # In the current implementation, the order of the patterns\n # matters.\n patterns = ['http://www.openbel.org/bel/namespace//(.*)',\n 'http://www.openbel.org/vocabulary//(.*)',\n 'http://www.openbel.org/bel//(.*)',\n 'http://www.openbel.org/bel/namespace/(.*)',\n 'http://www.openbel.org/vocabulary/(.*)',\n 'http://www.openbel.org/bel/(.*)']\n for pr in patterns:\n match = re.match(pr, uri)\n if match is not None:\n term = match.groups()[0]\n term = unquote(term)\n return term\n # If none of the patterns match then the URI is actually a simple term\n # for instance a site: \"341\" or a substitution: \"sub(V,600,E)\"\n return uri","def format_literal(term: Literal) -> str:\n lang = term.language\n dtype = term.datatype\n lit = str(term)\n if lang is not None or dtype is not None:\n return term.n3()\n if re.fullmatch(r_integer, lit):\n dtype = XSD.integer\n elif re.fullmatch(r_decimal, lit):\n dtype = XSD.decimal\n elif re.fullmatch(r_double, lit):\n dtype = XSD.double\n elif re.fullmatch(r_boolean, lit):\n dtype = XSD.boolean\n return Literal(lit, lang, dtype).n3()","def visitTerminal(self, node):\n # type: (TerminalNode) -> Union[expr.Expr, int, float]\n\n node_type = node.getSymbol().type\n node_text = node.getText()\n name = node_text[1:]\n\n # variables\n if node_type == RelayLexer.GLOBAL_VAR:\n return lookup(deque([self.global_var_scope]), node_text[1:])\n if node_type == RelayLexer.LOCAL_VAR:\n # Remove the leading '%' and lookup the name.\n var = lookup(self.var_scopes, name)\n if var is None:\n raise ParseError(\"Couldn't resolve `{}`.\".format(name))\n return var\n if node_type == RelayLexer.GRAPH_VAR:\n try:\n return self.graph_expr[int(name)]\n except IndexError:\n raise ParseError(\"Couldn't resolve `{}`\".format(name))\n\n # data types\n if node_type == RelayLexer.NAT:\n return int(node_text)\n if node_type == RelayLexer.FLOAT:\n return float(node_text)\n if node_type == RelayLexer.BOOL_LIT:\n if node_text == \"True\":\n return True\n if node_text == \"False\":\n return False\n raise ParseError(\"Unrecognized BOOL_LIT: `{}`\".format(node_text))\n\n raise ParseError(\"todo: {}\".format(node_text))","def BuildTerm(self, p_node):\n\n max_comment_length = 60\n access_pn=Tree('access-policy ' + self.term.name )\n access_pn.AddParent(p_node)\n if self.verbose and self.term.comment:\n if len(self.term.comment[0]) < max_comment_length:\n comm=Tree('', '/* ' + self.term.comment[0] + ' */')\n else:\n comments = aclgenerator.WrapWords(self.term.comment, 60)\n comments.append( '*/')\n comments.insert(0, '/*')\n comm=Tree('', comments)\n comm.AddParent(access_pn)\n\n rule_match =Tree('match')\n rule_match.AddParent(access_pn)\n\n if self.from_zone:\n self.BuildTermZone(rule_match, 'src')\n\n if self.to_zone:\n self.BuildTermZone(rule_match, 'dest')\n\n if self.term.versa_application or self.app:\n self.BuildTermApp(rule_match)\n\n if self.term.dscp_match:\n self.BuildTermDscp(rule_match)\n\n if self.term.action:\n self.BuildTermLogging(access_pn)\n\n #print(\"\\n\".join(set_term.PrintTree()))","def tree(string, token=[WORD, POS, CHUNK, PNP, REL, ANCHOR, LEMMA]):\n return Text(string, token)","def term(self):\n initial_pos = self.pos\n\n # Match an integer constant.\n # Convert from C-style literals to Python integers.\n try:\n constant = self.match_type(NumericalConstant)\n\n # Use prefix (if present) to determine base\n base = 10\n bases = {\"0x\": 16, \"0X\": 16, \"0b\": 2, \"0B\": 2}\n try:\n prefix = constant.token[0:2]\n base = bases[prefix]\n value = constant.token[2:]\n except KeyError:\n value = constant.token\n\n # Strip suffix (if present)\n suffix = None\n suffixes = ['ull', 'ULL', 'ul', 'UL', 'll', 'LL', 'u', 'U', 'l', 'L']\n for s in suffixes:\n if value.endswith(s):\n suffix = s\n value = value[:-len(s)]\n break\n\n # Convert to decimal and then to integer with correct sign\n # Preprocessor always uses 64-bit arithmetic!\n int_value = int(value, base)\n if suffix and 'u' in suffix:\n return np.uint64(int_value)\n else:\n return np.int64(int_value)\n except ParseError:\n self.pos = initial_pos\n\n # Match a character constant.\n # Convert from character literals to integer value.\n try:\n constant = self.match_type(CharacterConstant)\n return np.int64(ord(constant.token))\n except ParseError:\n self.pos = initial_pos\n\n # Match a function call.\n try:\n return self.call()\n except ParseError:\n self.pos = initial_pos\n\n # Match an identifier.\n # Any identifier that still exists after substitution evaluates\n # to false\n try:\n self.match_type(Identifier)\n return np.int64(0)\n except ParseError:\n self.pos = initial_pos\n\n raise ParseError(\n \"Expected an integer constant, character constant, identifier or function call.\")","def expression_to_english_tree(expr):\n if isinstance(expr, ApplicationExpression):\n pred_name = expr.pred.variable.name\n if (not (pred_name in (adjectives + intransitive_verbs + transitive_verbs))):\n raise GenerationError(\"Invalid predicate: %s\" % pred_name)\n # might want to add a line enforcing variable name to begin with an x, y, or z?\n freevars = [Trace(Index(int(arg.variable.name[1:])), False) for arg in expr.args]\n if (pred_name in adjectives):\n tree = SynTree(default_featstructs['TP'], [SynTree(default_featstructs['DP_trace'], [SynTree(freevars[0], [])]), SynTree(default_featstructs['TBar'], [SynTree(default_featstructs['VP'], [SynTree(default_featstructs['VBar'], [SynTree(default_featstructs['V_link'], [SynTree('BE', [])]), SynTree(default_featstructs['AdjP'], [SynTree(default_featstructs['AdjBar'], [SynTree(default_featstructs['Adj'], [SynTree(pred_name, [])])])])])])])])\n elif (pred_name in intransitive_verbs):\n tree = SynTree(default_featstructs['TP'], [SynTree(default_featstructs['DP_trace'], [SynTree(freevars[0], [])]), SynTree(default_featstructs['TBar'], [SynTree(default_featstructs['VP'], [SynTree(default_featstructs['VBar'], [SynTree(default_featstructs['V_intrans'], [SynTree(pred_name, [])])])])])])\n else:\n tree = SynTree(default_featstructs['TP'], [SynTree(default_featstructs['DP_trace'], [SynTree(freevars[1], [])]), SynTree(default_featstructs['TBar'], [SynTree(default_featstructs['VP'], [SynTree(default_featstructs['VBar'], [SynTree(default_featstructs['V_trans'], [SynTree(pred_name, [])]), SynTree(default_featstructs['DP_trace'], [SynTree(freevars[0], [])])])])])])\n elif isinstance(expr, EqualityExpression):\n freevars = [Trace(Index(int(arg.variable.name[1:])), False) for arg in [expr.first, expr.second]]\n tree = SynTree(default_featstructs['TP'], [SynTree(default_featstructs['DP_trace'], [SynTree(freevars[0], [])]), SynTree(default_featstructs['TBar'], [SynTree(default_featstructs['VP'], [SynTree(default_featstructs['VBar'], [SynTree(default_featstructs['V_link'], [SynTree('BE', [])]), SynTree(default_featstructs['DP_trace'], [SynTree(freevars[1], [])])])])])])\n elif isinstance(expr, NLQuantifiedExpression):\n nucleus_tree = expression_to_english_tree(expr.nucleus)\n DPs = nucleus_tree.postorder_traverse(get_free_trace_DP, {'DPs' : []})['DPs']\n if (len(DPs) == 0):\n raise GenerationError(\"Quantifier %s must bind a free variable.\" % expr.getQuantifier())\n subj_tree = expression_to_english_DP_tree(expr.getQuantifier(), expr.restrictor)\n tree = SynTree(default_featstructs['TP'], [subj_tree, SynTree(default_featstructs['PA'], [SynTree(Index(-1), []), nucleus_tree])])\n for DP in DPs:\n if (int(expr.variable.name[1:]) == DP.children[0].label.index.index): # check that variables match\n tree[1][0].label = DP.children[0].label.index = tree[0].ID\n DP.children[0].label.bound = True # quantifier has bound the free variable\n break\n if (tree[1][0].label.index == -1):\n raise GenerationError(\"Quantifier %s failed to find corresponding free variable.\" % expr.getQuantifier())\n else:\n raise GenerationError(\"Invalid expression.\")\n tree.set_QR_level(1)\n tree.label_nodes()\n tree.make_nx_tree()\n return tree","def test_literal():\n token = Token(\"h\", TokenInfo(\"<stdin>\", 0, 1, \"he\"))\n assert token.info.offset == 1\n assert token.info.filename == \"<stdin>\"\n assert token.lexeme == \"h\"\n assert token.info.lineno == 0\n assert token.symbol == Literal.STRING\n assert token.info.line == \"he\"\n\n token += 'e'\n assert token.info.offset == 1\n assert token.info.filename == \"<stdin>\"\n assert token.lexeme == \"he\"\n assert token.info.lineno == 0\n assert token.symbol == Literal.STRING\n assert token.info.line == \"he\"\n\n token = Token(\"_\", TokenInfo(\"<stdin>\", 0, 1, \"_e_12__\"))\n assert token.info.offset == 1\n assert token.info.filename == \"<stdin>\"\n assert token.lexeme == \"_\"\n assert token.info.lineno == 0\n assert token.symbol == Literal.STRING\n assert token.info.line == \"_e_12__\"\n\n token += 'e'\n assert token.info.offset == 1\n assert token.info.filename == \"<stdin>\"\n assert token.lexeme == \"_e\"\n assert token.info.lineno == 0\n assert token.symbol == Literal.STRING\n assert token.info.line == \"_e_12__\"\n\n token += '_'\n assert token.info.offset == 1\n assert token.info.filename == \"<stdin>\"\n assert token.lexeme == \"_e_\"\n assert token.info.lineno == 0\n assert token.symbol == Literal.STRING\n assert token.info.line == \"_e_12__\"\n\n token += '1'\n assert token.info.offset == 1\n assert token.info.filename == \"<stdin>\"\n assert token.lexeme == \"_e_1\"\n assert token.info.lineno == 0\n assert token.symbol == Literal.STRING\n assert token.info.line == \"_e_12__\"\n\n token += '2'\n assert token.info.offset == 1\n assert token.info.filename == \"<stdin>\"\n assert token.lexeme == \"_e_12\"\n assert token.info.lineno == 0\n assert token.symbol == Literal.STRING\n assert token.info.line == \"_e_12__\"\n\n token += '_'\n assert token.info.offset == 1\n assert token.info.filename == \"<stdin>\"\n assert token.lexeme == \"_e_12_\"\n assert token.info.lineno == 0\n assert token.symbol == Literal.STRING\n assert token.info.line == \"_e_12__\"\n\n token += '_'\n assert token.info.offset == 1\n assert token.info.filename == \"<stdin>\"\n assert token.lexeme == \"_e_12__\"\n assert token.info.lineno == 0\n assert token.symbol == Literal.STRING\n assert token.info.line == \"_e_12__\"\n\n token = Token(\"h\", TokenInfo(\"<stdin>\", 0, 1, \"h+\"))\n assert token.info.offset == 1\n assert token.info.filename == \"<stdin>\"\n assert token.lexeme == \"h\"\n assert token.info.lineno == 0\n assert token.symbol == Literal.STRING\n assert token.info.line == \"h+\"\n\n with pytest.raises(LythSyntaxError) as err:\n token += \"+\"\n\n assert token.lexeme == \"h\"\n assert err.value.msg is LythError.MISSING_SPACE_BEFORE_OPERATOR\n assert err.value.filename == \"<stdin>\"\n assert err.value.lineno == 0\n assert err.value.offset == 1\n assert err.value.line == \"h+\"\n\n token = Token(\"_\", TokenInfo(\"<stdin>\", 0, 1, \"_+\"))\n assert token.info.offset == 1\n assert token.info.filename == \"<stdin>\"\n assert token.lexeme == \"_\"\n assert token.info.lineno == 0\n assert token.symbol == Literal.STRING\n assert token.info.line == \"_+\"\n\n with pytest.raises(LythSyntaxError) as err:\n token += \"+\"\n\n assert token.lexeme == \"_\"\n assert err.value.msg is LythError.MISSING_SPACE_BEFORE_OPERATOR\n assert err.value.filename == \"<stdin>\"\n assert err.value.lineno == 0\n assert err.value.offset == 1\n assert err.value.line == \"_+\"\n\n token = Token(\"_\", TokenInfo(\"<stdin>\", 0, 1, \"_1+\"))\n assert token.info.offset == 1\n assert token.info.filename == \"<stdin>\"\n assert token.lexeme == \"_\"\n assert token.info.lineno == 0\n assert token.symbol == Literal.STRING\n assert token.info.line == \"_1+\"\n\n token += \"1\"\n assert token.info.offset == 1\n assert token.info.filename == \"<stdin>\"\n assert token.lexeme == \"_1\"\n assert token.info.lineno == 0\n assert token.symbol == Literal.STRING\n assert token.info.line == \"_1+\"\n\n with pytest.raises(LythSyntaxError) as err:\n token += \"+\"\n\n assert token.lexeme == \"_1\"\n assert err.value.msg is LythError.MISSING_SPACE_BEFORE_OPERATOR\n assert err.value.filename == \"<stdin>\"\n assert err.value.lineno == 0\n assert err.value.offset == 1\n assert err.value.line == \"_1+\"","def _build_term_op_(term, state_array, int_state_array, sorting_indices):\n\n space_size = state_array.shape[0]\n\n needs_to_be_occupied = []\n needs_to_be_unoccupied = []\n\n # We keep track of the number of creation and annihilation operators and\n # ensure that there are an equal number of them in order to help detect\n # invalid inputs.\n delta = 0\n for index, op_type in reversed(term):\n if op_type == 0:\n needs_to_be_occupied.append(index)\n delta -= 1\n else:\n if index not in needs_to_be_occupied:\n needs_to_be_unoccupied.append(index)\n delta += 1\n\n if delta != 0:\n raise ValueError(\n \"The supplied operator doesn't preserve particle number\")\n\n # We search for every state which has the necessary orbitals occupied and\n # unoccupied in order to not be immediately zeroed out based on the\n # creation and annihilation operators specified in term.\n maybe_valid_states = numpy.where(\n numpy.logical_and(\n numpy.all(state_array[:, needs_to_be_occupied], axis=1),\n numpy.logical_not(\n numpy.any(state_array[:, needs_to_be_unoccupied], axis=1))))[0]\n\n data = []\n row_ind = []\n col_ind = []\n shape = (space_size, space_size)\n\n # For each state that is not immediately zeroed out by the action of our\n # operator we check to see if the determinant which this state gets mapped\n # to is in the space we are considering.\n # Note that a failure to find any state does not necessarily indicate that\n # term specifies an invalid operator. For example, if we are restricting\n # ourselves to double excitations from a fixed reference state then the\n # action of term on some of our basis states may lead to determinants with\n # more than two excitations from the reference. These more than double\n # excited determinants are not included in the matrix representation (and\n # hence, will not be present in state_array).\n for _, state in enumerate(maybe_valid_states):\n determinant = state_array[state, :]\n target_determinant = determinant.copy()\n\n parity = 1\n for i, _ in reversed(term):\n area_to_check = target_determinant[0:i]\n parity *= (-1)**numpy.sum(area_to_check)\n\n target_determinant[i] = not target_determinant[i]\n\n int_encoding = target_determinant.dot(\n 1 << numpy.arange(target_determinant.size)[::-1])\n\n target_state_index_sorted = numpy.searchsorted(int_state_array,\n int_encoding,\n sorter=sorting_indices)\n\n target_state = sorting_indices[target_state_index_sorted]\n\n if int_state_array[target_state] == int_encoding:\n # Then target state is in the space considered:\n data.append(parity)\n row_ind.append(target_state)\n col_ind.append(state)\n\n data = numpy.asarray(data)\n row_ind = numpy.asarray(row_ind)\n col_ind = numpy.asarray(col_ind)\n\n term_op = scipy.sparse.csc_matrix((data, (row_ind, col_ind)), shape=shape)\n\n return term_op","def _parse_TF(token):\n if token and token.lower() in ('true', 't', 'on', 'yes', '1'):\n return True\n elif token and token.lower() in ('false', 'f', 'off', 'no', '0'):\n return False\n else:\n raise SyntaxError('invalid value')","def parse_let(self, words):\n\n let_obj = Let()\n obj_var = self.prim_parser.parse_var(words[0])\n if obj_var:\n let_obj.var = obj_var\n if words[1] == '=':\n rest = words[2:]\n rest_str = ' '.join(words[2:])\n arith_expr_obj = self.prim_parser.parse_arith_expr(rest_str)\n prim_obj = self.prim_parser.parse_primative_obj(rest_str)\n\n if arith_expr_obj:\n let_obj.value = arith_expr_obj\n elif prim_obj:\n let_obj.value = prim_obj\n else:\n raise StatementParseError(\n 'Invalid args for LET {0} = {1}'.format(\n words[0], rest))\n else:\n raise StatementParseError(\n 'Invalid syntax for LET: {0}'.format(' '.join(words)))\n else:\n raise StatementParseError(\n 'Invalid syntax for LET: {0} not variable.'.format(words[0]))\n\n return let_obj","def tag_terms(text, terms, nlp=None):\n from spacy.lang.en.stop_words import STOP_WORDS\n spacy.tokens.token.Token.set_extension('workaround', default='', force=True)\n \n HEURISTIC_TOKENS = [\"-\", \"plant\", \"substance\", \"atom\"]\n \n # default to Stanford NLP pipeline wrapped in Spacy\n if nlp is None:\n snlp = stanfordnlp.Pipeline(lang=\"en\")\n nlp = StanfordNLPLanguage(snlp)\n \n # preprocess with spacy if needed\n if type(terms[0]) != spacy.tokens.doc.Doc:\n terms = [nlp(term) for term in terms]\n if (type(text) != spacy.tokens.doc.Doc and type(text) != spacy.tokens.span.Span):\n text = nlp(text)\n \n # set up a custom representation of the text where we can add term type annotations\n for token in text:\n token._.workaround = token.text_with_ws\n\n lemmatized_text = [token.lemma_ for token in text]\n tokenized_text = [token.text for token in text]\n tags = ['O'] * len(text)\n found_terms = defaultdict(lambda: {\"text\": [], \"indices\": [], \"pos\": [], \"type\": []})\n \n # iterate through terms from longest to shortest\n terms = sorted(terms, key=len)[::-1]\n for spacy_term in terms:\n term_length = len(spacy_term)\n lemma_term_list = [token.lemma_ for token in spacy_term]\n text_term_list = [token.text for token in spacy_term]\n term_lemma = \" \".join(lemma_term_list)\n \n # skip short acronyms that can cause problems\n if len(term_lemma) <= 2:\n continue\n \n # additional check to check for simple plural of uncommon biology terms\n match_uncommon_plural = lemma_term_list.copy()\n match_uncommon_plural[-1] = match_uncommon_plural[-1] + \"s\"\n\n # additional check using heuristics on lemmatized version\n match_heuristic = []\n if lemma_term_list[0] not in HEURISTIC_TOKENS:\n for token in lemma_term_list:\n if token not in HEURISTIC_TOKENS:\n match_heuristic += token.split(\"-\")\n heuristic_length = len(match_heuristic)\n else:\n heuristic_term = lemma_term_list\n heuristic_length = len(lemma_term_list)\n \n for ix in range(len(text) - term_length):\n \n heuristic_match = (lemmatized_text[ix:ix + heuristic_length] == match_heuristic)\n plural_match = (lemmatized_text[ix:ix + term_length] == match_uncommon_plural)\n lemma_match = (lemmatized_text[ix:ix + term_length] == lemma_term_list)\n text_match = (tokenized_text[ix:ix + term_length] == text_term_list)\n lower_match = ([t.lower() for t in tokenized_text[ix:ix + term_length]] ==\n [t.lower() for t in text_term_list])\n \n # Only match on text if lemmatized version is a stop word (i.e. lower casing acronym)\n if term_lemma in STOP_WORDS:\n valid_match = text_match\n else:\n valid_match = heuristic_match or plural_match or text_match or lemma_match or lower_match\n \n if valid_match:\n \n if heuristic_match and not lemma_match:\n match_length = heuristic_length\n else:\n match_length = term_length\n \n term_text = \" \".join([t.text for t in text[ix:ix + match_length]])\n term_tag = \" \".join([t.tag_ for t in text[ix:ix + match_length]])\n \n # only tag term if not part of larger term\n if tags[ix:ix + match_length] == [\"O\"] * match_length:\n \n # classify term type\n term_type = determine_term_type(spacy_term)\n \n # collect term information\n found_terms[term_lemma][\"text\"].append(term_text)\n found_terms[term_lemma][\"indices\"].append((ix, ix + match_length))\n found_terms[term_lemma][\"pos\"].append(term_tag)\n found_terms[term_lemma][\"type\"].append(term_type)\n \n # update sentence tags\n tags = tag_bioes(tags, ix, match_length)\n \n # annotate token representations with term type\n text[ix]._.workaround = f\"<{term_type}>\" + text[ix]._.workaround\n end_ix = ix + match_length - 1\n if text[end_ix]._.workaround.endswith(\" \"):\n text[end_ix]._.workaround = text[end_ix]._.workaround[:-1] + f\"</{term_type}> \"\n else:\n text[end_ix]._.workaround += f\"</{term_type}>\"\n \n # reconstruct fully annotated input text\n annotated_text = \"\"\n for token in text:\n annotated_text += token._.workaround\n \n return {\n \"tokenized_text\": tokenized_text, \n \"tags\": tags, \n \"annotated_text\": annotated_text,\n \"found_terms\": dict(found_terms)\n }","def __init__(\n self, \n *, \n polars_term = None, \n is_literal: bool = False,\n is_column: bool = False,\n is_series: bool = False,\n lit_value = None,\n ) -> None:\n assert isinstance(is_literal, bool)\n assert isinstance(is_column, bool)\n assert isinstance(is_series, bool)\n assert (is_literal + is_column + is_series) <= 1\n if lit_value is not None:\n assert is_literal\n self.lit_value = lit_value\n self.polars_term = polars_term\n self.is_literal = is_literal\n self.is_column = is_column\n self.is_series = is_series","def testTermInstantiation(self):\n \n action = Parser.parse_as(normalized_drive.split(\"\\n\"), Action, self.domain)\n term = Builder(action)(\"location-of\", \"?t\")\n action.instantiate({\"?from\" : term})\n pre2 = action.precondition.copy(copy_instance=True)\n self.assertEqual(pre2.pddl_str(), \"(and (= (location-of ?t) (location-of ?t)) (= (city-of (location-of ?t)) ?c) (= (city-of ?to) ?c))\")\n action.uninstantiate()","def _create_next_term(cls,\n context: 'IconScoreContext',\n prev_term: Optional['Term']) -> 'Term':\n new_preps: List['PRep'] = context.preps.get_preps(\n start_index=0, size=context.main_and_sub_prep_count)\n\n sequence = 0 if prev_term is None else prev_term.sequence + 1\n start_block_height = context.block.height + 1\n if prev_term:\n assert start_block_height == prev_term.end_block_height + 1\n\n # The current P-Rep term is over. Prepare the next P-Rep term\n if context.revision < Revision.SET_IREP_VIA_NETWORK_PROPOSAL.value:\n irep: int = cls._calculate_weighted_average_of_irep(new_preps[:context.main_prep_count])\n else:\n irep: int = context.inv_container.irep\n\n term = Term(\n sequence,\n start_block_height,\n context.term_period,\n irep,\n context.total_supply,\n context.preps.total_delegated\n )\n\n term.set_preps(new_preps, context.main_prep_count, context.main_and_sub_prep_count)\n\n return term","def create_operator(statement_a, operator, statement_b):\n return S(statement_a=statement_a, operator=operator, statement_b=statement_b)","def is_lval(t):\n if not t:\n return False\n i = iter(t)\n if i.next() not in IDENTIFIER_START:\n return False\n return all(e in IDENTIFIER_PART for e in i)","def from_string(cls, compound_term_string):\n compound_term_string = compound_term_string.replace(\" \", \"\")\n subterms, connector, intervals = cls.parse_toplevel_subterms_and_connector(compound_term_string)\n return cls(subterms, connector,intervals=intervals)","def AddTreeTerm(con, cur, termid, parentid, ontologynameid, commit=True):\n try:\n # test if already exists\n cur.execute('SELECT uniqueId FROM OntologyTreeStructureTable WHERE (ontologyId=%s AND ontologyParentId=%s AND ontologyNameId=%s) LIMIT 1', [termid, parentid, ontologynameid])\n if cur.rowcount > 0:\n sid = cur.fetchone()[0]\n debug(2, 'Tree entry exists (%d). returning it' % sid)\n return '', sid\n # does not exist - lets add it\n cur.execute('INSERT INTO OntologyTreeStructureTable (ontologyId,ontologyParentId,ontologyNameId) VALUES (%s,%s,%s) RETURNING uniqueId', [termid, parentid, ontologynameid])\n sid = cur.fetchone()[0]\n return '', sid\n except psycopg2.DatabaseError as e:\n debug(7, \"error %s enountered in ontology.AddTreeTerm\" % e)\n return \"error %s enountered in ontology.AddTreeTerm\" % e, -2","def parseTerms(cmds):\n if len(cmds) != 0:\n print(\"Term\")\n delimit = \"[*|/|%]+\"\n factors = re.split(delimit, cmds[0])\n parseFactors(cmds[0])\n parseTerms(cmds[1:])","def test_build_from_info():\n terms = [Intercept(),\n LinearTerm(0),\n SplineTerm(0),\n FactorTerm(0),\n TensorTerm(0,1)]\n\n for term in terms:\n assert Term.build_from_info(term.info) == term\n\n assert te(0, 1) == TensorTerm(SplineTerm(0, n_splines=10), SplineTerm(1, n_splines=10))","def parse(seq):\n\tdef eval_expr(z, list):\n\t\treturn reduce(lambda s, (f, x): f(s, x), list, z)\n\tunarg = lambda f: lambda x: f(*x)\n\tconst = lambda x: lambda _: x # like ^^^ in Scala\n\n\ttokval = lambda x: x.value # returns the value of a token\n\top = lambda s: a(Token('Op', s)) >> tokval # return the value if token is Op\n\top_ = lambda s: skip(op(s)) # checks if token is Op and ignores it\n\ttoktype = lambda t: some(lambda x: x.type == t) >> tokval # checks type of token\n\tdef lst(h,t):\n\t\treturn [h,] + t\n\tcall = lambda x: Call(x[0], x[1])\n\n\tmakeop = lambda s, f: op(s) >> const(f)\n\n\tadd = makeop('+', Plus)\n\tsub = makeop('-', Minus)\n\tmul = makeop('*', Times)\n\tdiv = makeop('/', Div)\n\n\tdef make_const(i):\n\t\treturn const(int(i))\n\n\tnumber = toktype('Number') >> Const\n\n\tmul_op = mul | div\n\tadd_op = add | sub\n\n\tfactor = with_forward_decls(lambda:\n\t\tnumber | op_('(') + exp + op_(')') | call)\n\tterm = factor + many(mul_op + factor) >> unarg(eval_expr)\n\texp = term + many(add_op + term) >> unarg(eval_expr)\n\texp_lst = with_forward_decls(lambda:\n\t\texp + many(op_(',') + exp) >> unarg(lst))\n\tcall = toktype('Name') + op_('(') + exp_lst + op_(')') >> call\n\n\treturn exp.parse(seq)","def andExpr( ): #DOUBLE CHECK THIS\n\n\ttok = tokens.peek( )\n\tif debug: print(\"andExpr: \", tok)\n\tleft = relationalExpr( ) #does the left side of the grammar\n\ttok = tokens.peek( )\n\twhile tok == \"and\": #checks to see if there is the token \"and\" and will preform what is inside the curly bracket since it is a series \n\t\ttokens.next()\n\t\tright = relationalExpr( )\n\t\tleft = BinaryExpr(tok, left, right)#MIGHT HAVE TO CHANGE TO STRING \n\t\ttok = tokens.peek( )\n\treturn left","def _eval_atom(self, vars, word):\n if word == \"null\":\n return None\n elif word == \"true\":\n return True\n elif word == \"false\":\n return False\n elif word.startswith(\"$\"):\n return vars[word[1:]]\n (instr, arg) = word.split(\":\")\n if instr == \"int\":\n return int(arg)\n elif instr == \"float\":\n return float(arg)\n elif instr == \"id\":\n return uuid.UUID(arg.zfill(32))\n elif instr == \"blob\":\n return bytearray.fromhex(arg)\n elif instr == \"str\":\n return arg\n else:\n raise NotAnAtom()","def _parse_token(token: str):\r\n if token in OPERATOR_TOKENS:\r\n return Operator(token)\r\n if token.isdigit():\r\n return Number(int(token))\r\n if \".\" in token:\r\n if token.count(\".\") > 1 or token[-1] == '.':\r\n raise BadNumber(token)\r\n return Number(float(token))\r\n if token == \"i\":\r\n return ComplexNumber(0, 1)\r\n if token.isalpha():\r\n return Variable(token)\r\n raise UnknownToken(token)","def normalize(term):\n if isinstance(term, spacy.tokens.token.Token):\n return term.text if term.pos_ == 'PROPN' else term.lemma_\n elif isinstance(term, spacy.tokens.span.Span):\n return ' '.join(word.text if word.pos_ == 'PROPN' else word.lemma_\n for word in term)\n else:\n msg = \"Normalization requires a Token or Span, not {}.\".format(type(term))\n raise TypeError(msg)","def tf(term, document, algorithm=\"RAW\"):\n\n if algorithm == \"RAW\":\n return tf_raw(term, document)\n elif algorithm == \"BOOL\":\n return tf_bool(term, document)\n elif algorithm == \"LOG\":\n return tf_log(term, document)\n else:\n raise ValueError(\"tf cannot use algorithm %s\" % algorithm)","def _digest_atom(raw_token: RawToken) -> Token:\n\n # Is this a preposition\n try:\n return Token(\n kind=TokenKind.PREPOSITION,\n value=Preposition(raw_token.value),\n location=raw_token.location,\n )\n except ValueError:\n pass\n\n # Is this an integer value?\n try:\n return Token(\n kind=TokenKind.NUMBER,\n value=int(raw_token.value),\n location=raw_token.location,\n )\n except ValueError:\n pass\n\n # A float?\n try:\n return Token(\n kind=TokenKind.NUMBER,\n value=float(raw_token.value),\n location=raw_token.location,\n )\n except ValueError:\n pass\n\n # A duration?\n duration_match = RE_DURATION.match(raw_token.value)\n if duration_match is not None:\n total_length = (\n int(duration_match.group(1) or '0') * 24 * 60 * 60 +\n int(duration_match.group(2) or '0') * 60 * 60 +\n int(duration_match.group(3) or '0') * 60 +\n int(duration_match.group(4) or '0')\n )\n return Token(\n kind=TokenKind.DURATION,\n value=total_length,\n location=raw_token.location,\n )\n\n # A literal?\n try:\n kind, value = LITERALS[raw_token.value]\n return Token(\n kind=kind,\n value=value,\n location=raw_token.location,\n )\n except KeyError:\n pass\n\n # Pass through, split by dots\n return Token(\n kind=TokenKind.ATOM,\n value=raw_token.value.split('.'),\n location=raw_token.location,\n )","def potential_multi_term(tagged) :\n res = True\n for tag in tagged :\n res = res and stemgrammar(tag)\n return res","def from_string_expr(cls, expr):\n if \"*\" in expr:\n ch = \"*\"\n op = \"cross\"\n elif \"+\" in expr:\n ch = \"+\"\n op = \"blend\"\n elif \"/\" in expr:\n ch = \"/\"\n op = \"nest\"\n factors = [cls(s.strip()) for s in expr.split(ch)]\n return cls(op=op, factors=factors)","def terminal_node(\n self,\n expr: Any = None,\n ) -> None:\n self.data.append(\n {\n \"type\": \"TERMINAL\",\n \"expr\": expr,\n \"id\": len(\n self.data,\n ),\n }\n )","def get_american_term_definition(word: str) -> str:\n word = process_word(word)\n return AMERICAN_ENGLISH_ONLY_TERMS[word]","def parse_go_term(term):\n\n id_pattern = re.compile(r\"^id:\\s+(GO:[0-9]+)\\s+\", re.M)\n is_a_pattern = re.compile(r\"^is_a:\\s+(.*?) !\", re.M)\n\n id_parse = re.findall(id_pattern, term)\n is_a_parse = re.findall(is_a_pattern, term)\n\n return id_parse, is_a_parse","def var_or_atomic():\n return (var() | atomic()).expect('var_or_atomic')","def literal(self, tree: lark.Tree) -> Result:\n if len(tree.children) != 1:\n raise CELSyntaxError(\n f\"{tree.data} {tree.children}: bad literal node\",\n line=tree.meta.line,\n column=tree.meta.column,\n\n )\n value_token = cast(lark.Token, tree.children[0])\n try:\n result: Result\n if value_token.type == \"FLOAT_LIT\":\n result = celpy.celtypes.DoubleType(value_token.value)\n elif value_token.type == \"INT_LIT\":\n result = celpy.celtypes.IntType(value_token.value)\n elif value_token.type == \"UINT_LIT\":\n if not value_token.value[-1].lower() == 'u':\n raise CELSyntaxError(\n f\"invalid unsigned int literal {value_token!r}\",\n line=tree.meta.line,\n column=tree.meta.column,\n )\n result = celpy.celtypes.UintType(value_token.value[:-1])\n elif value_token.type in (\"MLSTRING_LIT\", \"STRING_LIT\"):\n result = celstr(value_token)\n elif value_token.type == \"BYTES_LIT\":\n result = celbytes(value_token)\n elif value_token.type == \"BOOL_LIT\":\n result = (\n celpy.celtypes.BoolType(value_token.value.lower() == \"true\")\n )\n elif value_token.type == \"NULL_LIT\":\n result = None\n else:\n raise CELUnsupportedError(\n f\"{tree.data} {tree.children}: type not implemented\",\n line=value_token.line,\n column=value_token.column,\n )\n except ValueError as ex:\n result = CELEvalError(ex.args[0], ex.__class__, ex.args, tree=tree)\n\n return result","def __init__(self, term=None, coefficient=1.0):\n self.terms = {}\n if term is not None:\n term, parity = _sort_majorana_term(term)\n self.terms[term] = coefficient * (-1)**parity","def makeShellType(tag, keyword, G):\n sid = G(\"%sID\" % keyword)\n string = \"<%s\" % tag\n if sid:\n string += ' shellid\"=%s-%s\"' % (NODEID, sid)\n string += \">\"\n string += \"<PrincipalQuantumNumber>%s</PrincipalQuantumNumber>\" % G(\"%sPrincipalQN\" % keyword)\n\n string += \"<OrbitalAngularMomentum>\"\n string += \"<Value>%s</Value>\" % G(\"%sOrbitalAngMom\" % keyword)\n symb = G(\"%sOrbitalAngMomSymbol\" % keyword)\n if symb:\n string += \"<Symbol>%s</Symbol>\" % symb\n string += \"</OrbitalAngularMomentum>\"\n string += \"<NumberOfElectrons>%s</NumberOfElectrons>\" % G(\"%sNumberOfElectrons\" % keyword)\n string += \"<Parity>%s</Parity>\" % G(\"%sParity\" % keyword)\n string += \"<Kappa>%s</Kappa>\" % G(\"%sKappa\" % keyword)\n string += \"<TotalAngularMomentum>%s</TotalAngularMomentum>\" % G(\"%sTotalAngularMomentum\" % keyword)\n string += makeTermType(\"ShellTerm\", \"%sTerm\" % keyword, G)\n string += \"</%s>\" % keyword\n return string","def tokenize(eq):\n\n def push(token):\n if token != \"\":\n if token[0].isdigit():\n tokens.append(int(token))\n else:\n tokens.append(token)\n\n tokens = []\n token = \"\"\n\n for t in eq:\n if t == \" \":\n push(token)\n token = \"\"\n if t == \"+\" or t == \"*\" or t == \"(\" or t == \")\":\n push(token)\n push(t)\n token = \"\"\n elif t.isdigit():\n token += t\n\n push(token)\n return tokens","def _simpl_pono_term(term: Term, resolvers) -> Term:\n\n sums_dict = dict(term.sums)\n other, wigner_3js = _parse_3js(term.amp)\n jms, rels = _get_jms_rels(wigner_3js)\n\n new_other = _simpl_pono(\n other, resolvers, sums_dict, jms, rels, sums_only=False\n )\n\n new_amp = new_other * prod_(\n i.expr for i in wigner_3js\n )\n\n return Term(term.sums, new_amp, term.vecs)","def create_expression(sv, tree): \r\n if not tree: return None # nothing to do\r\n o,A,B=tree\r\n\r\n if o==Obr: # bracketed expression: remove brackets \r\n return create_expression(sv, A) # RECURSIVE\r\n\r\n nam=tree_join(tree)\r\n verify_expression(tree, nam) # check name validity \r\n\r\n if nam in sv.Object and not sv.Object[nam].isnew: # don't replace existing name unless new user call\r\n nod=sv.Object[nam] # use old name \r\n return (nam, None, None) # replace expression with name \r\n \r\n nod=add_object(sv, nam) # create object (unless new user call)\r\n nod.isexpression=True\r\n nod.isnew=False # process only once\r\n \r\n # link expression (only for new nodes)\r\n if o==Comma: # special case: list: clause for each changing element\r\n li=[]\r\n for t in A:\r\n exprs=create_expression(sv, t) # RECURSIVE\r\n if exprs: li=li+[exprs]\r\n vlu=(Comma, li, None) # list of elements \r\n nod.clauses=[(Starttree,vlu)] # start clause for whole list ((Start, None, None), (Comma, li, None)) \r\n for t in li: # each term is a triplet\r\n if t and not is_fixed(t[0]):\r\n add_change_clause(sv, nod, t, vlu)\r\n\r\n return (nam, None, None) # name for the list\r\n\r\n # some sort of expression except a list\r\n exprsA=create_expression(sv, A)\r\n exprsB=create_expression(sv, B)\r\n vlu=(o, exprsA, exprsB) # reduce to a simple operation between two expressions \r\n\r\n # make start clauses, and change clause for non-fixed objects (do not repeat 'change')\r\n nod.clauses=[(Starttree, vlu)] # ((Start, None, None), vlu) \r\n if o in sv.Object and not is_fixed(o):\r\n add_change_clause(sv, nod, (o, None, None), vlu)\r\n if A and not is_fixed(A[0]):\r\n add_change_clause(sv, nod, exprsA, vlu)\r\n if B and B!=A and not is_fixed(B[0]):\r\n add_change_clause(sv, nod, exprsB, vlu)\r\n \r\n if o==Since: # special case: conditions for \"since\" \r\n pl=create_expression(sv, (Plus, exprsB, exprsA)) # RECURSIVE \r\n nod.clauses[-1]=((Change, pl, None), vlu) # when change(event+delay): (Since, exprsA, exprsB) \r\n add_change_clause(sv, nod, exprsB, vlu) # when change(event)...\r\n # n.b. changing delay during 'since' should have no effect\r\n \r\n return (nam, None, None) # replace expression with name \r","def create_equation(expr: Expr, var: Expr) -> Eq:\n factor = Mul(\n *(arg for arg in expr.args if isinstance(arg, Rational) or isinstance(arg, Pow))\n )\n\n lhs = (expr / factor).subs({x3: x3_val})\n rhs = (lmbda * var / factor).subs({x3: x3_val})\n\n return Eq(lhs, rhs)","def getAtom(t, swipl):\n return Atom.fromTerm(t, swipl)"],"string":"[\n \"def parse_term(s, ctx, mctx, ops):\\n s = strip_parens(s.strip())\\n if re.search(\\\"^\\\\w*$\\\",s): # If a single word, either a variable or a constant\\n if s in ops:\\n return Con(ops[s], [], ctx, mctx)\\n elif s in ctx:\\n return Var(s, ctx, mctx)\\n elif s in mctx:\\n return MVar(s, [], ctx, mctx)\\n elif s.startswith(\\\"O\\\") and s[1:] in mctx:\\n return MVar(s, [], ctx, mctx, is_hole=True)\\n else:\\n raise Exception(\\\"Unbound variable: \\\" + \\\"'\\\" + s + \\\"'\\\")\\n\\n elif re.search(\\\"^\\\\w*\\\\[.*\\\\]$\\\", s): # If a metavariable\\n m = re.search(\\\"^(\\\\w)*\\\\[(.*)\\\\]$\\\", s)\\n mvar = m.group(1)\\n env = m.group(2)\\n if not env:\\n return MVar(mvar, [], ctx, mctx, is_hole=mvar.startswith(\\\"O\\\"))\\n else:\\n return MVar(mvar, [Term.parse_term(t, ctx, mctx, ops) for t in split_tuple(env)], ctx, mctx)\\n\\n elif re.search(\\\"^([\\\\w ]*)\\\\.(.*)$\\\", s): # If a variable under binders\\n m = re.search(\\\"^([\\\\w ]*)\\\\.(.*)$\\\", s)\\n bound = m.group(1).split()\\n tm = m.group(2)\\n return Term.parse_term(tm, bound + ctx, mctx, ops)\\n\\n elif re.search(\\\"^(\\\\w*) *\\\\((.*)\\\\)$\\\", s): # If an expression\\n m = re.search(\\\"^(\\\\w*) *\\\\((.*)\\\\)$\\\", s)\\n op = m.group(1)\\n args = m.group(2)\\n return Con(ops[op], [Term.parse_term(t, ctx, mctx, ops) for t in split_tuple(args)], ctx, mctx)\\n else:\\n raise Exception(\\\"Can't parse: \\\" + s)\",\n \"def convert_term(var_map, s, t):\\n def convert(t):\\n if t.head in var_map:\\n if len(t.args) == 0:\\n return s(Ident(to_binary(var_map[t.head])))\\n elif len(t.args) == 1:\\n return s(Para(Ident(to_binary(var_map[t.head])), t.arg))\\n else:\\n raise NotImplementedError\\n elif t.is_equals():\\n return Term.mk_equals(convert(t.arg1), convert(t.arg))\\n elif logic.is_neg(t):\\n return logic.neg(convert(t.arg))\\n elif logic.is_conj(t):\\n return logic.conj(convert(t.arg1), convert(t.arg))\\n elif logic.is_disj(t):\\n return logic.disj(convert(t.arg1), convert(t.arg))\\n elif t.get_type() == boolT:\\n return BoolV(t)\\n elif t.get_type() == natT:\\n return NatV(t)\\n else:\\n raise NotImplementedError\\n\\n return convert(t)\",\n \"def term( ):\\n\\n\\ttok = tokens.peek( )\\n\\tif debug: print (\\\"Term: \\\", tok)\\n\\tleft = factor( )\\n\\ttok = tokens.peek( )\\n\\twhile tok == \\\"*\\\" or tok == \\\"/\\\":\\n\\t\\ttokens.next()\\n\\t\\tright = factor( )\\n\\t\\tleft = BinaryExpr( tok, left, right )\\n\\t\\ttok = tokens.peek( )\\n\\treturn left\",\n \"def makeVarOrKeyword(it):\\n s = \\\"\\\"\\n helper = AlphabetHelper()\\n while it.hasNext():\\n c = it.peek()\\n if helper.isLiteral(c):\\n s += c\\n else:\\n break\\n it.next()\\n\\n if s in Keywords:\\n return Token(KEYWORD, s)\\n if s == \\\"true\\\" or s == \\\"false\\\":\\n return Token(BOOLEAN, s)\\n return Token(VARIABLE, s)\",\n \"def parse_term(self) -> SyntaxNode:\\n return self._parse_cat_binary(\\\"M\\\", self.parse_value)\",\n \"def Term(self, paren=False):\\n left = self.Factor()\\n while self.currtok[1].name in {\\\"TIMES\\\", \\\"DIVISION\\\", \\\"MOD\\\"}:\\n op = self.currtok[0]\\n self.currtok = next(self.tg)\\n right = self.Factor()\\n left = BinaryExpr(op, left, right, paren)\\n return left\",\n \"def compile_term(self) -> None:\\n token_type = self.tokenizer.token_type()\\n\\n if token_type == TokenTypes.IDENTIFIER:\\n curr_token = self._get_current_token()\\n self.tokenizer.advance()\\n if self._get_current_token() in ('(', '.'):\\n self.compile_subroutine_call(curr_token)\\n elif self._get_current_token() == '[':\\n self._consume('[')\\n self.compile_expression()\\n self._consume(']')\\n\\n kind = convert_kind(self.table.kind_of(curr_token))\\n index = self.table.index_of(curr_token)\\n\\n self.writer.write_push(kind, index)\\n self.writer.write_arithmetic('ADD')\\n self.writer.write_pop('POINTER', 1)\\n self.writer.write_push('THAT', 0)\\n\\n else:\\n kind = convert_kind(self.table.kind_of(curr_token))\\n index = self.table.index_of(curr_token)\\n self.writer.write_push(kind, index)\\n\\n elif token_type == token_type.INT_CONST:\\n self.writer.write_push('CONST', int(self._get_current_token()))\\n self._consume(token_type)\\n\\n elif token_type == token_type.KEYWORD:\\n curr_token = self._get_current_token()\\n if curr_token in ['true', 'false', 'null']:\\n self.writer.write_push('CONST', 0)\\n if curr_token == 'true':\\n self.writer.write_arithmetic('NOT')\\n if curr_token == 'this':\\n self.writer.write_push('POINTER', 0)\\n self._consume(token_type)\\n\\n elif token_type == token_type.STRING_CONST:\\n const_str = ''\\n first = True\\n while const_str.count('\\\"') < 2:\\n if first:\\n const_str += self._get_current_token()\\n first = False\\n else:\\n const_str += ' ' + self._get_current_token()\\n if self.tokenizer.has_more_tokens():\\n self.tokenizer.advance()\\n const_str = const_str.replace('\\\"', '')\\n\\n self.writer.write_push('CONST', len(const_str))\\n self.writer.write_call('String.new', 1)\\n\\n for char in const_str:\\n self.writer.write_push('CONST', ord(char))\\n self.writer.write_call('String.appendChar', 2)\\n\\n else:\\n if self._get_current_token() == '(':\\n self._consume('(')\\n self.compile_expression()\\n self._consume(')')\\n else:\\n op = self._get_current_token()\\n self._consume(['-', '~']) # unaryOp term\\n self.compile_term()\\n if op == '-':\\n self.writer.write_arithmetic('NEG')\\n else:\\n self.writer.write_arithmetic('NOT')\",\n \"def from_term(term):\\n if term is None:\\n return term\\n elif isinstance(term, (six.string_types, int, float)):\\n return term\\n elif isinstance(term, dict):\\n return {k: from_term(v) for k, v in term.items()}\\n elif isinstance(term, list):\\n return [from_term(t) for i, t in enumerate(term)]\\n elif issubclass(term.__class__, (Matcher,)):\\n return term.generate()\\n else:\\n raise ValueError('Unknown type: %s' % type(term))\",\n \"def compile_term(self):\\n\\n\\t\\tself.outfile.write('<term>\\\\n')\\n\\n\\t\\tcount = 0\\n\\n\\t\\twhile(self.tokenizer.get_token() not in [')',']',';',',', '/', '|', '<', '>', '=', '*', '+', '&']):\\n\\t\\t\\tif self.tokenizer.get_token().isdigit():\\n\\t\\t\\t\\tself.outfile.write(self.tokenizer.int_value())\\n\\t\\t\\telif '\\\"' in self.tokenizer.get_token():\\n\\t\\t\\t\\tself.outfile.write(self.tokenizer.str_value())\\n\\t\\t\\telif self.tokenizer.get_token() in ['true', 'false', 'null', 'this']:\\n\\t\\t\\t\\tself.outfile.write(self.tokenizer.keyword())\\n\\t\\t\\telif self.tokenizer.get_token() == '-' and count == 0:\\n\\t\\t\\t\\tself.outfile.write(self.tokenizer.symbol())\\n\\t\\t\\t\\tself.compile_term()\\n\\t\\t\\telif self.tokenizer.get_token() == '-' and count > 0:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\telif self.tokenizer.get_token() == '~':\\n\\t\\t\\t\\tself.outfile.write(self.tokenizer.symbol())\\n\\n\\t\\t\\t\\tif self.tokenizer.get_token() != '(':\\n\\t\\t\\t\\t\\tself.compile_term()\\n\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tself.outfile.write('<term>\\\\n' + self.tokenizer.symbol())\\n\\t\\t\\t\\t\\tself.compile_expression()\\n\\t\\t\\t\\t\\txml = self.tokenizer.symbol() + '</term>\\\\n'\\n\\t\\t\\t\\t\\tself.outfile.write(xml)\\n\\n\\t\\t\\telif self.tokenizer.get_token() == '(':\\n\\n\\t\\t\\t\\tself.outfile.write(self.tokenizer.symbol())\\n\\t\\t\\t\\tself.compile_expression()\\n\\t\\t\\t\\tself.outfile.write(self.tokenizer.symbol())\\n\\n\\t\\t\\telif self.tokenizer.get_token() == '[':\\n\\t\\t\\t\\txml = self.tokenizer.symbol()\\n\\t\\t\\t\\tself.outfile.write(xml)\\n\\n\\t\\t\\t\\tself.compile_expression()\\n\\n\\t\\t\\t\\tself.outfile.write(self.tokenizer.symbol())\\n\\n\\t\\t\\telif self.tokenizer.get_token() == '.':\\n\\t\\t\\t\\txml = self.tokenizer.symbol() + self.tokenizer.identifier() + self.tokenizer.symbol() + '<expressionList>\\\\n'\\n\\t\\t\\t\\tself.outfile.write(xml)\\n\\n\\t\\t\\t\\tif self.tokenizer.get_token() != ')':\\n\\t\\t\\t\\t\\tself.compile_expression_list()\\n\\n\\t\\t\\t\\tself.outfile.write('</expressionList>\\\\n' + self.tokenizer.symbol())\\n\\t\\t\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.outfile.write(self.tokenizer.identifier())\\n\\n\\t\\t\\tcount = count + 1\\n\\n\\t\\tself.outfile.write('</term>\\\\n')\\n\\n\\t\\tif self.tokenizer.get_token() in self.tokenizer._operands:\\n\\t\\t\\tif self.tokenizer.get_token() in ['<', '>', '\\\"', '&']:\\n\\t\\t\\t\\txml = '<symbol> ' + CompilationEngine._operands.get(self.tokenizer.get_token()) + ' </symbol>\\\\n'\\n\\t\\t\\t\\tself.tokenizer.advance()\\n\\t\\t\\telse:\\n\\t\\t\\t\\txml = self.tokenizer.symbol()\\n\\n\\t\\t\\tself.outfile.write(xml)\\n\\t\\t\\tself.compile_term()\",\n \"def fold_term(self, init_repr, term):\\n if isinstance(term, Var):\\n return self.var(init_repr, term.name)\\n elif isinstance(term, Const):\\n return self.const(init_repr, term.name)\\n elif isinstance(term, Dist):\\n return self.dist(init_repr, term.name)\\n elif isinstance(term, Func):\\n return self.func(\\n init_repr,\\n term.funcname,\\n [ self.fold_term(init_repr, x)\\n for x in term.args ])\\n elif isinstance(term, Eq):\\n return self.eq(\\n init_repr,\\n term.pos,\\n self.fold_term(init_repr, term.t1),\\n self.fold_term(init_repr, term.t2))\\n elif isinstance(term, Disj):\\n return self.disj(\\n init_repr,\\n term.role,\\n [ self.fold_term(init_repr, eq)\\n for eq in term.eqs ])\\n elif isinstance(term, Conj):\\n return self.conj(\\n init_repr,\\n [ self.fold_term(init_repr, disj)\\n for disj in term.disjs ])\",\n \"def parseTerm(element):\\n tag, text = element.tag, element.text\\n if tag == RESULTS_NS_ET + 'literal':\\n if text is None:\\n text = ''\\n datatype = None\\n lang = None\\n if element.get('datatype', None):\\n datatype = URIRef(element.get('datatype'))\\n elif element.get(\\\"{%s}lang\\\" % XML_NAMESPACE, None):\\n lang = element.get(\\\"{%s}lang\\\" % XML_NAMESPACE)\\n\\n ret = Literal(text, datatype=datatype, lang=lang)\\n\\n return ret\\n elif tag == RESULTS_NS_ET + 'uri':\\n return URIRef(text)\\n elif tag == RESULTS_NS_ET + 'bnode':\\n return BNode(text)\\n else:\\n raise TypeError(\\\"unknown binding type %r\\\" % element)\",\n \"def term_to_rdflib(term: str) -> Term:\\n if term.startswith('?'):\\n return Variable(term[1:])\\n elif term.startswith(\\\"\\\\\\\"\\\"):\\n return from_n3(term)\\n else:\\n return URIRef(term)\",\n \"def simplify(term):\\n simplified_term = term\\n\\n if isinstance(term,StatementTerm):\\n simplified_term = StatementTerm(subject_term=simplify(term.get_subject_term()),\\n predicate_term=simplify(term.get_predicate_term()),\\n copula=term.get_copula(),\\n interval=term.interval)\\n elif isinstance(term,CompoundTerm):\\n if term.connector == NALSyntax.TermConnector.Negation and \\\\\\n len(term.subterms) == 1 and \\\\\\n isinstance(term.subterms[0],CompoundTerm) and \\\\\\n term.subterms[0].connector == NALSyntax.TermConnector.Negation :\\n # (--,(--,(S --> P)) <====> (S --> P)\\n # Double negation theorem. 2 Negations cancel out\\n simplified_term = simplify(term.subterms[0].subterms[0]) # get the inner statement\\n # elif NALSyntax.TermConnector.is_conjunction(term.connector):\\n # #(&&,A,B..C)\\n # new_subterms = []\\n # new_intervals = []\\n # for i in range(len(term.subterms)):\\n # subterm = simplify(term.subterms[i])\\n # if i < len(term.intervals): new_intervals.append(term.intervals[i])\\n # if isinstance(subterm, CompoundTerm) and subterm.connector == term.connector:\\n # # inner conjunction\\n # new_subterms.extend(subterm.subterms)\\n # new_intervals.extend(subterm.intervals)\\n # else:\\n # new_subterms.append(subterm)\\n #\\n # simplified_term = CompoundTerm(subterms=new_subterms,\\n # term_connector=term.connector,\\n # intervals=new_intervals)\\n elif term.connector is NALSyntax.TermConnector.ExtensionalDifference:\\n pass\\n elif term.connector is NALSyntax.TermConnector.IntensionalDifference:\\n pass\\n elif term.connector is NALSyntax.TermConnector.ExtensionalImage:\\n pass\\n elif term.connector is NALSyntax.TermConnector.IntensionalImage:\\n pass\\n\\n\\n return simplified_term\",\n \"def T(logic_formula):\\n global counter, p_base\\n # p_base: (str) A string which is important to creating new variable without coincide with the existing variables.\\n # counter: (int) The counter that increment when new variable is created.\\n \\n if logic_formula.isliteral:\\n return (logic_formula, TRUE)\\n else:\\n args = logic_formula.args\\n operator = OR if logic_formula.operator == '|' else AND if logic_formula.operator == '&' else NOT\\n if operator == NOT:\\n f = args[0]\\n p_prime, c_prime = T(f)\\n return (NOT(p_prime), c_prime)\\n else:\\n f1 = args[0]\\n f2 = operator(*args[1:len(args)]) if (len(args) > 2) else args[1]\\n\\n p = p_base.__str__() + str(counter)\\n p = algebra.Symbol(p)\\n counter = counter + 1\\n\\n p1, c1 = T(f1)\\n p2, c2 = T(f2)\\n\\n return (p, (AND(OR(NOT(p), p1, p2), OR(p, NOT(p1)), OR(p, NOT(p2)), c1, c2)).simplify()) if (\\n operator == OR) else \\\\\\n (p, (AND(OR(p, NOT(p1), NOT(p2)), OR(NOT(p), p1), OR(NOT(p), p2), c1, c2).simplify()))\",\n \"def var_or_atomics():\\n return Parse.plus(var_or_atomic())\",\n \"def parse_terminal(node, ty=None):\\n if ty == \\\"METHOD_CALL\\\":\\n return Terminal(\\\"var\\\", None)\\n elif ty:\\n return Terminal(\\\"var\\\", ty)\\n else:\\n return Terminal(\\\"var\\\", get_type(node))\",\n \"def ontology_term(self, term=None, parent_ID=None, specified=None, vtype=None,\\n desc=None, units=None, **kwargs):\\n if specified:\\n specified=str2bool(specified)\\n\\n payload={\\\"name\\\":term,\\\"description\\\":desc,\\\"type\\\":vtype,\\\"specified\\\":specified,\\\"units\\\":units}\\n r=self.post(self.ONTOLOGY_TERM_RT,None,parent_ID,payload,**kwargs)\\n return r\",\n \"def parse(s):\\n Term.str = s\\n new_term = None\\n while Term.str != '':\\n new_term, Term.str = Term.parse_prefix(Term.str)\\n return new_term\",\n \"def parse_prefix(s):\\n\\n Term.str = replace_string(s) # replace operators with more than one letter to be one letter\\n second = None\\n\\n # if there is a left parentheses it means that we are having an operator that is enclosed by parenthesis\\n if is_left_parenthese(Term.str[0]):\\n Term.eat() # eat left parentheses\\n first, Term.str = Formula.parse_prefix(Term.str) # take first formula of the operator\\n root = switch_root_to_str(Term.str[0]) # take the root\\n Term.eat() # eat the root\\n second, Term.str = Formula.parse_prefix(Term.str) # take second formula of the operator\\n Term.eat() # eat right parentheses\\n\\n # if first letter is a quantifier ('A' or 'E')\\n elif is_quantifier(Term.str[0]):\\n root = Term.str[0] # take the quantifier as root\\n Term.eat() # eat the root ( quantifier)\\n first = Term.get_whole_name() # take the name of the variable\\n Term.eat() # eat the left bracket\\n second, Term.str = Formula.parse_prefix(Term.str) # take the formula\\n Term.eat() # eat the right bracket\\n\\n # if first letter is a relation (starts with capital letter)\\n elif is_relation(Term.str[0]):\\n root = Term.get_whole_name() # take the name of the relation\\n first = []\\n Term.eat() # eat left parentheses\\n\\n # if we didn't find closing parenthesis - than there must be at least one Term inside the parenthesis.\\n # take it.\\n if not is_right_parenthese(Term.str[0]):\\n term_obj, Term.str = Term.parse_prefix(Term.str)\\n first.append(term_obj)\\n\\n # while there is a comma, take the next term\\n while is_comma(Term.str[0]):\\n Term.eat() # eat left parentheses\\n term_obj, Term.str = Term.parse_prefix(Term.str)\\n first.append(term_obj)\\n Term.eat() # eat right parentheses\\n\\n # else , it is an operator\\n else:\\n\\n # if it's an unary operator\\n if is_unary(Term.str[0]):\\n root = Term.str[0]\\n Term.eat()\\n first, Term.str = Formula.parse_prefix(Term.str)\\n\\n # else , the operator is binary or equaluty\\n else:\\n first, Term.str = Term.parse_prefix(Term.str)\\n # if it's a binary operator\\n if is_binary(Term.str[0]):\\n root = Term.str[0:2]\\n Term.eat()\\n\\n # if it's an equal operator\\n else:\\n root = Term.str[0]\\n Term.eat()\\n second, Term.str = Term.parse_prefix(Term.str)\\n returned_formula = Formula(root, first, second)\\n return returned_formula, Term.str\",\n \"def fromTerm(cls, term, swipl):\\n\\n if isinstance(term, Term):\\n term = term.handle\\n elif not isinstance(term, (c_void_p, int)):\\n raise ArgumentTypeError((str(Term), str(c_void_p)), str(type(term)))\\n\\n a = atom_t()\\n if swipl.PL_get_atom(term, byref(a)):\\n return cls(a.value, swipl)\",\n \"def __generate_object_term__(self, datatype, value):\\n if datatype == NS_MGR.xsd.anyURI.rdflib:\\n term = rdflib.URIRef(value)\\n elif datatype:\\n term = rdflib.Literal(value, datatype=datatype)\\n else:\\n term = rdflib.Literal(value)\\n return term\",\n \"def __init__(self, ty, base_ty):\\n\\t\\t\\tassert isinstance(ty, Term)\\n\\t\\t\\tassert isinstance(base_ty, Term)\\n\\t\\t\\tself.ty = ty\\n\\t\\t\\tself.base_ty = ty\",\n \"def BNF():\\n\\n sect_begin = Literal(\\\"{\\\").suppress()\\n sect_end = Literal(\\\"}\\\").suppress()\\n array_begin = Literal(\\\"[\\\").suppress()\\n array_end = Literal(\\\"]\\\").suppress()\\n tag_begin = Literal(\\\"<\\\").suppress()\\n tag_end = Literal(\\\">\\\").suppress()\\n eql = Literal(\\\"=\\\").suppress()\\n dmark = Literal('$').suppress()\\n end_data = Literal('$end').suppress()\\n prtable = alphanums + r'!$%&*+-./<>?@^_|~'\\n int_t = Regex('[-]?\\\\d+')\\n float_t = Regex('-?\\\\d+\\\\.\\\\d*([eE]?[+-]?\\\\d+)?')\\n bool_t = Regex('([Yy]es|[Nn]o|[Tt]rue|[Ff]alse|[Oo]n|[Oo]ff)')\\n\\n # Helper definitions\\n kstr = quotedString.setParseAction(\\n removeQuotes) ^ float_t ^ int_t ^ bool_t ^ Word(prtable)\\n name = Word(alphas + \\\"_\\\", alphanums + \\\"_\\\")\\n vec = array_begin + delimitedList(\\n float_t ^ int_t ^ bool_t ^ Word(prtable) ^ Literal(\\\"\\\\n\\\").suppress() ^\\n quotedString.setParseAction(removeQuotes)) + array_end\\n sect = name + sect_begin\\n tag_sect = name + Group(tag_begin + name + tag_end) + sect_begin\\n\\n # Grammar\\n keyword = name + eql + kstr\\n vector = name + eql + vec\\n data = Combine(dmark + name) + SkipTo(end_data) + end_data\\n #section = Forward()\\n sect_def = (sect | tag_sect)\\n #input = section | data | vector | keyword\\n input = sect_def | data | vector | keyword | sect_end\\n #section << sect_def + ZeroOrMore(input) + sect_end\\n\\n # Parsing actions\\n int_t.setParseAction(token_actions.to_int)\\n float_t.setParseAction(token_actions.to_float)\\n bool_t.setParseAction(token_actions.to_bool)\\n keyword.setParseAction(token_actions.to_scalar)\\n vector.setParseAction(token_actions.to_array)\\n data.setParseAction(token_actions.to_data)\\n sect.setParseAction(token_actions.to_section)\\n tag_sect.setParseAction(token_actions.to_section)\\n sect_end.setParseAction(token_actions.end_of_section)\\n\\n bnf = ZeroOrMore(input) + StringEnd().setFailAction(\\n token_actions.parse_error)\\n bnf.ignore(pythonStyleComment)\\n\\n return Dict(bnf)\",\n \"def determine_term_type(term):\\n \\n NOMINALS = [\\\"ation\\\", \\\"ition\\\", \\\"ption\\\", \\\"ing\\\", \\\"sis\\\", \\\"lism\\\", \\\"ment\\\", \\\"sion\\\"]\\n EVENT_KEYWORDS = [\\\"process\\\", \\\"cycle\\\"]\\n \\n # key words that indicate events despite being nouns \\n if any([ek in term.text.lower() for ek in EVENT_KEYWORDS]):\\n term_type = \\\"event\\\"\\n # key endings indicating a nominalized form of an event \\n elif any([term[i].text.endswith(ne) for ne in NOMINALS for i in range(len(term))]):\\n term_type = \\\"event\\\"\\n # POS = Verb implies event \\n elif any([t.pos_ == \\\"VERB\\\" for t in term]):\\n term_type = \\\"event\\\"\\n # default is otherwise entity \\n else:\\n term_type = \\\"entity\\\"\\n \\n return term_type\",\n \"def fold_term(self, term):\\n if isinstance(term, Var):\\n return self.var(term.name)\\n elif isinstance(term, Const):\\n return self.const(term.name)\\n elif isinstance(term, Dist):\\n return self.dist(term.name)\\n elif isinstance(term, Func):\\n return self.func(\\n term.funcname,\\n tuple( self.fold_term(x)\\n for x in term.args ))\\n elif isinstance(term, Eq):\\n return self.encode_eq(term)\\n elif isinstance(term, Disj):\\n return self.encode_disj(term)\\n elif isinstance(term, Conj):\\n return self.encode_conj(term)\\n raise RuntimeError('Invalid term {}'.format(term))\",\n \"def makeTermType(tag, keyword, G):\\n string = \\\"<%s>\\\" % tag\\n\\n l = G(\\\"%sLSL\\\" % keyword)\\n lsym = G(\\\"%sLSLSymbol\\\" % keyword)\\n s = G(\\\"%sS\\\" % keyword)\\n mult = G(\\\"%sLSMultiplicity\\\" % keyword)\\n senior = G(\\\"%sLSSeniority\\\" % keyword)\\n\\n if l and s:\\n string += \\\"<LS>\\\"\\n string += \\\"<L><Value>%s</Value>\\\"% l\\n if lsym: string += \\\"<Symbol>%s</Symbol>\\\" % lsym\\n string += \\\"</L><S>%s</S>\\\" % s\\n if mult: string += \\\"<Multiplicity>%s</Multiplicity>\\\" % mult\\n if senior: string += \\\"<Seniority>%s</Seniority>\\\" % senior\\n string += \\\"</LS>\\\"\\n\\n jj = makeiter(G(\\\"%sJJ\\\" % keyword))\\n if jj:\\n string += \\\"<jj>\\\"\\n for j in jj:\\n string += \\\"<j>%s</j>\\\" % j\\n string += \\\"</jj>\\\"\\n j1j2 = makeiter(G(\\\"%sJ1J2\\\" % keyword))\\n if j1j2:\\n string += \\\"<j1j2>\\\"\\n for j in j1j2:\\n string += \\\"<j>%s</j>\\\" % j\\n string += \\\"</j1j2>\\\"\\n K = G(\\\"%sK\\\" % keyword)\\n if K:\\n string += \\\"<jK>\\\"\\n j = G(\\\"%sJKJ\\\" % keyword)\\n if j:\\n string += \\\"<j>%s</j>\\\" % j\\n S2 = G(\\\"%sJKS\\\" % keyword)\\n if S2:\\n string += \\\"<S2>%s</S2>\\\" % S2\\n string += \\\"<K>%s</K>\\\" % K\\n string += \\\"</jK>\\\"\\n l = G(\\\"%sLKL\\\" % keyword)\\n k = G(\\\"%sLKK\\\" % keyword)\\n if l and k:\\n string += \\\"<LK>\\\"\\n string += \\\"<L><Value>%s</Value><Symbol>%s</Symbol></L>\\\" % (l, G(\\\"%sLKLSymbol\\\" % keyword))\\n string += \\\"<K>%s</K>\\\" % k\\n string += \\\"<S2>%s</S2>\\\" % G(\\\"%sLKS2\\\" % keyword)\\n string += \\\"</LK>\\\"\\n tlabel = G(\\\"%sLabel\\\" % keyword)\\n if tlabel:\\n string += \\\"<TermLabel>%s</TermLabel>\\\" % tlabel\\n string += \\\"</%s>\\\" % tag\\n return string\",\n \"def assign_term(urs):\\n\\n if isinstance(urs, six.string_types):\\n return MAPPING.get(urs, UNKNOWN)\\n return assign_term(urs.get_rna_type())\",\n \"def visit_term(self, node, children):\\n if self.debug:\\n print(\\\"Term {}\\\".format(children))\\n term = children[0]\\n for i in range(2, len(children), 2):\\n if children[i-1] == \\\"*\\\":\\n term *= children[i]\\n else:\\n term /= children[i]\\n if self.debug:\\n print(\\\"Term = {}\\\".format(term))\\n return term\",\n \"def parse(s: str):\\n Term.str = s\\n new_Formula = None\\n while Term.str != '':\\n new_Formula, Term.str = Formula.parse_prefix(Term.str)\\n return new_Formula\\n # Task 7.4.2\",\n \"def apply_rule(term: Term, rule: Rule):\\n if isinstance(term, rule.type):\\n substitution = term.match(rule.left)\\n if substitution is not None:\\n new_t = subst(rule.right, substitution)\\n if isinstance(new_t, Term):\\n new_t = term.__class__(new_t.function, new_t.arguments, new_t.static)\\n return new_t\\n return term\",\n \"def __call__(self, *args: TermLike) -> 'Term':\\n return Term(self, args)\",\n \"def atomic():\\n #I forget why I am converting integers.\\n def f(item):\\n item1 = Parse.next_token().process(item)\\n result = item1.tok\\n if result.type == 'INTEGER' or result.type == 'WORD':\\n tok = copy.copy(result)\\n if tok.type == 'WORD':\\n tok.value = c.synonymize(tok.value)\\n tok.type = 'ATOMIC_IDENTIFIER'\\n return (tok,item1)\\n if result.type == 'ATOMIC_IDENTIFIER':\\n return result\\n raise ParseError(item)\\n return Parse(f).expect('atomic')\",\n \"def mk_VAR(v):\\n if not v.is_var():\\n raise InvalidDerivationException(\\\"mk_VAR\\\")\\n return Thm([], Const(\\\"_VAR\\\", TFun(v.T, BoolType))(v))\",\n \"def is_term():\\n global _STATIC_VARS\\n return _STATIC_VARS.term\",\n \"def format_term(term: Union[BNode, Literal, URIRef, Variable]) -> str:\\n if isinstance(term, URIRef):\\n return str(term)\\n elif isinstance(term, BNode):\\n return '?v_' + str(term)\\n elif isinstance(term, Literal):\\n return format_literal(term)\\n else:\\n return term.n3()\",\n \"def _make_transition(token_namespace, reserved_syntax_strings, label):\\n if label[0].isalpha():\\n # A named token (e.g. NAME, NUMBER, STRING)\\n return getattr(token_namespace, label)\\n else:\\n # Either a keyword or an operator\\n assert label[0] in ('\\\"', \\\"'\\\"), label\\n assert not label.startswith('\\\"\\\"\\\"') and not label.startswith(\\\"'''\\\")\\n value = literal_eval(label)\\n try:\\n return reserved_syntax_strings[value]\\n except KeyError:\\n r = reserved_syntax_strings[value] = ReservedString(value)\\n return r\",\n \"def act_on_literal(self, *, value):\\n assert not isinstance(value, PolarsTerm)\\n if isinstance(value, (Dict, List, Set)):\\n return PolarsTerm(polars_term=None, is_literal=True, lit_value=value)\\n else:\\n return PolarsTerm(polars_term=_build_lit(value), is_literal=True, lit_value=value)\",\n \"def get_or_create_term(self, term):\\n term_id = self.get_term_id(term)\\n if term_id is not None:\\n return term_id\\n\\n term_id = self.db.execute('INSERT INTO terms(term) VALUES (?) ', (term,)).lastrowid\\n postings_table = 'term_%d' % term_id\\n\\n info(\\\"creating table for term \\\" + term)\\n\\n self.db.execute('''CREATE TABLE %s (document_id INT NOT NULL,\\n hits INT NOT NULL,\\n FOREIGN KEY (document_id) REFERENCES documents(rowid));''' % postings_table)\\n\\n return term_id\",\n \"def generate_term(self, **kwargs):\\n term_map = kwargs.pop('term_map')\\n if hasattr(term_map, \\\"termType\\\") and\\\\\\n term_map.termType == NS_MGR.rr.BlankNode.rdflib:\\n return rdflib.BNode()\\n if not hasattr(term_map, 'datatype'):\\n term_map.datatype = NS_MGR.xsd.anyURI.rdflib\\n if hasattr(term_map, \\\"template\\\") and term_map.template is not None:\\n template_vars = kwargs\\n template_vars.update(self.constants)\\n # Call any functions to generate values\\n for key, value in template_vars.items():\\n if hasattr(value, \\\"__call__\\\"):\\n template_vars[key] = value()\\n raw_value = term_map.template.format(**template_vars)\\n if term_map.datatype == NS_MGR.xsd.anyURI.rdflib:\\n return rdflib.URIRef(raw_value)\\n return rdflib.Literal(raw_value,\\n datatype=term_map.datatype)\\n if term_map.reference is not None:\\n # Each child will have different mechanisms for referencing the\\n # source based\\n return self.__generate_reference__(term_map, **kwargs)\",\n \"def fromTerm(cls, term, swipl):\\n\\n if isinstance(term, Term):\\n term = term.handle\\n elif not isinstance(term, (c_void_p, int)):\\n raise ArgumentTypeError((str(Term), str(int)), str(type(term)))\\n\\n f = functor_t()\\n if swipl.PL_get_functor(term, byref(f)):\\n # get args\\n args = []\\n arity = swipl.PL_functor_arity(f.value)\\n # let's have all args be consecutive\\n a0 = swipl.PL_new_term_refs(arity)\\n for i, a in enumerate(range(1, arity + 1)):\\n if swipl.PL_get_arg(a, term, a0 + i):\\n args.append(getTerm(a0 + i, swipl))\\n\\n return cls(f.value, swipl, args=args, a0=a0)\",\n \"def temp_var_or_literal(self, name, var, init):\\n if var[0]:\\n # Literal\\n return var[1]\\n temp = self.make_temp_var(name)\\n init.append('%s = %s' % (temp, var[1]))\\n return temp\",\n \"def create() -> 'Tokenizer':\\n token_op_table = [\\n EOS,\\n op.Concat,\\n op.ConstStr,\\n op.SubStr,\\n op.GetSpan,\\n op.Trim,\\n ]\\n\\n # Nesting operators and their args get \\\"compacted\\\" into\\n # \\\"primitive\\\" tokens\\n\\n for type_ in op.Type:\\n for index in op.INDEX:\\n token_op_table.append((op.GetToken, type_, index))\\n\\n for case in op.Case:\\n token_op_table.append((op.ToCase, case))\\n\\n for delim1 in op.DELIMITER:\\n for delim2 in op.DELIMITER:\\n token_op_table.append((op.Replace, delim1, delim2))\\n\\n for dsl_regex in list(op.Type) + list(op.DELIMITER):\\n token_op_table.append((op.GetUpto, dsl_regex))\\n\\n for dsl_regex in list(op.Type) + list(op.DELIMITER):\\n token_op_table.append((op.GetFrom, dsl_regex))\\n\\n for type_ in op.Type:\\n for index in op.INDEX:\\n token_op_table.append((op.GetFirst, type_, index))\\n\\n for type_ in op.Type:\\n token_op_table.append((op.GetAll, type_))\\n\\n # Primitive types\\n\\n for type_ in op.Type:\\n token_op_table.append(type_)\\n\\n for boundary in op.Boundary:\\n token_op_table.append(boundary)\\n\\n # Covers op.INDEX\\n for position in range(op.POSITION[0], op.POSITION[1]+1):\\n token_op_table.append(position)\\n\\n # This covers op.DELIMITER\\n for character in op.CHARACTER:\\n token_op_table.append(character)\\n\\n token_op_table = {\\n token: op\\n for token, op in enumerate(token_op_table)\\n }\\n\\n op_token_table = {\\n op: token\\n for token, op in token_op_table.items()\\n }\\n\\n assert len(token_op_table) == len(op_token_table)\\n\\n string_token_table = {\\n char: token\\n for token, char in enumerate(op.CHARACTER)\\n }\\n\\n return Tokenizer(\\n token_op_table=token_op_table,\\n op_token_table=op_token_table,\\n string_token_table=string_token_table,\\n )\",\n \"def _read_terminal_node(cls, elements):\\n \\n # TODO: add option to read lemma, pos if the input come from ccg\\n label = elements[0]\\n word = elements[1]\\n return SyntacticNode(label, word=word, pos=label)\",\n \"def __init__(self, \\r\\n atomicTermExpr=None, \\r\\n composedTermNodeLabels=None, \\r\\n generatedTermLabel=None):\\r\\n self.__ate = atomicTermExpr if atomicTermExpr is not None else Never()\\r\\n self.__ctnls = composedTermNodeLabels\\r\\n self.__gtl = generatedTermLabel\",\n \"def expression( ):#DOUBLE CHECK THIS\\n\\t\\n\\ttok = tokens.peek( )\\n\\tif debug: print(\\\"Expression: \\\", tok)\\n\\tleft = andExpr( ) #does the left side of the grammar \\n\\ttok = tokens.peek( )\\n\\twhile tok == \\\"or\\\": #checks to see if there is the token or and will preform what is inside the curly bracket since it is a series \\n\\t\\ttokens.next()\\n\\t\\tright = andExpr( )\\n\\t\\tleft = BinaryExpr(tok, left, right) # MIGHT HAVE TO CHANGE THIS TO STRING CAUSE ITS \\\"or\\\"\\n\\t\\ttok = tokens.peek( )\\n\\treturn left\",\n \"def parse(operators, *term_strs):\\n scope = Scope()\\n rvs = []\\n for ts in term_strs:\\n p = Parser(operators, ts, scope)\\n try:\\n term = p.parse()\\n except SyntaxError:\\n print 'While parsing: %s' % ts\\n raise\\n rvs.append(term)\\n rvs.append(scope)\\n return tuple(rvs)\",\n \"def __transform_term(self, term: ast.TermASTNode) -> ast.TermASTNode:\\n # TODO: expansion cycle detection\\n if isinstance(term, ast.FunctionApplicationASTNode) \\\\\\n and isinstance(term.get_declaration().get_declaring_ast_node(), ast.DefineFunCommandASTNode):\\n definition = term.get_declaration().get_declaring_ast_node()\\n result = self.__create_expansion(term, definition)\\n else:\\n result = term\\n\\n # Transform child nodes.\\n children = result.get_child_nodes()\\n for i, child_node in enumerate(children):\\n result.set_child_node(i, self.__transform_term(child_node))\\n\\n return result\",\n \"def atom(token):\\n try:\\n return int(token)\\n except ValueError:\\n try:\\n return float(token)\\n except ValueError:\\n return Symbol(token)\",\n \"def act_on_literal(self, *, value):\\n assert not isinstance(value, PolarsTerm)\",\n \"def AddTerm(con, cur, term, parent='na', ontologyname='scdb', synonyms=[], commit=True):\\n try:\\n # convert everything to lower case before interacting with the database\\n term = term.lower()\\n parent = parent.lower()\\n ontologyname = ontologyname.lower()\\n synonyms = [csyn.lower() for csyn in synonyms]\\n\\n # add/get the ontology term\\n err, termid = dbidval.AddItem(con, cur, table='OntologyTable', description=term, commit=False)\\n if err:\\n return err, None\\n # add/get the ontology parent term\\n err, parentid = dbidval.AddItem(con, cur, table='OntologyTable', description=parent, commit=False)\\n if err:\\n return err, None\\n # add/get the ontology name\\n err, ontologynameid = dbidval.AddItem(con, cur, table='OntologyNamesTable', description=ontologyname, commit=False)\\n if err:\\n return err, None\\n # add the tree info\\n err, treeid = AddTreeTerm(con, cur, termid, parentid, ontologynameid, commit=False)\\n if err:\\n return err, None\\n # add the synonyms\\n if synonyms:\\n for csyn in synonyms:\\n err, cid = AddSynonym(con, cur, termid, csyn, commit=False)\\n debug(2, 'added ontology term %s. id is %d' % (term, termid))\\n if commit:\\n con.commit()\\n return '', termid\\n\\n except psycopg2.DatabaseError as e:\\n debug(7, \\\"error %s enountered in ontology.AddTerm\\\" % e)\\n return \\\"error %s enountered in ontology.AddTerm\\\" % e, -2\",\n \"def eval(node):\\n if node.id == '(literal)':\\n return node.value\\n elif node.id == '(name)':\\n return scope[node.value]\\n elif node.id == '(':\\n name, args = node.children\\n name = eval(name)\\n args = map(eval, args)\\n return name(*args)\\n elif node.id == 'and':\\n assert len(node.children) == 2\\n first = eval(node.children[0])\\n if first:\\n return eval(node.children[1])\\n else:\\n return first\\n elif node.id == 'or':\\n assert len(node.children) == 2\\n first = eval(node.children[0])\\n if first:\\n return first\\n else:\\n return eval(node.children[1])\\n elif node.id == 'not':\\n assert len(node.children) == 1\\n return not eval(node.children[0])\\n elif node.id in prefix_operators and len(node.children) == 1:\\n value = eval(node.children[0])\\n return prefix_operators[node.id](value)\\n elif node.id in operators:\\n values = [eval(v) for v in node.children]\\n return operators[node.id](*values)\\n else:\\n raise ValueError('unknown node type', node)\",\n \"def literal():\\n return Literal()\",\n \"def atom(token):\\n try:\\n return int(token)\\n except ValueError:\\n try:\\n return float(token)\\n except ValueError:\\n return Symbol(token) # Equivalent to str(token)\",\n \"def factor( ):\\n\\n\\ttok = tokens.peek( )\\n\\tif debug: print (\\\"Factor: \\\", tok)\\n\\tif re.match( Lexer.number, tok ):\\n\\t\\texpr = Number(tok)\\n\\t\\ttokens.next( )\\n\\t\\ttok = tokens.peek( )\\n\\t\\treturn expr\\n\\tif tok == \\\"(\\\":\\n\\t\\ttokens.next( ) # or match( tok )\\n\\t\\texpr = addExpr( )#might need to change to expression( )\\n\\t\\ttokens.peek( )\\n\\t\\ttok = match( \\\")\\\" )\\n\\t\\treturn expr\\n\\tif re.match( Lexer.identifier, tok ): # added this to take into accout identifiers\\n\\t\\texpr = VarRef(tok)\\n\\t\\ttokens.next( )\\n\\t\\treturn expr\\n\\tif re.match( Lexer.String, tok ): # added this to take into account strings\\n\\t\\texpr = String( tok )\\n\\t\\treturn expr\\n\\n\\terror( \\\"Invalid operand\\\" )\\n\\treturn\",\n \"def proc(form, term, idx):\\n assert term == tensor.local_terms[idx]\\n assert form == expected_terms[idx]\\n return 'N'\",\n \"def declare_variable(var, bound_variables):\\n varname = var.name\\n vartype = var.vartype\\n\\n # check if it is bound and has already been seen\\n if bound_variables is not None and varname in bound_variables:\\n yvar = bound_variables[varname].yices_term\\n var.bound = True\\n return yvar\\n\\n # check if it has already been seen\\n yvar = Terms.get_by_name(varname)\\n if yvar is not None:\\n #now we need to see if it is free or bound\\n tag = Terms.constructor(yvar)\\n if tag == Constructor.VARIABLE:\\n var.bound = True\\n bound_variables[varname] = var\\n return yvar\\n\\n type_term = vartype.yices_term\\n type_name = vartype.name\\n\\n var_term = None\\n\\n if bound_variables is not None:\\n # we need to make a yices variable not an uninterpreted term\\n var_term = Terms.new_variable(type_term, varname)\\n if var_term is None:\\n sys.stderr.write(f'declare_variable: Term.new_variable failed {Yices.error_string()}\\\\n')\\n return None\\n bound_variables[varname] = var\\n var.bound = True\\n else:\\n var_term = Terms.new_uninterpreted_term(type_term, varname)\\n if var_term is None:\\n sys.stderr.write(f'declare_variable: Term.new_uninterpreted_term failed {Yices.error_string()}\\\\n')\\n return None\\n\\n YicesSignature.types_to_variables[type_name].add(var)\\n\\n return var_term\",\n \"def terms(self) -> Tuple[Term, ...]:\\n ...\",\n \"def get_atom_type(self, atom):\\n if self.check_if_keyword(atom):\\n # 1 for keyword\\n return 1\\n if self.check_if_var(atom):\\n # 2 for identifier\\n return 2\\n if self.check_if_const(atom):\\n # 3 for constant\\n return 3\\n if atom == \\\" \\\" or atom == \\\"\\\" or atom == '' or atom == \\\"\\\\n\\\" or atom.isspace():\\n # 4 for generic separators\\n return 4\\n return 0\",\n \"def term_from_uri(uri):\\n if uri is None:\\n return None\\n # This insures that if we get a Literal with an integer value (as we\\n # do for modification positions), it will get converted to a string,\\n # not an integer.\\n if isinstance(uri, rdflib.Literal):\\n uri = str(uri.toPython())\\n # This is to handle URIs like\\n # http://www.openbel.org/bel/namespace//MAPK%20Erk1/3%20Family\\n # or\\n # http://www.openbel.org/bel/namespace/MAPK%20Erk1/3%20Family\\n # In the current implementation, the order of the patterns\\n # matters.\\n patterns = ['http://www.openbel.org/bel/namespace//(.*)',\\n 'http://www.openbel.org/vocabulary//(.*)',\\n 'http://www.openbel.org/bel//(.*)',\\n 'http://www.openbel.org/bel/namespace/(.*)',\\n 'http://www.openbel.org/vocabulary/(.*)',\\n 'http://www.openbel.org/bel/(.*)']\\n for pr in patterns:\\n match = re.match(pr, uri)\\n if match is not None:\\n term = match.groups()[0]\\n term = unquote(term)\\n return term\\n # If none of the patterns match then the URI is actually a simple term\\n # for instance a site: \\\"341\\\" or a substitution: \\\"sub(V,600,E)\\\"\\n return uri\",\n \"def format_literal(term: Literal) -> str:\\n lang = term.language\\n dtype = term.datatype\\n lit = str(term)\\n if lang is not None or dtype is not None:\\n return term.n3()\\n if re.fullmatch(r_integer, lit):\\n dtype = XSD.integer\\n elif re.fullmatch(r_decimal, lit):\\n dtype = XSD.decimal\\n elif re.fullmatch(r_double, lit):\\n dtype = XSD.double\\n elif re.fullmatch(r_boolean, lit):\\n dtype = XSD.boolean\\n return Literal(lit, lang, dtype).n3()\",\n \"def visitTerminal(self, node):\\n # type: (TerminalNode) -> Union[expr.Expr, int, float]\\n\\n node_type = node.getSymbol().type\\n node_text = node.getText()\\n name = node_text[1:]\\n\\n # variables\\n if node_type == RelayLexer.GLOBAL_VAR:\\n return lookup(deque([self.global_var_scope]), node_text[1:])\\n if node_type == RelayLexer.LOCAL_VAR:\\n # Remove the leading '%' and lookup the name.\\n var = lookup(self.var_scopes, name)\\n if var is None:\\n raise ParseError(\\\"Couldn't resolve `{}`.\\\".format(name))\\n return var\\n if node_type == RelayLexer.GRAPH_VAR:\\n try:\\n return self.graph_expr[int(name)]\\n except IndexError:\\n raise ParseError(\\\"Couldn't resolve `{}`\\\".format(name))\\n\\n # data types\\n if node_type == RelayLexer.NAT:\\n return int(node_text)\\n if node_type == RelayLexer.FLOAT:\\n return float(node_text)\\n if node_type == RelayLexer.BOOL_LIT:\\n if node_text == \\\"True\\\":\\n return True\\n if node_text == \\\"False\\\":\\n return False\\n raise ParseError(\\\"Unrecognized BOOL_LIT: `{}`\\\".format(node_text))\\n\\n raise ParseError(\\\"todo: {}\\\".format(node_text))\",\n \"def BuildTerm(self, p_node):\\n\\n max_comment_length = 60\\n access_pn=Tree('access-policy ' + self.term.name )\\n access_pn.AddParent(p_node)\\n if self.verbose and self.term.comment:\\n if len(self.term.comment[0]) < max_comment_length:\\n comm=Tree('', '/* ' + self.term.comment[0] + ' */')\\n else:\\n comments = aclgenerator.WrapWords(self.term.comment, 60)\\n comments.append( '*/')\\n comments.insert(0, '/*')\\n comm=Tree('', comments)\\n comm.AddParent(access_pn)\\n\\n rule_match =Tree('match')\\n rule_match.AddParent(access_pn)\\n\\n if self.from_zone:\\n self.BuildTermZone(rule_match, 'src')\\n\\n if self.to_zone:\\n self.BuildTermZone(rule_match, 'dest')\\n\\n if self.term.versa_application or self.app:\\n self.BuildTermApp(rule_match)\\n\\n if self.term.dscp_match:\\n self.BuildTermDscp(rule_match)\\n\\n if self.term.action:\\n self.BuildTermLogging(access_pn)\\n\\n #print(\\\"\\\\n\\\".join(set_term.PrintTree()))\",\n \"def tree(string, token=[WORD, POS, CHUNK, PNP, REL, ANCHOR, LEMMA]):\\n return Text(string, token)\",\n \"def term(self):\\n initial_pos = self.pos\\n\\n # Match an integer constant.\\n # Convert from C-style literals to Python integers.\\n try:\\n constant = self.match_type(NumericalConstant)\\n\\n # Use prefix (if present) to determine base\\n base = 10\\n bases = {\\\"0x\\\": 16, \\\"0X\\\": 16, \\\"0b\\\": 2, \\\"0B\\\": 2}\\n try:\\n prefix = constant.token[0:2]\\n base = bases[prefix]\\n value = constant.token[2:]\\n except KeyError:\\n value = constant.token\\n\\n # Strip suffix (if present)\\n suffix = None\\n suffixes = ['ull', 'ULL', 'ul', 'UL', 'll', 'LL', 'u', 'U', 'l', 'L']\\n for s in suffixes:\\n if value.endswith(s):\\n suffix = s\\n value = value[:-len(s)]\\n break\\n\\n # Convert to decimal and then to integer with correct sign\\n # Preprocessor always uses 64-bit arithmetic!\\n int_value = int(value, base)\\n if suffix and 'u' in suffix:\\n return np.uint64(int_value)\\n else:\\n return np.int64(int_value)\\n except ParseError:\\n self.pos = initial_pos\\n\\n # Match a character constant.\\n # Convert from character literals to integer value.\\n try:\\n constant = self.match_type(CharacterConstant)\\n return np.int64(ord(constant.token))\\n except ParseError:\\n self.pos = initial_pos\\n\\n # Match a function call.\\n try:\\n return self.call()\\n except ParseError:\\n self.pos = initial_pos\\n\\n # Match an identifier.\\n # Any identifier that still exists after substitution evaluates\\n # to false\\n try:\\n self.match_type(Identifier)\\n return np.int64(0)\\n except ParseError:\\n self.pos = initial_pos\\n\\n raise ParseError(\\n \\\"Expected an integer constant, character constant, identifier or function call.\\\")\",\n \"def expression_to_english_tree(expr):\\n if isinstance(expr, ApplicationExpression):\\n pred_name = expr.pred.variable.name\\n if (not (pred_name in (adjectives + intransitive_verbs + transitive_verbs))):\\n raise GenerationError(\\\"Invalid predicate: %s\\\" % pred_name)\\n # might want to add a line enforcing variable name to begin with an x, y, or z?\\n freevars = [Trace(Index(int(arg.variable.name[1:])), False) for arg in expr.args]\\n if (pred_name in adjectives):\\n tree = SynTree(default_featstructs['TP'], [SynTree(default_featstructs['DP_trace'], [SynTree(freevars[0], [])]), SynTree(default_featstructs['TBar'], [SynTree(default_featstructs['VP'], [SynTree(default_featstructs['VBar'], [SynTree(default_featstructs['V_link'], [SynTree('BE', [])]), SynTree(default_featstructs['AdjP'], [SynTree(default_featstructs['AdjBar'], [SynTree(default_featstructs['Adj'], [SynTree(pred_name, [])])])])])])])])\\n elif (pred_name in intransitive_verbs):\\n tree = SynTree(default_featstructs['TP'], [SynTree(default_featstructs['DP_trace'], [SynTree(freevars[0], [])]), SynTree(default_featstructs['TBar'], [SynTree(default_featstructs['VP'], [SynTree(default_featstructs['VBar'], [SynTree(default_featstructs['V_intrans'], [SynTree(pred_name, [])])])])])])\\n else:\\n tree = SynTree(default_featstructs['TP'], [SynTree(default_featstructs['DP_trace'], [SynTree(freevars[1], [])]), SynTree(default_featstructs['TBar'], [SynTree(default_featstructs['VP'], [SynTree(default_featstructs['VBar'], [SynTree(default_featstructs['V_trans'], [SynTree(pred_name, [])]), SynTree(default_featstructs['DP_trace'], [SynTree(freevars[0], [])])])])])])\\n elif isinstance(expr, EqualityExpression):\\n freevars = [Trace(Index(int(arg.variable.name[1:])), False) for arg in [expr.first, expr.second]]\\n tree = SynTree(default_featstructs['TP'], [SynTree(default_featstructs['DP_trace'], [SynTree(freevars[0], [])]), SynTree(default_featstructs['TBar'], [SynTree(default_featstructs['VP'], [SynTree(default_featstructs['VBar'], [SynTree(default_featstructs['V_link'], [SynTree('BE', [])]), SynTree(default_featstructs['DP_trace'], [SynTree(freevars[1], [])])])])])])\\n elif isinstance(expr, NLQuantifiedExpression):\\n nucleus_tree = expression_to_english_tree(expr.nucleus)\\n DPs = nucleus_tree.postorder_traverse(get_free_trace_DP, {'DPs' : []})['DPs']\\n if (len(DPs) == 0):\\n raise GenerationError(\\\"Quantifier %s must bind a free variable.\\\" % expr.getQuantifier())\\n subj_tree = expression_to_english_DP_tree(expr.getQuantifier(), expr.restrictor)\\n tree = SynTree(default_featstructs['TP'], [subj_tree, SynTree(default_featstructs['PA'], [SynTree(Index(-1), []), nucleus_tree])])\\n for DP in DPs:\\n if (int(expr.variable.name[1:]) == DP.children[0].label.index.index): # check that variables match\\n tree[1][0].label = DP.children[0].label.index = tree[0].ID\\n DP.children[0].label.bound = True # quantifier has bound the free variable\\n break\\n if (tree[1][0].label.index == -1):\\n raise GenerationError(\\\"Quantifier %s failed to find corresponding free variable.\\\" % expr.getQuantifier())\\n else:\\n raise GenerationError(\\\"Invalid expression.\\\")\\n tree.set_QR_level(1)\\n tree.label_nodes()\\n tree.make_nx_tree()\\n return tree\",\n \"def test_literal():\\n token = Token(\\\"h\\\", TokenInfo(\\\"<stdin>\\\", 0, 1, \\\"he\\\"))\\n assert token.info.offset == 1\\n assert token.info.filename == \\\"<stdin>\\\"\\n assert token.lexeme == \\\"h\\\"\\n assert token.info.lineno == 0\\n assert token.symbol == Literal.STRING\\n assert token.info.line == \\\"he\\\"\\n\\n token += 'e'\\n assert token.info.offset == 1\\n assert token.info.filename == \\\"<stdin>\\\"\\n assert token.lexeme == \\\"he\\\"\\n assert token.info.lineno == 0\\n assert token.symbol == Literal.STRING\\n assert token.info.line == \\\"he\\\"\\n\\n token = Token(\\\"_\\\", TokenInfo(\\\"<stdin>\\\", 0, 1, \\\"_e_12__\\\"))\\n assert token.info.offset == 1\\n assert token.info.filename == \\\"<stdin>\\\"\\n assert token.lexeme == \\\"_\\\"\\n assert token.info.lineno == 0\\n assert token.symbol == Literal.STRING\\n assert token.info.line == \\\"_e_12__\\\"\\n\\n token += 'e'\\n assert token.info.offset == 1\\n assert token.info.filename == \\\"<stdin>\\\"\\n assert token.lexeme == \\\"_e\\\"\\n assert token.info.lineno == 0\\n assert token.symbol == Literal.STRING\\n assert token.info.line == \\\"_e_12__\\\"\\n\\n token += '_'\\n assert token.info.offset == 1\\n assert token.info.filename == \\\"<stdin>\\\"\\n assert token.lexeme == \\\"_e_\\\"\\n assert token.info.lineno == 0\\n assert token.symbol == Literal.STRING\\n assert token.info.line == \\\"_e_12__\\\"\\n\\n token += '1'\\n assert token.info.offset == 1\\n assert token.info.filename == \\\"<stdin>\\\"\\n assert token.lexeme == \\\"_e_1\\\"\\n assert token.info.lineno == 0\\n assert token.symbol == Literal.STRING\\n assert token.info.line == \\\"_e_12__\\\"\\n\\n token += '2'\\n assert token.info.offset == 1\\n assert token.info.filename == \\\"<stdin>\\\"\\n assert token.lexeme == \\\"_e_12\\\"\\n assert token.info.lineno == 0\\n assert token.symbol == Literal.STRING\\n assert token.info.line == \\\"_e_12__\\\"\\n\\n token += '_'\\n assert token.info.offset == 1\\n assert token.info.filename == \\\"<stdin>\\\"\\n assert token.lexeme == \\\"_e_12_\\\"\\n assert token.info.lineno == 0\\n assert token.symbol == Literal.STRING\\n assert token.info.line == \\\"_e_12__\\\"\\n\\n token += '_'\\n assert token.info.offset == 1\\n assert token.info.filename == \\\"<stdin>\\\"\\n assert token.lexeme == \\\"_e_12__\\\"\\n assert token.info.lineno == 0\\n assert token.symbol == Literal.STRING\\n assert token.info.line == \\\"_e_12__\\\"\\n\\n token = Token(\\\"h\\\", TokenInfo(\\\"<stdin>\\\", 0, 1, \\\"h+\\\"))\\n assert token.info.offset == 1\\n assert token.info.filename == \\\"<stdin>\\\"\\n assert token.lexeme == \\\"h\\\"\\n assert token.info.lineno == 0\\n assert token.symbol == Literal.STRING\\n assert token.info.line == \\\"h+\\\"\\n\\n with pytest.raises(LythSyntaxError) as err:\\n token += \\\"+\\\"\\n\\n assert token.lexeme == \\\"h\\\"\\n assert err.value.msg is LythError.MISSING_SPACE_BEFORE_OPERATOR\\n assert err.value.filename == \\\"<stdin>\\\"\\n assert err.value.lineno == 0\\n assert err.value.offset == 1\\n assert err.value.line == \\\"h+\\\"\\n\\n token = Token(\\\"_\\\", TokenInfo(\\\"<stdin>\\\", 0, 1, \\\"_+\\\"))\\n assert token.info.offset == 1\\n assert token.info.filename == \\\"<stdin>\\\"\\n assert token.lexeme == \\\"_\\\"\\n assert token.info.lineno == 0\\n assert token.symbol == Literal.STRING\\n assert token.info.line == \\\"_+\\\"\\n\\n with pytest.raises(LythSyntaxError) as err:\\n token += \\\"+\\\"\\n\\n assert token.lexeme == \\\"_\\\"\\n assert err.value.msg is LythError.MISSING_SPACE_BEFORE_OPERATOR\\n assert err.value.filename == \\\"<stdin>\\\"\\n assert err.value.lineno == 0\\n assert err.value.offset == 1\\n assert err.value.line == \\\"_+\\\"\\n\\n token = Token(\\\"_\\\", TokenInfo(\\\"<stdin>\\\", 0, 1, \\\"_1+\\\"))\\n assert token.info.offset == 1\\n assert token.info.filename == \\\"<stdin>\\\"\\n assert token.lexeme == \\\"_\\\"\\n assert token.info.lineno == 0\\n assert token.symbol == Literal.STRING\\n assert token.info.line == \\\"_1+\\\"\\n\\n token += \\\"1\\\"\\n assert token.info.offset == 1\\n assert token.info.filename == \\\"<stdin>\\\"\\n assert token.lexeme == \\\"_1\\\"\\n assert token.info.lineno == 0\\n assert token.symbol == Literal.STRING\\n assert token.info.line == \\\"_1+\\\"\\n\\n with pytest.raises(LythSyntaxError) as err:\\n token += \\\"+\\\"\\n\\n assert token.lexeme == \\\"_1\\\"\\n assert err.value.msg is LythError.MISSING_SPACE_BEFORE_OPERATOR\\n assert err.value.filename == \\\"<stdin>\\\"\\n assert err.value.lineno == 0\\n assert err.value.offset == 1\\n assert err.value.line == \\\"_1+\\\"\",\n \"def _build_term_op_(term, state_array, int_state_array, sorting_indices):\\n\\n space_size = state_array.shape[0]\\n\\n needs_to_be_occupied = []\\n needs_to_be_unoccupied = []\\n\\n # We keep track of the number of creation and annihilation operators and\\n # ensure that there are an equal number of them in order to help detect\\n # invalid inputs.\\n delta = 0\\n for index, op_type in reversed(term):\\n if op_type == 0:\\n needs_to_be_occupied.append(index)\\n delta -= 1\\n else:\\n if index not in needs_to_be_occupied:\\n needs_to_be_unoccupied.append(index)\\n delta += 1\\n\\n if delta != 0:\\n raise ValueError(\\n \\\"The supplied operator doesn't preserve particle number\\\")\\n\\n # We search for every state which has the necessary orbitals occupied and\\n # unoccupied in order to not be immediately zeroed out based on the\\n # creation and annihilation operators specified in term.\\n maybe_valid_states = numpy.where(\\n numpy.logical_and(\\n numpy.all(state_array[:, needs_to_be_occupied], axis=1),\\n numpy.logical_not(\\n numpy.any(state_array[:, needs_to_be_unoccupied], axis=1))))[0]\\n\\n data = []\\n row_ind = []\\n col_ind = []\\n shape = (space_size, space_size)\\n\\n # For each state that is not immediately zeroed out by the action of our\\n # operator we check to see if the determinant which this state gets mapped\\n # to is in the space we are considering.\\n # Note that a failure to find any state does not necessarily indicate that\\n # term specifies an invalid operator. For example, if we are restricting\\n # ourselves to double excitations from a fixed reference state then the\\n # action of term on some of our basis states may lead to determinants with\\n # more than two excitations from the reference. These more than double\\n # excited determinants are not included in the matrix representation (and\\n # hence, will not be present in state_array).\\n for _, state in enumerate(maybe_valid_states):\\n determinant = state_array[state, :]\\n target_determinant = determinant.copy()\\n\\n parity = 1\\n for i, _ in reversed(term):\\n area_to_check = target_determinant[0:i]\\n parity *= (-1)**numpy.sum(area_to_check)\\n\\n target_determinant[i] = not target_determinant[i]\\n\\n int_encoding = target_determinant.dot(\\n 1 << numpy.arange(target_determinant.size)[::-1])\\n\\n target_state_index_sorted = numpy.searchsorted(int_state_array,\\n int_encoding,\\n sorter=sorting_indices)\\n\\n target_state = sorting_indices[target_state_index_sorted]\\n\\n if int_state_array[target_state] == int_encoding:\\n # Then target state is in the space considered:\\n data.append(parity)\\n row_ind.append(target_state)\\n col_ind.append(state)\\n\\n data = numpy.asarray(data)\\n row_ind = numpy.asarray(row_ind)\\n col_ind = numpy.asarray(col_ind)\\n\\n term_op = scipy.sparse.csc_matrix((data, (row_ind, col_ind)), shape=shape)\\n\\n return term_op\",\n \"def _parse_TF(token):\\n if token and token.lower() in ('true', 't', 'on', 'yes', '1'):\\n return True\\n elif token and token.lower() in ('false', 'f', 'off', 'no', '0'):\\n return False\\n else:\\n raise SyntaxError('invalid value')\",\n \"def parse_let(self, words):\\n\\n let_obj = Let()\\n obj_var = self.prim_parser.parse_var(words[0])\\n if obj_var:\\n let_obj.var = obj_var\\n if words[1] == '=':\\n rest = words[2:]\\n rest_str = ' '.join(words[2:])\\n arith_expr_obj = self.prim_parser.parse_arith_expr(rest_str)\\n prim_obj = self.prim_parser.parse_primative_obj(rest_str)\\n\\n if arith_expr_obj:\\n let_obj.value = arith_expr_obj\\n elif prim_obj:\\n let_obj.value = prim_obj\\n else:\\n raise StatementParseError(\\n 'Invalid args for LET {0} = {1}'.format(\\n words[0], rest))\\n else:\\n raise StatementParseError(\\n 'Invalid syntax for LET: {0}'.format(' '.join(words)))\\n else:\\n raise StatementParseError(\\n 'Invalid syntax for LET: {0} not variable.'.format(words[0]))\\n\\n return let_obj\",\n \"def tag_terms(text, terms, nlp=None):\\n from spacy.lang.en.stop_words import STOP_WORDS\\n spacy.tokens.token.Token.set_extension('workaround', default='', force=True)\\n \\n HEURISTIC_TOKENS = [\\\"-\\\", \\\"plant\\\", \\\"substance\\\", \\\"atom\\\"]\\n \\n # default to Stanford NLP pipeline wrapped in Spacy\\n if nlp is None:\\n snlp = stanfordnlp.Pipeline(lang=\\\"en\\\")\\n nlp = StanfordNLPLanguage(snlp)\\n \\n # preprocess with spacy if needed\\n if type(terms[0]) != spacy.tokens.doc.Doc:\\n terms = [nlp(term) for term in terms]\\n if (type(text) != spacy.tokens.doc.Doc and type(text) != spacy.tokens.span.Span):\\n text = nlp(text)\\n \\n # set up a custom representation of the text where we can add term type annotations\\n for token in text:\\n token._.workaround = token.text_with_ws\\n\\n lemmatized_text = [token.lemma_ for token in text]\\n tokenized_text = [token.text for token in text]\\n tags = ['O'] * len(text)\\n found_terms = defaultdict(lambda: {\\\"text\\\": [], \\\"indices\\\": [], \\\"pos\\\": [], \\\"type\\\": []})\\n \\n # iterate through terms from longest to shortest\\n terms = sorted(terms, key=len)[::-1]\\n for spacy_term in terms:\\n term_length = len(spacy_term)\\n lemma_term_list = [token.lemma_ for token in spacy_term]\\n text_term_list = [token.text for token in spacy_term]\\n term_lemma = \\\" \\\".join(lemma_term_list)\\n \\n # skip short acronyms that can cause problems\\n if len(term_lemma) <= 2:\\n continue\\n \\n # additional check to check for simple plural of uncommon biology terms\\n match_uncommon_plural = lemma_term_list.copy()\\n match_uncommon_plural[-1] = match_uncommon_plural[-1] + \\\"s\\\"\\n\\n # additional check using heuristics on lemmatized version\\n match_heuristic = []\\n if lemma_term_list[0] not in HEURISTIC_TOKENS:\\n for token in lemma_term_list:\\n if token not in HEURISTIC_TOKENS:\\n match_heuristic += token.split(\\\"-\\\")\\n heuristic_length = len(match_heuristic)\\n else:\\n heuristic_term = lemma_term_list\\n heuristic_length = len(lemma_term_list)\\n \\n for ix in range(len(text) - term_length):\\n \\n heuristic_match = (lemmatized_text[ix:ix + heuristic_length] == match_heuristic)\\n plural_match = (lemmatized_text[ix:ix + term_length] == match_uncommon_plural)\\n lemma_match = (lemmatized_text[ix:ix + term_length] == lemma_term_list)\\n text_match = (tokenized_text[ix:ix + term_length] == text_term_list)\\n lower_match = ([t.lower() for t in tokenized_text[ix:ix + term_length]] ==\\n [t.lower() for t in text_term_list])\\n \\n # Only match on text if lemmatized version is a stop word (i.e. lower casing acronym)\\n if term_lemma in STOP_WORDS:\\n valid_match = text_match\\n else:\\n valid_match = heuristic_match or plural_match or text_match or lemma_match or lower_match\\n \\n if valid_match:\\n \\n if heuristic_match and not lemma_match:\\n match_length = heuristic_length\\n else:\\n match_length = term_length\\n \\n term_text = \\\" \\\".join([t.text for t in text[ix:ix + match_length]])\\n term_tag = \\\" \\\".join([t.tag_ for t in text[ix:ix + match_length]])\\n \\n # only tag term if not part of larger term\\n if tags[ix:ix + match_length] == [\\\"O\\\"] * match_length:\\n \\n # classify term type\\n term_type = determine_term_type(spacy_term)\\n \\n # collect term information\\n found_terms[term_lemma][\\\"text\\\"].append(term_text)\\n found_terms[term_lemma][\\\"indices\\\"].append((ix, ix + match_length))\\n found_terms[term_lemma][\\\"pos\\\"].append(term_tag)\\n found_terms[term_lemma][\\\"type\\\"].append(term_type)\\n \\n # update sentence tags\\n tags = tag_bioes(tags, ix, match_length)\\n \\n # annotate token representations with term type\\n text[ix]._.workaround = f\\\"<{term_type}>\\\" + text[ix]._.workaround\\n end_ix = ix + match_length - 1\\n if text[end_ix]._.workaround.endswith(\\\" \\\"):\\n text[end_ix]._.workaround = text[end_ix]._.workaround[:-1] + f\\\"</{term_type}> \\\"\\n else:\\n text[end_ix]._.workaround += f\\\"</{term_type}>\\\"\\n \\n # reconstruct fully annotated input text\\n annotated_text = \\\"\\\"\\n for token in text:\\n annotated_text += token._.workaround\\n \\n return {\\n \\\"tokenized_text\\\": tokenized_text, \\n \\\"tags\\\": tags, \\n \\\"annotated_text\\\": annotated_text,\\n \\\"found_terms\\\": dict(found_terms)\\n }\",\n \"def __init__(\\n self, \\n *, \\n polars_term = None, \\n is_literal: bool = False,\\n is_column: bool = False,\\n is_series: bool = False,\\n lit_value = None,\\n ) -> None:\\n assert isinstance(is_literal, bool)\\n assert isinstance(is_column, bool)\\n assert isinstance(is_series, bool)\\n assert (is_literal + is_column + is_series) <= 1\\n if lit_value is not None:\\n assert is_literal\\n self.lit_value = lit_value\\n self.polars_term = polars_term\\n self.is_literal = is_literal\\n self.is_column = is_column\\n self.is_series = is_series\",\n \"def testTermInstantiation(self):\\n \\n action = Parser.parse_as(normalized_drive.split(\\\"\\\\n\\\"), Action, self.domain)\\n term = Builder(action)(\\\"location-of\\\", \\\"?t\\\")\\n action.instantiate({\\\"?from\\\" : term})\\n pre2 = action.precondition.copy(copy_instance=True)\\n self.assertEqual(pre2.pddl_str(), \\\"(and (= (location-of ?t) (location-of ?t)) (= (city-of (location-of ?t)) ?c) (= (city-of ?to) ?c))\\\")\\n action.uninstantiate()\",\n \"def _create_next_term(cls,\\n context: 'IconScoreContext',\\n prev_term: Optional['Term']) -> 'Term':\\n new_preps: List['PRep'] = context.preps.get_preps(\\n start_index=0, size=context.main_and_sub_prep_count)\\n\\n sequence = 0 if prev_term is None else prev_term.sequence + 1\\n start_block_height = context.block.height + 1\\n if prev_term:\\n assert start_block_height == prev_term.end_block_height + 1\\n\\n # The current P-Rep term is over. Prepare the next P-Rep term\\n if context.revision < Revision.SET_IREP_VIA_NETWORK_PROPOSAL.value:\\n irep: int = cls._calculate_weighted_average_of_irep(new_preps[:context.main_prep_count])\\n else:\\n irep: int = context.inv_container.irep\\n\\n term = Term(\\n sequence,\\n start_block_height,\\n context.term_period,\\n irep,\\n context.total_supply,\\n context.preps.total_delegated\\n )\\n\\n term.set_preps(new_preps, context.main_prep_count, context.main_and_sub_prep_count)\\n\\n return term\",\n \"def create_operator(statement_a, operator, statement_b):\\n return S(statement_a=statement_a, operator=operator, statement_b=statement_b)\",\n \"def is_lval(t):\\n if not t:\\n return False\\n i = iter(t)\\n if i.next() not in IDENTIFIER_START:\\n return False\\n return all(e in IDENTIFIER_PART for e in i)\",\n \"def from_string(cls, compound_term_string):\\n compound_term_string = compound_term_string.replace(\\\" \\\", \\\"\\\")\\n subterms, connector, intervals = cls.parse_toplevel_subterms_and_connector(compound_term_string)\\n return cls(subterms, connector,intervals=intervals)\",\n \"def AddTreeTerm(con, cur, termid, parentid, ontologynameid, commit=True):\\n try:\\n # test if already exists\\n cur.execute('SELECT uniqueId FROM OntologyTreeStructureTable WHERE (ontologyId=%s AND ontologyParentId=%s AND ontologyNameId=%s) LIMIT 1', [termid, parentid, ontologynameid])\\n if cur.rowcount > 0:\\n sid = cur.fetchone()[0]\\n debug(2, 'Tree entry exists (%d). returning it' % sid)\\n return '', sid\\n # does not exist - lets add it\\n cur.execute('INSERT INTO OntologyTreeStructureTable (ontologyId,ontologyParentId,ontologyNameId) VALUES (%s,%s,%s) RETURNING uniqueId', [termid, parentid, ontologynameid])\\n sid = cur.fetchone()[0]\\n return '', sid\\n except psycopg2.DatabaseError as e:\\n debug(7, \\\"error %s enountered in ontology.AddTreeTerm\\\" % e)\\n return \\\"error %s enountered in ontology.AddTreeTerm\\\" % e, -2\",\n \"def parseTerms(cmds):\\n if len(cmds) != 0:\\n print(\\\"Term\\\")\\n delimit = \\\"[*|/|%]+\\\"\\n factors = re.split(delimit, cmds[0])\\n parseFactors(cmds[0])\\n parseTerms(cmds[1:])\",\n \"def test_build_from_info():\\n terms = [Intercept(),\\n LinearTerm(0),\\n SplineTerm(0),\\n FactorTerm(0),\\n TensorTerm(0,1)]\\n\\n for term in terms:\\n assert Term.build_from_info(term.info) == term\\n\\n assert te(0, 1) == TensorTerm(SplineTerm(0, n_splines=10), SplineTerm(1, n_splines=10))\",\n \"def parse(seq):\\n\\tdef eval_expr(z, list):\\n\\t\\treturn reduce(lambda s, (f, x): f(s, x), list, z)\\n\\tunarg = lambda f: lambda x: f(*x)\\n\\tconst = lambda x: lambda _: x # like ^^^ in Scala\\n\\n\\ttokval = lambda x: x.value # returns the value of a token\\n\\top = lambda s: a(Token('Op', s)) >> tokval # return the value if token is Op\\n\\top_ = lambda s: skip(op(s)) # checks if token is Op and ignores it\\n\\ttoktype = lambda t: some(lambda x: x.type == t) >> tokval # checks type of token\\n\\tdef lst(h,t):\\n\\t\\treturn [h,] + t\\n\\tcall = lambda x: Call(x[0], x[1])\\n\\n\\tmakeop = lambda s, f: op(s) >> const(f)\\n\\n\\tadd = makeop('+', Plus)\\n\\tsub = makeop('-', Minus)\\n\\tmul = makeop('*', Times)\\n\\tdiv = makeop('/', Div)\\n\\n\\tdef make_const(i):\\n\\t\\treturn const(int(i))\\n\\n\\tnumber = toktype('Number') >> Const\\n\\n\\tmul_op = mul | div\\n\\tadd_op = add | sub\\n\\n\\tfactor = with_forward_decls(lambda:\\n\\t\\tnumber | op_('(') + exp + op_(')') | call)\\n\\tterm = factor + many(mul_op + factor) >> unarg(eval_expr)\\n\\texp = term + many(add_op + term) >> unarg(eval_expr)\\n\\texp_lst = with_forward_decls(lambda:\\n\\t\\texp + many(op_(',') + exp) >> unarg(lst))\\n\\tcall = toktype('Name') + op_('(') + exp_lst + op_(')') >> call\\n\\n\\treturn exp.parse(seq)\",\n \"def andExpr( ): #DOUBLE CHECK THIS\\n\\n\\ttok = tokens.peek( )\\n\\tif debug: print(\\\"andExpr: \\\", tok)\\n\\tleft = relationalExpr( ) #does the left side of the grammar\\n\\ttok = tokens.peek( )\\n\\twhile tok == \\\"and\\\": #checks to see if there is the token \\\"and\\\" and will preform what is inside the curly bracket since it is a series \\n\\t\\ttokens.next()\\n\\t\\tright = relationalExpr( )\\n\\t\\tleft = BinaryExpr(tok, left, right)#MIGHT HAVE TO CHANGE TO STRING \\n\\t\\ttok = tokens.peek( )\\n\\treturn left\",\n \"def _eval_atom(self, vars, word):\\n if word == \\\"null\\\":\\n return None\\n elif word == \\\"true\\\":\\n return True\\n elif word == \\\"false\\\":\\n return False\\n elif word.startswith(\\\"$\\\"):\\n return vars[word[1:]]\\n (instr, arg) = word.split(\\\":\\\")\\n if instr == \\\"int\\\":\\n return int(arg)\\n elif instr == \\\"float\\\":\\n return float(arg)\\n elif instr == \\\"id\\\":\\n return uuid.UUID(arg.zfill(32))\\n elif instr == \\\"blob\\\":\\n return bytearray.fromhex(arg)\\n elif instr == \\\"str\\\":\\n return arg\\n else:\\n raise NotAnAtom()\",\n \"def _parse_token(token: str):\\r\\n if token in OPERATOR_TOKENS:\\r\\n return Operator(token)\\r\\n if token.isdigit():\\r\\n return Number(int(token))\\r\\n if \\\".\\\" in token:\\r\\n if token.count(\\\".\\\") > 1 or token[-1] == '.':\\r\\n raise BadNumber(token)\\r\\n return Number(float(token))\\r\\n if token == \\\"i\\\":\\r\\n return ComplexNumber(0, 1)\\r\\n if token.isalpha():\\r\\n return Variable(token)\\r\\n raise UnknownToken(token)\",\n \"def normalize(term):\\n if isinstance(term, spacy.tokens.token.Token):\\n return term.text if term.pos_ == 'PROPN' else term.lemma_\\n elif isinstance(term, spacy.tokens.span.Span):\\n return ' '.join(word.text if word.pos_ == 'PROPN' else word.lemma_\\n for word in term)\\n else:\\n msg = \\\"Normalization requires a Token or Span, not {}.\\\".format(type(term))\\n raise TypeError(msg)\",\n \"def tf(term, document, algorithm=\\\"RAW\\\"):\\n\\n if algorithm == \\\"RAW\\\":\\n return tf_raw(term, document)\\n elif algorithm == \\\"BOOL\\\":\\n return tf_bool(term, document)\\n elif algorithm == \\\"LOG\\\":\\n return tf_log(term, document)\\n else:\\n raise ValueError(\\\"tf cannot use algorithm %s\\\" % algorithm)\",\n \"def _digest_atom(raw_token: RawToken) -> Token:\\n\\n # Is this a preposition\\n try:\\n return Token(\\n kind=TokenKind.PREPOSITION,\\n value=Preposition(raw_token.value),\\n location=raw_token.location,\\n )\\n except ValueError:\\n pass\\n\\n # Is this an integer value?\\n try:\\n return Token(\\n kind=TokenKind.NUMBER,\\n value=int(raw_token.value),\\n location=raw_token.location,\\n )\\n except ValueError:\\n pass\\n\\n # A float?\\n try:\\n return Token(\\n kind=TokenKind.NUMBER,\\n value=float(raw_token.value),\\n location=raw_token.location,\\n )\\n except ValueError:\\n pass\\n\\n # A duration?\\n duration_match = RE_DURATION.match(raw_token.value)\\n if duration_match is not None:\\n total_length = (\\n int(duration_match.group(1) or '0') * 24 * 60 * 60 +\\n int(duration_match.group(2) or '0') * 60 * 60 +\\n int(duration_match.group(3) or '0') * 60 +\\n int(duration_match.group(4) or '0')\\n )\\n return Token(\\n kind=TokenKind.DURATION,\\n value=total_length,\\n location=raw_token.location,\\n )\\n\\n # A literal?\\n try:\\n kind, value = LITERALS[raw_token.value]\\n return Token(\\n kind=kind,\\n value=value,\\n location=raw_token.location,\\n )\\n except KeyError:\\n pass\\n\\n # Pass through, split by dots\\n return Token(\\n kind=TokenKind.ATOM,\\n value=raw_token.value.split('.'),\\n location=raw_token.location,\\n )\",\n \"def potential_multi_term(tagged) :\\n res = True\\n for tag in tagged :\\n res = res and stemgrammar(tag)\\n return res\",\n \"def from_string_expr(cls, expr):\\n if \\\"*\\\" in expr:\\n ch = \\\"*\\\"\\n op = \\\"cross\\\"\\n elif \\\"+\\\" in expr:\\n ch = \\\"+\\\"\\n op = \\\"blend\\\"\\n elif \\\"/\\\" in expr:\\n ch = \\\"/\\\"\\n op = \\\"nest\\\"\\n factors = [cls(s.strip()) for s in expr.split(ch)]\\n return cls(op=op, factors=factors)\",\n \"def terminal_node(\\n self,\\n expr: Any = None,\\n ) -> None:\\n self.data.append(\\n {\\n \\\"type\\\": \\\"TERMINAL\\\",\\n \\\"expr\\\": expr,\\n \\\"id\\\": len(\\n self.data,\\n ),\\n }\\n )\",\n \"def get_american_term_definition(word: str) -> str:\\n word = process_word(word)\\n return AMERICAN_ENGLISH_ONLY_TERMS[word]\",\n \"def parse_go_term(term):\\n\\n id_pattern = re.compile(r\\\"^id:\\\\s+(GO:[0-9]+)\\\\s+\\\", re.M)\\n is_a_pattern = re.compile(r\\\"^is_a:\\\\s+(.*?) !\\\", re.M)\\n\\n id_parse = re.findall(id_pattern, term)\\n is_a_parse = re.findall(is_a_pattern, term)\\n\\n return id_parse, is_a_parse\",\n \"def var_or_atomic():\\n return (var() | atomic()).expect('var_or_atomic')\",\n \"def literal(self, tree: lark.Tree) -> Result:\\n if len(tree.children) != 1:\\n raise CELSyntaxError(\\n f\\\"{tree.data} {tree.children}: bad literal node\\\",\\n line=tree.meta.line,\\n column=tree.meta.column,\\n\\n )\\n value_token = cast(lark.Token, tree.children[0])\\n try:\\n result: Result\\n if value_token.type == \\\"FLOAT_LIT\\\":\\n result = celpy.celtypes.DoubleType(value_token.value)\\n elif value_token.type == \\\"INT_LIT\\\":\\n result = celpy.celtypes.IntType(value_token.value)\\n elif value_token.type == \\\"UINT_LIT\\\":\\n if not value_token.value[-1].lower() == 'u':\\n raise CELSyntaxError(\\n f\\\"invalid unsigned int literal {value_token!r}\\\",\\n line=tree.meta.line,\\n column=tree.meta.column,\\n )\\n result = celpy.celtypes.UintType(value_token.value[:-1])\\n elif value_token.type in (\\\"MLSTRING_LIT\\\", \\\"STRING_LIT\\\"):\\n result = celstr(value_token)\\n elif value_token.type == \\\"BYTES_LIT\\\":\\n result = celbytes(value_token)\\n elif value_token.type == \\\"BOOL_LIT\\\":\\n result = (\\n celpy.celtypes.BoolType(value_token.value.lower() == \\\"true\\\")\\n )\\n elif value_token.type == \\\"NULL_LIT\\\":\\n result = None\\n else:\\n raise CELUnsupportedError(\\n f\\\"{tree.data} {tree.children}: type not implemented\\\",\\n line=value_token.line,\\n column=value_token.column,\\n )\\n except ValueError as ex:\\n result = CELEvalError(ex.args[0], ex.__class__, ex.args, tree=tree)\\n\\n return result\",\n \"def __init__(self, term=None, coefficient=1.0):\\n self.terms = {}\\n if term is not None:\\n term, parity = _sort_majorana_term(term)\\n self.terms[term] = coefficient * (-1)**parity\",\n \"def makeShellType(tag, keyword, G):\\n sid = G(\\\"%sID\\\" % keyword)\\n string = \\\"<%s\\\" % tag\\n if sid:\\n string += ' shellid\\\"=%s-%s\\\"' % (NODEID, sid)\\n string += \\\">\\\"\\n string += \\\"<PrincipalQuantumNumber>%s</PrincipalQuantumNumber>\\\" % G(\\\"%sPrincipalQN\\\" % keyword)\\n\\n string += \\\"<OrbitalAngularMomentum>\\\"\\n string += \\\"<Value>%s</Value>\\\" % G(\\\"%sOrbitalAngMom\\\" % keyword)\\n symb = G(\\\"%sOrbitalAngMomSymbol\\\" % keyword)\\n if symb:\\n string += \\\"<Symbol>%s</Symbol>\\\" % symb\\n string += \\\"</OrbitalAngularMomentum>\\\"\\n string += \\\"<NumberOfElectrons>%s</NumberOfElectrons>\\\" % G(\\\"%sNumberOfElectrons\\\" % keyword)\\n string += \\\"<Parity>%s</Parity>\\\" % G(\\\"%sParity\\\" % keyword)\\n string += \\\"<Kappa>%s</Kappa>\\\" % G(\\\"%sKappa\\\" % keyword)\\n string += \\\"<TotalAngularMomentum>%s</TotalAngularMomentum>\\\" % G(\\\"%sTotalAngularMomentum\\\" % keyword)\\n string += makeTermType(\\\"ShellTerm\\\", \\\"%sTerm\\\" % keyword, G)\\n string += \\\"</%s>\\\" % keyword\\n return string\",\n \"def tokenize(eq):\\n\\n def push(token):\\n if token != \\\"\\\":\\n if token[0].isdigit():\\n tokens.append(int(token))\\n else:\\n tokens.append(token)\\n\\n tokens = []\\n token = \\\"\\\"\\n\\n for t in eq:\\n if t == \\\" \\\":\\n push(token)\\n token = \\\"\\\"\\n if t == \\\"+\\\" or t == \\\"*\\\" or t == \\\"(\\\" or t == \\\")\\\":\\n push(token)\\n push(t)\\n token = \\\"\\\"\\n elif t.isdigit():\\n token += t\\n\\n push(token)\\n return tokens\",\n \"def _simpl_pono_term(term: Term, resolvers) -> Term:\\n\\n sums_dict = dict(term.sums)\\n other, wigner_3js = _parse_3js(term.amp)\\n jms, rels = _get_jms_rels(wigner_3js)\\n\\n new_other = _simpl_pono(\\n other, resolvers, sums_dict, jms, rels, sums_only=False\\n )\\n\\n new_amp = new_other * prod_(\\n i.expr for i in wigner_3js\\n )\\n\\n return Term(term.sums, new_amp, term.vecs)\",\n \"def create_expression(sv, tree): \\r\\n if not tree: return None # nothing to do\\r\\n o,A,B=tree\\r\\n\\r\\n if o==Obr: # bracketed expression: remove brackets \\r\\n return create_expression(sv, A) # RECURSIVE\\r\\n\\r\\n nam=tree_join(tree)\\r\\n verify_expression(tree, nam) # check name validity \\r\\n\\r\\n if nam in sv.Object and not sv.Object[nam].isnew: # don't replace existing name unless new user call\\r\\n nod=sv.Object[nam] # use old name \\r\\n return (nam, None, None) # replace expression with name \\r\\n \\r\\n nod=add_object(sv, nam) # create object (unless new user call)\\r\\n nod.isexpression=True\\r\\n nod.isnew=False # process only once\\r\\n \\r\\n # link expression (only for new nodes)\\r\\n if o==Comma: # special case: list: clause for each changing element\\r\\n li=[]\\r\\n for t in A:\\r\\n exprs=create_expression(sv, t) # RECURSIVE\\r\\n if exprs: li=li+[exprs]\\r\\n vlu=(Comma, li, None) # list of elements \\r\\n nod.clauses=[(Starttree,vlu)] # start clause for whole list ((Start, None, None), (Comma, li, None)) \\r\\n for t in li: # each term is a triplet\\r\\n if t and not is_fixed(t[0]):\\r\\n add_change_clause(sv, nod, t, vlu)\\r\\n\\r\\n return (nam, None, None) # name for the list\\r\\n\\r\\n # some sort of expression except a list\\r\\n exprsA=create_expression(sv, A)\\r\\n exprsB=create_expression(sv, B)\\r\\n vlu=(o, exprsA, exprsB) # reduce to a simple operation between two expressions \\r\\n\\r\\n # make start clauses, and change clause for non-fixed objects (do not repeat 'change')\\r\\n nod.clauses=[(Starttree, vlu)] # ((Start, None, None), vlu) \\r\\n if o in sv.Object and not is_fixed(o):\\r\\n add_change_clause(sv, nod, (o, None, None), vlu)\\r\\n if A and not is_fixed(A[0]):\\r\\n add_change_clause(sv, nod, exprsA, vlu)\\r\\n if B and B!=A and not is_fixed(B[0]):\\r\\n add_change_clause(sv, nod, exprsB, vlu)\\r\\n \\r\\n if o==Since: # special case: conditions for \\\"since\\\" \\r\\n pl=create_expression(sv, (Plus, exprsB, exprsA)) # RECURSIVE \\r\\n nod.clauses[-1]=((Change, pl, None), vlu) # when change(event+delay): (Since, exprsA, exprsB) \\r\\n add_change_clause(sv, nod, exprsB, vlu) # when change(event)...\\r\\n # n.b. changing delay during 'since' should have no effect\\r\\n \\r\\n return (nam, None, None) # replace expression with name \\r\",\n \"def create_equation(expr: Expr, var: Expr) -> Eq:\\n factor = Mul(\\n *(arg for arg in expr.args if isinstance(arg, Rational) or isinstance(arg, Pow))\\n )\\n\\n lhs = (expr / factor).subs({x3: x3_val})\\n rhs = (lmbda * var / factor).subs({x3: x3_val})\\n\\n return Eq(lhs, rhs)\",\n \"def getAtom(t, swipl):\\n return Atom.fromTerm(t, swipl)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6580291","0.61413693","0.6123516","0.60709804","0.6037164","0.59499276","0.5909678","0.57880825","0.5784058","0.5760817","0.5713413","0.56021833","0.5593748","0.556113","0.5538992","0.550548","0.5455731","0.5445209","0.5441471","0.54201454","0.5406824","0.5374939","0.5343486","0.5341943","0.53146803","0.529294","0.52360636","0.52273506","0.52126193","0.521064","0.5168171","0.5155264","0.5154346","0.51330054","0.5107875","0.5088269","0.508807","0.5079745","0.5046105","0.5029267","0.50172615","0.50169057","0.49785575","0.49746874","0.49711713","0.49665424","0.49663898","0.49349177","0.49113247","0.4901842","0.49010623","0.48969695","0.48948434","0.48841882","0.48841086","0.48634645","0.48614585","0.48489025","0.48403528","0.48364303","0.4831675","0.48306802","0.48237923","0.4819594","0.48147336","0.48074257","0.47945204","0.47809088","0.47768402","0.47601497","0.47595346","0.4753034","0.47336107","0.4732476","0.47324398","0.47287557","0.47257844","0.47207445","0.47140795","0.46945012","0.4693386","0.46837696","0.46694544","0.46612957","0.4641011","0.46397904","0.46325693","0.4631543","0.46222064","0.46173826","0.46090275","0.46067685","0.45891842","0.45856708","0.45780528","0.45774606","0.45752427","0.45743683","0.45737332","0.45736885"],"string":"[\n \"0.6580291\",\n \"0.61413693\",\n \"0.6123516\",\n \"0.60709804\",\n \"0.6037164\",\n \"0.59499276\",\n \"0.5909678\",\n \"0.57880825\",\n \"0.5784058\",\n \"0.5760817\",\n \"0.5713413\",\n \"0.56021833\",\n \"0.5593748\",\n \"0.556113\",\n \"0.5538992\",\n \"0.550548\",\n \"0.5455731\",\n \"0.5445209\",\n \"0.5441471\",\n \"0.54201454\",\n \"0.5406824\",\n \"0.5374939\",\n \"0.5343486\",\n \"0.5341943\",\n \"0.53146803\",\n \"0.529294\",\n \"0.52360636\",\n \"0.52273506\",\n \"0.52126193\",\n \"0.521064\",\n \"0.5168171\",\n \"0.5155264\",\n \"0.5154346\",\n \"0.51330054\",\n \"0.5107875\",\n \"0.5088269\",\n \"0.508807\",\n \"0.5079745\",\n \"0.5046105\",\n \"0.5029267\",\n \"0.50172615\",\n \"0.50169057\",\n \"0.49785575\",\n \"0.49746874\",\n \"0.49711713\",\n \"0.49665424\",\n \"0.49663898\",\n \"0.49349177\",\n \"0.49113247\",\n \"0.4901842\",\n \"0.49010623\",\n \"0.48969695\",\n \"0.48948434\",\n \"0.48841882\",\n \"0.48841086\",\n \"0.48634645\",\n \"0.48614585\",\n \"0.48489025\",\n \"0.48403528\",\n \"0.48364303\",\n \"0.4831675\",\n \"0.48306802\",\n \"0.48237923\",\n \"0.4819594\",\n \"0.48147336\",\n \"0.48074257\",\n \"0.47945204\",\n \"0.47809088\",\n \"0.47768402\",\n \"0.47601497\",\n \"0.47595346\",\n \"0.4753034\",\n \"0.47336107\",\n \"0.4732476\",\n \"0.47324398\",\n \"0.47287557\",\n \"0.47257844\",\n \"0.47207445\",\n \"0.47140795\",\n \"0.46945012\",\n \"0.4693386\",\n \"0.46837696\",\n \"0.46694544\",\n \"0.46612957\",\n \"0.4641011\",\n \"0.46397904\",\n \"0.46325693\",\n \"0.4631543\",\n \"0.46222064\",\n \"0.46173826\",\n \"0.46090275\",\n \"0.46067685\",\n \"0.45891842\",\n \"0.45856708\",\n \"0.45780528\",\n \"0.45774606\",\n \"0.45752427\",\n \"0.45743683\",\n \"0.45737332\",\n \"0.45736885\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72168934"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":79089,"cells":{"query":{"kind":"string","value":"Recursively calculate the syntactic complexity of the compound term. The connector adds 1 complexity, and the subterms syntactic complexities are summed as well."},"document":{"kind":"string","value":"def _calculate_syntactic_complexity(self):\n count = 0\n if self.connector is not None:\n count = 1 # the term connector\n for subterm in self.subterms:\n count = count + subterm._calculate_syntactic_complexity()\n return count"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _calculate_syntactic_complexity(self):\n count = 1 # the copula\n for subterm in self.subterms:\n count = count + subterm._calculate_syntactic_complexity()\n\n return count","def _calculate_complexity(workflow):\n complexity = estimate_complexity(workflow.type_, workflow.reana_specification)\n workflow.complexity = complexity\n Session.commit()\n return complexity","def complexity(self):\n n = 0\n ctx = self\n while ctx is not None:\n n += 1\n ctx = ctx.parent()\n return n","def simplify(term):\n simplified_term = term\n\n if isinstance(term,StatementTerm):\n simplified_term = StatementTerm(subject_term=simplify(term.get_subject_term()),\n predicate_term=simplify(term.get_predicate_term()),\n copula=term.get_copula(),\n interval=term.interval)\n elif isinstance(term,CompoundTerm):\n if term.connector == NALSyntax.TermConnector.Negation and \\\n len(term.subterms) == 1 and \\\n isinstance(term.subterms[0],CompoundTerm) and \\\n term.subterms[0].connector == NALSyntax.TermConnector.Negation :\n # (--,(--,(S --> P)) <====> (S --> P)\n # Double negation theorem. 2 Negations cancel out\n simplified_term = simplify(term.subterms[0].subterms[0]) # get the inner statement\n # elif NALSyntax.TermConnector.is_conjunction(term.connector):\n # #(&&,A,B..C)\n # new_subterms = []\n # new_intervals = []\n # for i in range(len(term.subterms)):\n # subterm = simplify(term.subterms[i])\n # if i < len(term.intervals): new_intervals.append(term.intervals[i])\n # if isinstance(subterm, CompoundTerm) and subterm.connector == term.connector:\n # # inner conjunction\n # new_subterms.extend(subterm.subterms)\n # new_intervals.extend(subterm.intervals)\n # else:\n # new_subterms.append(subterm)\n #\n # simplified_term = CompoundTerm(subterms=new_subterms,\n # term_connector=term.connector,\n # intervals=new_intervals)\n elif term.connector is NALSyntax.TermConnector.ExtensionalDifference:\n pass\n elif term.connector is NALSyntax.TermConnector.IntensionalDifference:\n pass\n elif term.connector is NALSyntax.TermConnector.ExtensionalImage:\n pass\n elif term.connector is NALSyntax.TermConnector.IntensionalImage:\n pass\n\n\n return simplified_term","def commands_complexity():\n complexity()","def cyclomaticComplexity (self):\n self.tarjan()\n return len(self.__edges) - len(self.__nodes) + 2 * len(self.__scc)","def __simplifyRecurse(self): # TODO make this work with ^\n # check if we're a + node, a * node, or a simple node\n if isinstance(self.poly, (int, float, Variable.Variable)):\n return self\n elif self.poly[0] == \"+\":\n self.__handlePowPlus()\n\n newPoly = Polynomial()\n newPoly.poly = [\"+\"]\n for branch in self.poly[1:]:\n simplifiedBranch = ensurePoly(branch).__simplifyRecurse()\n if not simplifiedBranch.isSimple():\n for additiveTerm in simplifiedBranch.poly[1:]:\n newPoly.poly.append(additiveTerm)\n else:\n newPoly.poly.append(simplifiedBranch)\n return newPoly\n elif self.poly[0] == \"*\":\n self.__handlePowTimes()\n\n nonSimple, simple = self.__partitionSimpleAndNonSimpleBranches()\n\n if len(nonSimple) == 0: # this means our * node gives a monomial!\n return Polynomial(input=self)\n else:\n # do the full distribution\n simplified = self.__distribute(nonSimple, simple)\n newPoly = Polynomial()\n newPoly.poly = [\"+\"]\n for branch in simplified.poly[1:]:\n recursive = ensurePoly(branch).__simplifyRecurse()\n if recursive.poly[0] == \"*\":\n newPoly.poly.append(recursive)\n elif recursive.poly[0] == \"+\":\n newPoly.poly.extend(recursive.poly[1:])\n return newPoly\n\n elif self.poly[0] == \"^\":\n # this case will only be hit when we have a ^ node as the root\n newPoly = Polynomial()\n newPoly.poly = [\"*\"]\n for _ in range(self.poly[2]):\n newPoly.poly.append(self.poly[1])\n\n simp = newPoly.__simplifyRecurse()\n return simp","def get_total_complexity(n):\n total = 0\n for i in range(1, n + 1):\n total += get_complexity(i)\n return total","def complexity(self):\n raise NotImplementedError()","def design_complexity(design: Design) -> int:\n diversity = 3 * len(design.required)\n abundance = 2 * sum(design.required.values())\n return diversity + abundance + design.additional","def calculate_compound_costs(self, recursive: bool = True):\n assert self.graph_handler\n if not self.start_compounds_set:\n raise RuntimeError(\"No start conditions given\")\n if len(self.graph_handler.graph.nodes) == 0:\n raise RuntimeError(\"No nodes in graph\")\n cmps_to_check = [n for n in self.graph_handler.graph.nodes if ';' not in n\n and n not in self.start_compounds]\n # # # Set all compounds to be checked to pseudo inf cost\n for cmp_id in cmps_to_check:\n self.compound_costs[cmp_id] = self._pseudo_inf\n # # # Dictionary for current run\n tmp_compound_costs: Dict[str, float] = {}\n # # # Determine convergence variables for while loop\n current_inf_count = sum(value == self._pseudo_inf for value in self.compound_costs.values())\n prev_inf_count = current_inf_count\n # # # Convergence criteria\n compound_costs_change = None\n compound_costs_opt_change = 1\n converged = False\n # # # Find paths until either no costs are unknown or the None count has not changed\n while (not converged):\n compound_costs_opt_change = 0\n print(\"Remaining Nodes:\", len(cmps_to_check))\n for tmp_start_node in self.start_compounds:\n # # # Loop over all nodes to be checked starting from start nodes\n for target in cmps_to_check:\n # # # Determine cost and path with dijkstra's algorithm\n tmp_cost, _ = nx.single_source_dijkstra(self.graph_handler.graph, tmp_start_node, target,\n cutoff=None, weight=self.__weight_func)\n # # # Check if the obtained cost is larger than infinity (pseudo_inf)\n # # # and continue with the next target if this is the case\n if (tmp_cost - self._pseudo_inf) > 0.0:\n continue\n # # # Add cost of the starting node\n tmp_cost += self.compound_costs[tmp_start_node]\n # # # Check for value in compound_costs dict and\n if (self.compound_costs[target] != self._pseudo_inf and\n 10e-6 < self.compound_costs[target] - tmp_cost):\n compound_costs_opt_change += 1\n # # # Not already set check\n if self.compound_costs[target] == self._pseudo_inf or (\n self.compound_costs != self._pseudo_inf and 10e-6 < self.compound_costs[target] - tmp_cost):\n # # # Not discovered in current run OR new tmp cost lower than stored cost\n if (target not in tmp_compound_costs.keys()):\n tmp_compound_costs[target] = tmp_cost\n elif (tmp_cost < tmp_compound_costs[target]):\n tmp_compound_costs[target] = tmp_cost\n # # # Write obtained compound_costs to overall dictionary\n for key, value in tmp_compound_costs.items():\n self.compound_costs[key] = value\n # # # Remove found nodes if recursive is false\n if not recursive:\n cmps_to_check.remove(key)\n # # # Reset tmp_pr_cost\n tmp_compound_costs = {}\n # # # Convergence Check\n current_inf_count = sum(value == self._pseudo_inf for value in self.compound_costs.values())\n compound_costs_change = prev_inf_count - current_inf_count\n prev_inf_count = current_inf_count\n\n print(50 * '-')\n print(\"Current None:\", current_inf_count)\n print(\"PR Change:\", compound_costs_change)\n print(\"PR Opt Change:\", compound_costs_opt_change)\n # # # Convergence Check\n if (compound_costs_change == 0 and compound_costs_opt_change == 0):\n converged = True\n\n # # # Final check if all compound costs are solved\n if current_inf_count == 0:\n self.compound_costs_solved = True","def complexity(self):\n complexity = 0\n for k in self.keys():\n for i, j in combinations(range(1, max(k) + 1), 2):\n seq = filter(lambda x: x == i or x == j, k)\n cpxty = len([p for p, q in pairwise(seq) if p != q])\n complexity = max(cpxty, complexity)\n return complexity","def complexity(self):\n from kinbaku._pygenie import gettype, getpath\n from kinbaku.python import Dotpath\n if not self.contents:\n return\n try:\n stats = measure_complexity(self.contents, self.fname)\n except SyntaxError:\n return None\n\n out = PrettyPrinter(StringIO()).flatten_stats(stats)\n out = [ [ gettype(_type),\n getpath(_type,dotpath),\n score ] for _type, dotpath, score in out ]\n return out","def calc_complexity_step(self, adj_ens, feat_ens, sizes_subg_ens):\n num_ensemble = len(feat_ens)\n dims_ens = []\n ops = 0\n for i in range(num_ensemble):\n if len(self.type_feature_augment) > 0:\n for ia, _ in enumerate(self.type_feature_augment): # this does not change feat dim\n ops += np.prod(list(self.aug_layers[i][ia].weight.shape)) * feat_ens[i].shape[0]\n dims_respool = []\n dims_conv = (layers.Dims_X(*(feat_ens[i].shape)), layers.Dims_adj(adj_ens[i].shape[0], adj_ens[i].size))\n for md in self.conv_layers[i]:\n dims_conv, _ops = md.complexity(*dims_conv)\n dims_respool.append(dims_conv[0])\n ops += _ops\n dims_emb, _ops = self.res_pool_layers[i].complexity(dims_respool, sizes_subg_ens)\n ops += _ops\n dims_ens.append(dims_emb)\n dims_cls, _ops = self.ensembler.complexity(dims_ens)\n ops += _ops\n _dims_final, _ops = self.classifier.complexity(dims_cls)\n ops += _ops\n return ops","def rational_function_coefficient_descent(rational_function, sigma, poly_ring):\n\n if rational_function.parent().is_field():\n S = rational_function.parent().ring()\n else:\n S = rational_function.parent()\n\n if rational_function == S(0):\n return poly_ring(0)\n\n num = S(rational_function.numerator())\n denom = S(rational_function.denominator())\n f = num.coefficients()\n fe = num.exponents()\n g = denom.coefficients()\n ge = denom.exponents()\n #force the cancellation of common coefficient factors by scaling by f[-1]\n ff = [ field_descent(sigma, x/f[-1]) for x in f]\n gg = [ field_descent(sigma, x/f[-1]) for x in g]\n if None in ff or None in gg:\n return\n\n z = poly_ring.gen(0)\n numer = sum( poly_ring(ff[i])*z**fe[i] for i in range(len(ff)) )\n denom = sum( poly_ring(gg[i])*z**ge[i] for i in range(len(gg)) )\n return numer / denom","def complexity(s, **kwargs):\n num, den = 1, 1\n for k in range(1, len(s)):\n k4 = 4**k # For DNA\n num += min(len(set(s[i:i+k] for i in range(len(s) - k + 1))), k4)\n den += min(len(s) - k + 1, k4)\n return num / den","def complexity(self) -> str:\n return pulumi.get(self, \"complexity\")","def parse_toplevel_subterms_and_connector(cls, compound_term_string):\n compound_term_string = compound_term_string.replace(\" \",\"\")\n subterms = []\n intervals = []\n internal_string = compound_term_string[1:-1] # string with no outer parentheses () or set brackets [], {}\n\n # check for intensional/extensional set [a,b], {a,b}\n connector = NALSyntax.TermConnector.get_term_connector_from_string(compound_term_string[0])\n if connector is None:\n # otherwise check for regular Term/Statement connectors\n if internal_string[1] == NALSyntax.StatementSyntax.TermDivider.value:\n connector_string = internal_string[0] # Term connector\n else:\n connector_string = internal_string[0:2] # Statement connector\n connector = NALSyntax.TermConnector.get_term_connector_from_string(connector_string)\n\n assert (internal_string[\n len(\n connector.value)] == NALSyntax.StatementSyntax.TermDivider.value), \"Connector not followed by comma in CompoundTerm string \" + compound_term_string\n internal_string = internal_string[len(connector.value) + 1:]\n\n assert (connector is not None), \"Connector could not be parsed from CompoundTerm string.\"\n\n depth = 0\n subterm_string = \"\"\n for i, c in enumerate(internal_string):\n if c == NALSyntax.StatementSyntax.Start.value or NALSyntax.TermConnector.is_set_bracket_start(c):\n depth += 1\n elif c == NALSyntax.StatementSyntax.End.value or NALSyntax.TermConnector.is_set_bracket_end(c):\n depth -= 1\n\n if c == NALSyntax.StatementSyntax.TermDivider.value and depth == 0:\n if subterm_string.isdigit():\n intervals.append(int(subterm_string))\n else:\n subterm = Term.from_string(subterm_string)\n subterms.append(subterm)\n subterm_string = \"\"\n else:\n subterm_string += c\n\n subterm = Term.from_string(subterm_string)\n subterms.append(subterm)\n\n return subterms, connector, intervals","def count_consonants_recursive(input):\n if len(input) == 0:\n return 0\n if input[0].lower() in consonants:\n return 1 + count_consonants_recursive(input[1:])\n else:\n return count_consonants_recursive(input[1:])","def complex_sum(c_1,c_2):\n return c_1 + c_2","def nth_order_const_coeff(*coeffs: List[Symbol], t: Symbol = t) -> Tuple[List[Symbol], Procedure]:\n\n # First, set up characteristic equation.\n char_eq_r, r = sympy.S.Zero, Dummy('r')\n\n for order, coeff in enumerate(coeffs[::-1]):\n char_eq_r += coeff * r ** order\n\n char_eq = Poly(char_eq_r, r)\n\n # Can't just call roots because it doesn't return rootof for unsolveable\n # polynomials.\n char_eq_roots = roots(char_eq, multiple=True)\n\n root_dict = defaultdict(int) # type: Dict[int, int]\n\n conjugate_roots = []\n for root in char_eq_roots:\n root_dict[root] += 1\n\n sols = []\n for root, mult in root_dict.items():\n for i in range(mult):\n if isinstance(root, RootOf):\n sols.append(t**i * exp(root*t))\n elif root.is_real:\n sols.append(t**i*exp(root*t))\n else:\n if root in conjugate_roots:\n continue\n reroot = re(root)\n imroot = im(root)\n conjugate_roots.append(conjugate(root))\n sols.append(t**i*exp(reroot*t) * sin(abs(imroot) * t))\n sols.append(t**i*exp(reroot*t) * cos(imroot * t))\n\n # collect roots for display\n p_roots = []\n count = 1\n for root, mult in root_dict.items():\n p_roots.append(Eq(Dummy('r_{}'.format(\n \",\".join([str(i) for i in range(count, count + mult)]))), root, evaluate=False))\n count += mult\n\n procedure = Procedure()\n procedure\\\n .text('Characteristic equation: ', nl=True)\\\n .eq(Eq(char_eq_r, 0, evaluate=False))\\\n .text('Roots: ')\\\n .equarr(p_roots)\\\n .text('General Solution: ', nl=True)\\\n .eq(Eq(Dummy('y'), to_general(sols)[0], evaluate=False))\n\n return sols, procedure","def _cmplx_add_ ( s , o ) :\n return o + complex ( s )","def __mul__(self, other, nested=False):\n\n other = formula(other, namespace=self.namespace)\n\n selftermnames = self.termnames()\n othertermnames = other.termnames()\n\n I = len(selftermnames)\n J = len(othertermnames)\n\n terms = []\n termnames = []\n\n for i in range(I):\n for j in range(J):\n termname = '%s*%s' % (str(selftermnames[i]), str(othertermnames[j]))\n pieces = termname.split('*')\n pieces.sort()\n termname = '*'.join(pieces)\n termnames.append(termname)\n\n selfnames = self.terms[i].names()\n othernames = other.terms[j].names()\n\n if self.terms[i].name is 'intercept':\n _term = other.terms[j]\n _term.namespace = other.namespace\n\n elif other.terms[j].name is 'intercept':\n _term = self.terms[i]\n _term.namespace = self.namespace\n else:\n names = []\n\n d1 = len(selfnames) \n d2 = len(othernames)\n\n for r in range(d1):\n for s in range(d2):\n name = '%s*%s' % (str(selfnames[r]), str(othernames[s]))\n pieces = name.split('*')\n pieces.sort()\n name = '*'.join(pieces)\n names.append(name)\n\n def product_func(value, d1=d1, d2=d2):\n\n out = []\n for r in range(d1):\n for s in range(d2):\n out.append(value[r] * value[d1+s])\n return N.array(out)\n\n sumterms = self + other\n sumterms.terms = [self, other] # enforce the order we want\n sumterms.namespace = self.namespace\n\n _term = quantitative(names, func=sumterms, termname=termname,\n transform=product_func)\n _term.namespace = self.namespace\n\n\n terms.append(_term)\n\n return formula(terms, namespace=self.namespace)","def simplify(self): # TODO too complex, refactor\n simplified = self.__simplifyRecurse()\n # distributed out the polynomial. Now need to collect like terms\n simplified.vars = self.vars.copy()\n orderedVars = sorted(list(self.vars))\n\n powers = {} # will have keys of tuples. The tuples will represent the power of a variable. Values will be the\n for monomial in simplified.poly[1:]:\n power = [0] * len(orderedVars)\n total = 0\n\n if monomial.isSimple():\n monomial.poly = [\"*\", monomial.poly]\n\n for term in monomial.poly[1:]:\n term = ensurePoly(term)\n if isinstance(term.poly, (int, float)):\n total += term.poly\n elif isinstance(term.poly, (Variable.Variable)):\n power[orderedVars.index(term.poly)] += 1\n\n power = tuple(power)\n if power not in powers:\n powers[power] = total\n else:\n powers[power] = min(total, powers[power])\n\n finalPoly = Polynomial()\n finalPoly.poly = [\"+\"]\n finalPoly.vars = self.vars.copy()\n for power in sorted(list(powers.keys())):\n monomial = Polynomial()\n monomial.poly = [\"*\"]\n if powers[power] != 0:\n monomial.poly.append(powers[power])\n\n for pow, ind in zip(power, range(len(power))):\n if pow == 0:\n continue\n elif pow == 1:\n monomial.poly.append(orderedVars[ind])\n else:\n monomial.poly.append(orderedVars[ind]**pow)\n finalPoly.poly.append(monomial)\n return finalPoly","def continued_fraction(a) -> list:\n e = _sympify(a)\n if all(i.is_Rational for i in e.atoms()):\n if e.is_Integer:\n return continued_fraction_periodic(e, 1, 0)\n elif e.is_Rational:\n return continued_fraction_periodic(e.p, e.q, 0)\n elif e.is_Pow and e.exp is S.Half and e.base.is_Integer:\n return continued_fraction_periodic(0, 1, e.base)\n elif e.is_Mul and len(e.args) == 2 and (\n e.args[0].is_Rational and\n e.args[1].is_Pow and\n e.args[1].base.is_Integer and\n e.args[1].exp is S.Half):\n a, b = e.args\n return continued_fraction_periodic(0, a.q, b.base, a.p)\n else:\n # this should not have to work very hard- no\n # simplification, cancel, etc... which should be\n # done by the user. e.g. This is a fancy 1 but\n # the user should simplify it first:\n # sqrt(2)*(1 + sqrt(2))/(sqrt(2) + 2)\n p, d = e.expand().as_numer_denom()\n if d.is_Integer:\n if p.is_Rational:\n return continued_fraction_periodic(p, d)\n # look for a + b*c\n # with c = sqrt(s)\n if p.is_Add and len(p.args) == 2:\n a, bc = p.args\n else:\n a = S.Zero\n bc = p\n if a.is_Integer:\n b = S.NaN\n if bc.is_Mul and len(bc.args) == 2:\n b, c = bc.args\n elif bc.is_Pow:\n b = Integer(1)\n c = bc\n if b.is_Integer and (\n c.is_Pow and c.exp is S.Half and\n c.base.is_Integer):\n # (a + b*sqrt(c))/d\n c = c.base\n return continued_fraction_periodic(a, d, c, b)\n raise ValueError(\n 'expecting a rational or quadratic irrational, not %s' % e)","def time_complexities():\n return \"Best Case: O(n), Average Case: O(n), Worst Case: O(n)\"","def countRecursiveReferences(self) -> Tuple[Dict[str, List[str]], Dict[str, Dict[str, int]]]:\n countReferences = {}\n isReferencedBy = {}\n for nt in self.non_terminals: # for each non-terminal in the grammar\n for production in self.grammar[nt]: # for each possible production on that non terminal\n count = {}\n for option in production.split(): # iterate over the production's terms\n count.setdefault(option, 0)\n if option in self.non_terminals: # if the term is a non terminal\n count[option] += 1 # the number of times that option has been referenced increases\n isReferencedBy.setdefault(option, set())\n isReferencedBy[option].add(nt)\n \n for key in count:\n count.setdefault(key, 0)\n countReferences.setdefault(key, {})\n countReferences[key].setdefault(nt, 0)\n\n countReferences[key][nt] = max(\n countReferences[key][nt], count[key]) # the number of references of the non terminal is for this\n # term is the maximum between all productions in this non terminal\n\n return isReferencedBy, countReferences","def __mul__(self, other, nested=False):\n\n other = Formula(other)\n\n selftermnames = self.termnames()\n othertermnames = other.termnames()\n\n I = len(selftermnames)\n J = len(othertermnames)\n\n terms = []\n termnames = []\n\n for i in range(I):\n for j in range(J):\n termname = '%s*%s' % (str(selftermnames[i]), str(othertermnames[j]))\n pieces = sorted(termname.split('*'))\n termname = '*'.join(pieces)\n termnames.append(termname)\n\n selfnames = self.terms[i].names()\n othernames = other.terms[j].names()\n\n if self.terms[i].name is 'intercept':\n _term = other.terms[j]\n _term.namespace = other.namespace\n elif other.terms[j].name is 'intercept':\n _term = self.terms[i]\n _term.namespace = self.namespace\n else:\n names = []\n\n d1 = len(selfnames)\n d2 = len(othernames)\n\n for r in range(d1):\n for s in range(d2):\n name = '%s*%s' % (str(selfnames[r]), str(othernames[s]))\n pieces = sorted(name.split('*'))\n name = '*'.join(pieces)\n names.append(name)\n\n def product_func(value, d1=d1, d2=d2):\n\n out = []\n for r in range(d1):\n for s in range(d2):\n out.append(value[r] * value[d1+s])\n return np.array(out)\n\n cself = copy.copy(self.terms[i])\n cother = copy.copy(other.terms[j])\n sumterms = cself + cother\n sumterms.terms = [cself, cother] # enforce the order we want\n\n _term = Quantitative(names, func=sumterms,\n termname=termname,\n transform=product_func)\n\n if _namespace_equal(self.namespace, other.namespace):\n _term.namespace = self.namespace\n\n terms.append(_term)\n\n return Formula(terms)","def test_complexity(tmp_path: Path, capsys) -> None:\n file_content = '\"\"\"Docstring.\"\"\"\\n\\n'\n program = \"\"\"\n elements = [open(str(i)) for i in range(10)]\n\n\n def foo():\n \\\"\\\"\\\"Docstring.\\\"\\\"\\\"\n if elements[0]:\n aaa = 1\n elif elements[1]:\n aaa = 1\n elif elements[2]:\n aaa = 1\n elif elements[3]:\n aaa = 1\n elif elements[4]:\n aaa = 1\n elif elements[5]:\n aaa = 1\n elif elements[6]:\n aaa = 1\n elif elements[7]:\n aaa = 1\n elif elements[8]:\n aaa = 1\n elif elements[9]:\n aaa = 1\n print(aaa)\n \"\"\"\n file_content += dedent(program)\n run_linter(tmp_path, capsys, file_content, \"'foo' is too complex (11)\")","def calc_process_cohesion(partitions, graph):\n ch = 0\n for part in partitions:\n crc = calc_community_relation_cohesion(part, graph)\n cic = calc_community_information_cohesion(part, graph)\n ch = ch + (crc * cic)\n ch = ch / len(partitions)\n return ch","def continued_fraction_reduce(cf):\n from sympy.solvers import solve\n\n period = []\n x = Dummy('x')\n\n def untillist(cf):\n for nxt in cf:\n if isinstance(nxt, list):\n period.extend(nxt)\n yield x\n break\n yield nxt\n\n a = S.Zero\n for a in continued_fraction_convergents(untillist(cf)):\n pass\n\n if period:\n y = Dummy('y')\n solns = solve(continued_fraction_reduce(period + [y]) - y, y)\n solns.sort()\n pure = solns[-1]\n rv = a.subs(x, pure).radsimp()\n else:\n rv = a\n if rv.is_Add:\n rv = factor_terms(rv)\n if rv.is_Mul and rv.args[0] == -1:\n rv = rv.func(*rv.args)\n return rv","def innerProd(linearCombo1, linearCombo2):\n innerProd = 0\n # TODO: I'm starting with simple sets on both sides, not sum of sets, \n # with coefficient 1. We need to fix this later\n # TODO: find way to represent dashed vs undashed arrows\n # For now, assume both are already sums (sets) of dashed subdiagrams\n\n # copy linear combinations to make it easier to alter them as needed\n linearComboCopy1 = deepcopy(linearCombo1)\n linearComboCopy2 = deepcopy(linearCombo2)\n print len(linearComboCopy2[0][1])\n\n # get list of subdiagrams, get coefficients\n for coeffAndSubdiagrams1 in linearComboCopy1:\n subdiagramSet1 = coeffAndSubdiagrams1[1]\n coeff1 = coeffAndSubdiagrams1[0]\n subdiagramsToRemove1 = []\n\n for coeffAndSubdiagrams2 in linearComboCopy2:\n subdiagramSet2 = coeffAndSubdiagrams2[1]\n coeff2 = coeffAndSubdiagrams2[0]\n subdiagramsToRemove2 = []\n\n # look for equivalent pairs of dashed subdiagrams in both lists\n for subdiagram1 in subdiagramSet1:\n for subdiagram2 in subdiagramSet2: \n # for equivalent pairs of dashed subdiagrams, increment innerProd by \n # product of coefficients and remove the subdiagrams to avoid \n # over-counting diagrams\n if equiv(subdiagram1, subdiagram2):\n innerProd += coeff1 * coeff2\n subdiagramsToRemove1.append(subdiagram1)\n subdiagramsToRemove2.append(subdiagram2)\n print \" \", innerProd\n # remove the used subdiagrams\n # print \"sub 2\\t\" + str(subdiagramSet2)\n # print \" 2 \" + str(subdiagramsToRemove2)\n # print \" 1 \" + str(subdiagramsToRemove1)\n for removal2 in subdiagramsToRemove2:\n # print \" remove \" + str(removal2)\n subdiagramSet2.remove(removal2)\n subdiagramsToRemove2 = []\n # for removal1 in subdiagramsToRemove1:\n # subdiagramSet1.remove(removal1) \n return innerProd","def number_of_connectives(formula):\n pass\n # ======== YOUR CODE HERE ========","def compute(n):\n if n == 1:\n return 1\n else:\n i = find_i(n)\n return 2 * compute(n - i) + 2 ** i - 1","def parse_algebra(self):\r\n # 0.33 or 7 or .34 or 16.\r\n number_part = Word(nums)\r\n inner_number = (number_part + Optional(\".\" + Optional(number_part))) | (\".\" + number_part)\r\n # pyparsing allows spaces between tokens--`Combine` prevents that.\r\n inner_number = Combine(inner_number)\r\n\r\n # SI suffixes and percent.\r\n number_suffix = MatchFirst(Literal(k) for k in SUFFIXES.keys())\r\n\r\n # 0.33k or 17\r\n plus_minus = Literal('+') | Literal('-')\r\n number = Group(\r\n Optional(plus_minus) +\r\n inner_number +\r\n Optional(CaselessLiteral(\"E\") + Optional(plus_minus) + number_part) +\r\n Optional(number_suffix)\r\n )\r\n number = number(\"number\")\r\n\r\n # Predefine recursive variables.\r\n expr = Forward()\r\n\r\n # Handle variables passed in. They must start with letters/underscores\r\n # and may contain numbers afterward.\r\n inner_varname = Word(alphas + \"_\", alphanums + \"_\")\r\n varname = Group(inner_varname)(\"variable\")\r\n varname.setParseAction(self.variable_parse_action)\r\n\r\n # Same thing for functions.\r\n function = Group(inner_varname + Suppress(\"(\") + expr + Suppress(\")\"))(\"function\")\r\n function.setParseAction(self.function_parse_action)\r\n\r\n atom = number | function | varname | \"(\" + expr + \")\"\r\n atom = Group(atom)(\"atom\")\r\n\r\n # Do the following in the correct order to preserve order of operation.\r\n pow_term = atom + ZeroOrMore(\"^\" + atom)\r\n pow_term = Group(pow_term)(\"power\")\r\n\r\n par_term = pow_term + ZeroOrMore('||' + pow_term) # 5k || 4k\r\n par_term = Group(par_term)(\"parallel\")\r\n\r\n prod_term = par_term + ZeroOrMore((Literal('*') | Literal('/')) + par_term) # 7 * 5 / 4\r\n prod_term = Group(prod_term)(\"product\")\r\n\r\n sum_term = Optional(plus_minus) + prod_term + ZeroOrMore(plus_minus + prod_term) # -5 + 4 - 3\r\n sum_term = Group(sum_term)(\"sum\")\r\n\r\n # Finish the recursion.\r\n expr << sum_term # pylint: disable=W0104\r\n self.tree = (expr + stringEnd).parseString(self.math_expr)[0]","def complexity(self, mode='#nodes'):\n if mode == '#nodes':\n return len(self.nodes)","def get_complexity(n):\n try:\n return complexity_map[n]\n except KeyError:\n if n - 1 in complexity_map:\n complexity_map[n] = complexity_map[n - 1] + 1\n for i in range(2, int(floor(n / 2) + 1)):\n if n % i == 0:\n complexity = get_complexity(i) + get_complexity(n / i)\n if n not in complexity_map or complexity < complexity_map[n]:\n complexity_map[n] = complexity\n return complexity_map[n]","def _AddCompound(self, kegg_id, how_many):\n i = self._FindCompoundIndex(kegg_id)\n if i is not None:\n self.reactants[i].coeff += how_many\n else:\n self.reactants += [CompoundWithCoeff.FromId(how_many, kegg_id)]\n \n # clear the cache since the reaction has changed\n self._catalyzing_enzymes = None","def test_linear_comb() -> None:\n SumStr = FormalLinearCombination(\n str, complex, complex(0, 0), lambda z1, z2: z1+z2)\n flc_1a2b3c = SumStr(\n [(complex(1, 0), \"a\"), (complex(2, 0), \"b\"), (complex(3, 0), \"c\")])\n assert str(flc_1a2b3c) == \"(1+0j)*a+(2+0j)*b+(3+0j)*c\"\n two_flc_1a2b3c = flc_1a2b3c+flc_1a2b3c\n exp_two_flc_1a2b3c = SumStr(\n [(complex(2, 0), \"a\"), (complex(4, 0), \"b\"), (complex(6, 0), \"c\")])\n assert str(two_flc_1a2b3c) == \"(2+0j)*a+(4+0j)*b+(6+0j)*c\"\n assert exp_two_flc_1a2b3c == two_flc_1a2b3c\n assert str(flc_1a2b3c*flc_1a2b3c) == \"(1+0j)*aa+(2+0j)*ab+(3+0j)*ac\"+\\\n \"+(2+0j)*ba+(4+0j)*bb+(6+0j)*bc\"+\\\n \"+(3+0j)*ca+(6+0j)*cb+(9+0j)*cc\"","def solve_part2(input, verbose=False):\n equations = parse(input)\n\n result = []\n for eq in equations:\n result.append(solve_equation_addition_precendence(eq, verbose))\n\n if verbose:\n print(f\"results: {result}\")\n\n return sum(result)","def concretise_ast(node):\n node.children = list(node.get_children())\n\n for child in node.children:\n counter = concretise_ast(child)","def cosh(self):\n return type(self)(self.parent(),\n self._simplify(self._express.cosh()))","def calculate (self,phrase):\r\n\r\n\r\n def bracketed (phrase,bracketing='()'):\r\n\r\n \"\"\"Returns TRUE if <phrase> is encompassed by a left bracket and a right bracket\r\n at the same hierarchical level\"\"\"\r\n\r\n level = 0\r\n left_point = None\r\n right_point = None\r\n \r\n\r\n for count,char in enumerate(phrase):\r\n\r\n if char == bracketing[0]:\r\n if level == 0:\r\n left_point = count\r\n level+=1\r\n if char == bracketing[1]:\r\n level-=1\r\n if level == 0:\r\n right_point = count\r\n if not (left_point is None) and (not right_point is None) and left_point == 0 and right_point == len(phrase)-1:\r\n return True\r\n return False\r\n\r\n def quoted (phrase):\r\n\r\n level = 0\r\n foundchar = ''\r\n left_point = None\r\n right_point = None \r\n for count,char in enumerate(phrase):\r\n\r\n if char in ['\"',\"'\"] and level == 0:\r\n foundchar = char\r\n left_point = count\r\n level += 1\r\n elif level == 1 and char == foundchar:\r\n right_point = count\r\n level += 1\r\n if not (left_point is None) and (not right_point is None) and left_point == 0 and right_point == len(phrase)-1:\r\n return True\r\n return False \r\n \r\n \r\n\r\n def is_function(phrase):\r\n\r\n \"\"\"Tests to see if a phrase begins with a predefined function,\r\n in which case it returns information about the iarity of function\"\"\"\r\n \r\n \r\n for x in self.functions.keys():\r\n\r\n if len(x) < len(phrase) and phrase[0:len(x)] == x:\r\n if bracketed(phrase[len(x):]):\r\n if self.functions[x][1]-1 <= phrase.count(',') <= self.functions[x][2]-1:\r\n return x, self.functions[x][0], self.functions[x][2], phrase[len(x):]\r\n else:\r\n return False,False,False,False \r\n \r\n\r\n def all_simple (phrase):\r\n\r\n \"\"\"Tests if a phrase is a simple string representing an expression, rather than an operation\"\"\"\r\n\r\n\r\n for x in phrase:\r\n if (x not in self.operations and not (isinstance(x,(int,type(ListType()),float,bool) or (isinstance(x,str) and quoted(x)))) or self.current_register.contains(x)):\r\n return False\r\n return True\r\n \r\n def parse (phrase):\r\n\r\n \r\n COMPTERMS = ['==','>=','<=','!=','>','<',]\r\n\r\n\r\n def contains_comp (x):\r\n \"\"\"True is x contains any of the COMP Terms\"\"\"\r\n\r\n for comp in COMPTERMS:\r\n if comp in x:\r\n return True\r\n return False\r\n\r\n\r\n \r\n \"\"\"Parses and analzes the phrase\"\"\"\r\n\r\n \r\n if phrase in ['bTrue','bFalse','EmptyList']:\r\n return {'bTrue':True,\r\n 'bFalse':False,\r\n 'EmptyList':ListType()}[phrase]\r\n\r\n if isinstance(phrase,str):\r\n \r\n if quoted(phrase):\r\n return phrase\r\n else:\r\n try:\r\n return float(phrase)\r\n except:\r\n pass\r\n \r\n\r\n # If the phrase is a string\r\n phrase = phrase.strip()\r\n\r\n func_name, func, iarity, func_phrase = is_function(phrase)\r\n # tests is it is function; otherwise the values are false.\r\n \r\n \r\n\r\n if func_name:\r\n if iarity == 1:\r\n # If the function accepts one value\r\n return func(parse(func_phrase))\r\n if iarity == 2:\r\n # Two values \r\n func_phrase = func_phrase[1:-1]\r\n term1,term2 = func_phrase.split(',')[0],func_phrase.split(',')[1]\r\n return func(parse(term1),parse(term2))\r\n if iarity == 3:\r\n func_phrase = func_phrase[1:-1]\r\n term1,term2, term3 = func_phrase.split(',')[0],func_phrase.split(',')[1],func_phrase.split(',')[2]\r\n return func(parse(term1),parse(term2),parse(term3))\r\n \r\n if iarity >3:\r\n # A list of values \r\n func_phrase = func_phrase[1:-1]\r\n return func([parse(x) for x in func_phrase.split(',')])\r\n elif phrase and phrase[0] == '-' and bracketed(phrase[1:]):\r\n # Translates negative sign (as opposed to operators) into corresponding function \r\n return -parse(phrase[2:-1])\r\n\r\n\r\n elif bracketed(phrase):\r\n # removes top-level bracket\r\n phrase = phrase[1:-1]\r\n return parse(phrase)\r\n elif phrase in self.operations:\r\n return phrase\r\n elif self.current_register.contains(phrase):\r\n # for variables and constants\r\n return self.current_register.get(phrase)\r\n elif contains_comp(phrase) and '(' not in phrase and ')' not in phrase:\r\n return calc.computer.get(phrase)\r\n elif phrase and phrase[0]=='@' and phrase[-1]=='@':\r\n # to retrieve values from the log \r\n index = int(parse(phrase[1:-1]))\r\n if 0<= index <= len(self.lines):\r\n return self.lines[index][0]\r\n else:\r\n \r\n phrase = list(phrase)\r\n #phrase is converted to a list to allowing indexical assignments\r\n operation_sequence = []\r\n level = 0\r\n inquotes = False\r\n quote_form = ''\r\n for counter, x in enumerate(phrase):\r\n\r\n # Search for operators that are not enclosed in parantheses\r\n\r\n if not inquotes and x in ['\"',\"'\"]:\r\n inquotes = True\r\n quote_form = x\r\n elif inquotes and x == quote_form:\r\n if counter < len(phrase)-1:\r\n if phrase[counter+1] in ['+']:\r\n phrase[counter+1] = '#+#'\r\n\r\n if x == '(':\r\n level +=1\r\n\r\n if x == ')':\r\n level -=1\r\n if level == 0:\r\n if counter<len(phrase)-1:\r\n if phrase[counter+1] in self.operations:\r\n # If an operator is found, surround it with pound signs\r\n phrase[counter+1] = '#'+phrase[counter+1]+'#'\r\n if phrase[counter+2] in self.operations:\r\n phrase[counter+2] = '~'\r\n # For a minus sign that is not an operator\r\n\r\n \r\n phrase = ''.join(phrase).replace('~','-').split('#')\r\n # Split the phrase into expressions linked by operators \r\n newphrase = []\r\n for x in phrase:\r\n # a clumsy way to distinction between numerical values, and string operators\r\n try:\r\n newphrase.append(float(x))\r\n except:\r\n newphrase.append(x)\r\n phrase = newphrase\r\n\r\n return parse(phrase)\r\n \r\n \r\n\r\n if isinstance(phrase,list):\r\n # If the phrase has already been parsed into a list \r\n if len(phrase) == 1:\r\n return (parse(phrase[0]))\r\n if all_simple(phrase):\r\n # If every value in the phrase list has been reduced to\r\n # a numerical value or an operator\r\n \r\n\r\n for operation in self.operations:\r\n\r\n #In order to preserve the correct order of operations,\r\n #the operations are analyzed in succession\r\n\r\n while operation in phrase:\r\n\r\n #This repeat as long as the operation is in the phrase,\r\n #since with each pass it only \"reduced\"\r\n #expression/operator/expression triplet\r\n \r\n\r\n newlist = [] # For the result of each pass through the list.\r\n lastvalue = None\r\n counter = 0\r\n stop = False\r\n while counter < len(phrase) and not stop:\r\n \r\n \r\n if counter < len(phrase)-2:\r\n a = phrase[counter]\r\n op = phrase[counter+1]\r\n b = phrase[counter+2]\r\n #take a triplet of values from the list\r\n\r\n if op == operation:\r\n # if an operator is found, reduced the triplet, and\r\n # then add the reduced value, together with the rest\r\n # of the list to the \r\n if operation == '*':\r\n c = a*b\r\n elif operation == '+':\r\n if isinstance(a,str) and isinstance(b,str):\r\n c = a[0:-1]+b[1:]\r\n else:\r\n c = a+b\r\n elif operation == '/':\r\n c = a/b\r\n elif operation == '^':\r\n c = a**b\r\n elif operation == '%':\r\n c = a % b\r\n elif operation == '-':\r\n c = a - b\r\n newlist.append(c)\r\n newlist += phrase[counter+3:] \r\n stop = True\r\n else:\r\n newlist.append(a)\r\n else:\r\n # otherwise, just add the text value to the new list\r\n newlist.append(phrase[counter])\r\n counter +=1 \r\n \r\n \r\n phrase = newlist\r\n\r\n \r\n else:\r\n # if the list is not yet simple, return a new list after parsing each element.\r\n phrase = [parse(x) for x in phrase]\r\n return parse(phrase)\r\n\r\n if isinstance(phrase,(int,float,type(ListType()),bool)):\r\n # if a numerical value, stop the recursion\r\n \r\n return phrase \r\n\r\n return parse(phrase)","def visit_Compound(self, node):\n for child in node.children:\n self.visit(child)","def get_nested_sum():\n l_int = [1,2,[], 3,[4,[], 5,[6]],[7],[8,9], 10,[[],11]]\n print 'Sum:', nested_sum(l_int) \n return","def _calc_C(self, lambdify=True):\n\n C = None\n C_func = None\n # check to see if we have our term saved in file\n C, C_func = self._load_from_file('C', lambdify)\n\n if C is None and C_func is None:\n # if no saved file was loaded, generate function\n print('Generating centrifugal and Coriolis compensation function')\n\n # first get the inertia matrix\n M = self._calc_M(lambdify=False)\n\n # C_{kj} = sum_i c_{ijk}(q) \\dot{q}_i\n # c_{ijk} = 1/2 * sum_i (\\frac{\\partial M_{kj}}{\\partial q_j} +\n # \\frac{\\partial M_{ki}}{\\partial q_j} - \\frac{\\partial M_{ij}}\n # {\\partial q_k})\n C = sp.zeros(self.N_JOINTS, self.N_JOINTS)\n for kk in range(self.N_JOINTS):\n for jj in range(self.N_JOINTS):\n for ii in range(self.N_JOINTS):\n dMkjdqi = M[kk, jj].diff(self.q[ii])\n dMkidqj = M[kk, ii].diff(self.q[jj])\n dMijdqk = M[ii, jj].diff(self.q[kk])\n C[kk, jj] += .5 * (dMkjdqi + dMkidqj - dMijdqk) * self.dq[ii]\n C[kk, jj] = C[kk, jj]\n C = sp.Matrix(C)\n\n # save to file\n abr_control.utils.os_utils.makedirs(\n '%s/C' % self.config_folder)\n cloudpickle.dump(C, open(\n '%s/C/C' % self.config_folder, 'wb'))\n\n if lambdify is False:\n # if should return expression not function\n return C\n\n if C_func is None:\n C_func = self._generate_and_save_function(\n filename='C', expression=C,\n parameters=self.q+self.dq)\n return C_func","def complexity(text:str) -> float:\n words = text.split(' ')\n freqs = [frequency(w) for w in words]\n return sum(freqs) / (len(frequency_list) - freqs.count(0)) #sum of the frequencies / all the words that were in the list","def get_circuit_size(self, circuit: ACircuit, recursive: bool = False) -> Tuple[int, int]:","def combine_expression(self, connector, sub_expressions):\n lhs, rhs = sub_expressions\n if connector == '%%':\n return 'MOD(%s)' % ','.join(sub_expressions)\n elif connector == '&':\n return 'BAND(%s)' % ','.join(sub_expressions)\n elif connector == '|':\n return 'BOR(%s)' % ','.join(sub_expressions)\n elif connector == '^':\n return 'POWER(%s)' % ','.join(sub_expressions)\n elif connector == '<<':\n return '(%(lhs)s * POWER(2, %(rhs)s))' % {'lhs': lhs, 'rhs': rhs}\n elif connector == '>>':\n return 'FLOOR(%(lhs)s / POWER(2, %(rhs)s))' % {'lhs': lhs, 'rhs': rhs}\n return super().combine_expression(connector, sub_expressions)","def custom_quadratic(n_particles, coefficients, is_bosonic):\n if is_bosonic:\n op = bosonic_op if n_particles == 2 else bosonic_op_3\n else:\n op = fermionic_op if n_particles == 2 else fermionic_op_3\n\n if n_particles == 2:\n (J_11, J_22), (J_12,) = coefficients\n return J_11 * op[\"a1^dag a1\"] + J_12 * (op[\"a1^dag a2\"] + op[\"a2^dag a1\"]) + J_22 * op[\"a2^dag a2\"]\n\n elif n_particles == 3:\n (J_11, J_22, J_33), (J_12, J_13, J_23) = coefficients\n return (\n J_11 * op[\"a1^dag a1\"]\n + J_12 * (op[\"a1^dag a2\"] + op[\"a2^dag a1\"])\n + J_13 * (op[\"a1^dag a3\"] + op[\"a3^dag a1\"])\n + J_22 * op[\"a2^dag a2\"]\n + J_23 * (op[\"a2^dag a3\"] + op[\"a3^dag a2\"])\n + J_33 * op[\"a3^dag a3\"]\n )","def _nt_sum(cobj, prop, theta):\n # Build sum term\n i = 1\n s = 0\n while True:\n try:\n ni = getattr(cobj, f\"{prop}_coeff_n{i}\")\n ti = getattr(cobj, f\"{prop}_coeff_t{i}\")\n s += ni * theta**ti\n i += 1\n except AttributeError:\n break\n return s","def dfs(self, nums, cur_sum, S):\n ways = 0\n nums_length = len(nums)\n if nums_length == 0:\n if cur_sum == S:\n return 1\n return 0\n\n multiple = [1, -1]\n for value in multiple:\n new_num = nums[nums_length - 1]\n new_nums = nums[0:nums_length - 1]\n new_sum = cur_sum + new_num * value\n ways = ways + self.dfs(new_nums, new_sum, S)\n\n return ways","def associativity(ob):\n return 0","def conjugation(conj_id, present_base, perfect_base, present_ending, participle_base, infinitive):\n\t\n\t#TODO: Rewrite the following with attribute calls:\n \n tense = {}\n #Tenses, aspects and moods in Latin:\n tense[\"ind_a_pr\"] = conj_ind_a_pr(conj_id, present_base)\n tense[\"ind_a_im\"] = conj_ind_a_im(conj_id, present_base)\n tense[\"ind_a_fu\"] = conj_ind_a_fu(conj_id, present_base)\n tense[\"ind_a_pe\"] = conj_ind_a_pe(conj_id, perfect_base)\n tense[\"ind_a_pl\"] = conj_ind_a_pl(conj_id, perfect_base)\n tense[\"ind_a_fp\"] = conj_ind_a_fp(conj_id, perfect_base)\n tense[\"imp_a_pr\"] = conj_imp_a_pr(conj_id, present_base)\n tense[\"imp_p_pr\"] = conj_imp_p_pr(conj_id, infinitive, present_base) # c\n tense[\"imp_p_fu\"] = conj_imp_p_fu(conj_id, present_base)\n tense[\"imp_a_fu\"] = conj_imp_a_fu(conj_id, present_base)\n tense[\"ind_p_pr\"] = conj_ind_p_pr(conj_id, present_base, present_ending)\n tense[\"ind_p_im\"] = conj_ind_p_im(conj_id, present_base)\n tense[\"ind_p_fu\"] = conj_ind_p_fu(conj_id, present_base, present_ending)\n tense[\"sub_a_pr\"] = conj_sub_a_pr(conj_id, present_base)\n tense[\"sub_p_pr\"] = conj_sub_p_pr(conj_id, present_base)\n tense[\"sub_a_im\"] = conj_sub_a_im(infinitive)\n tense[\"sub_p_im\"] = conj_sub_p_im(infinitive)\n tense[\"sub_a_pe\"] = conj_sub_a_pe(perfect_base)\n tense[\"sub_a_pl\"] = conj_sub_a_pl(perfect_base)\n \n #TODO: Put the above in dictionary as objects?\n #\n tense[\"ind_p_pe\"] = (Esse.ipra, participle_parpp(participle_base))\n tense[\"ind_p_pl\"] = (Esse.iima, participle_parpp(participle_base))\n tense[\"sub_p_pe\"] = (Esse.sub_pr, participle_parpp(participle_base))\n tense[\"sub_p_pl\"] = (Esse.sub_im, participle_parpp(participle_base))\n tense[\"ind_p_fp\"] = (Esse.ind_fu, participle_parpp(participle_base))\n \n return tense","def __init__(self, children):\n super().__init__('complex', children, None)\n self.real = children[0].real\n self.imag = children[1].imag\n self.complex = self.real + self.imag*1j","def _cmplx_div_ ( s , o ) :\n return ( 1.0 / o ) * complex ( s )","def encode_compound(db, tree):\n length = 0\n data = 0\n sf = 0\n subfields = []\n for cn in tree.childNodes:\n l = 0\n if cn.nodeName == 'Variable':\n l, v = encode_variable(db, cn)\n else:\n if cn.nodeName == 'Fixed':\n l, v = encode_fixed(db, cn)\n else:\n if cn.nodeName == 'Repetitive':\n l, v = encode_repetitive(db, cn)\n else:\n if cn.nodeName == 'Variable':\n l, v = encode_variable(db, cn)\n else:\n if cn.nodeName == 'Compound':\n l, v = encode_compound(db, cn)\n\n if l > 0:\n subfields.append(sf)\n length += l\n data <<= (8 * l)\n data += v\n\n sf += 1\n\n n_octets = max(subfields) / 7 + 1\n primary_subfield = 0\n for i in sorted(subfields): # subfields\n primary_subfield += (1 << (8 * (i / 7) + (8 - (i % 7))))\n for i in range(n_octets - 1): # FX\n primary_subfield += (1 << 8 * (i + 1))\n\n data += (primary_subfield << (8 * length))\n\n return length + n_octets, data","def get_covered_terms(self):\n base = 0\n x_index = [index for index, item in enumerate(self.bin_str[::-1]) if item == '-']\n\n for index, item in enumerate(self.bin_str[::-1]):\n if item == '1':\n base += 2 ** index\n\n yield base\n\n for i in range(len(x_index)):\n for items in itertools.combinations(x_index, i + 1):\n accumulator = 0\n for index in items:\n accumulator += 2 ** index\n yield base + accumulator","def Cprimebound(relatorlist,Lambda=1):\n F,rels=fg.parseinputwords(relatorlist)\n if not all(r==F.cyclic_reduce(r) for r in rels):\n raise ValueError(\"Relators are not cyclically reduced.\")\n biggestratio=Fraction(1,min(len(r) for r in rels))\n if biggestratio>=Fraction(1,Lambda):\n return 1\n rels.sort(key=len) # sort list of relators with shortest first\n irels=[rel for rel in itertools.chain.from_iterable(zip([w() for w in rels],[(w**(-1))() for w in rels]))] # arrange relators and inverses in a list of the form relator1, inverse of relator1, relator2, inverse of relator2,...\n drels=[x+x for x in irels] # double the relators to look for pieces that would have wrapped\n for relatorindex in range(len(rels)):\n relator=irels[2*relatorindex]\n foundbiggest=False\n for L in range(len(relator),int(biggestratio*len(relator)),-1):# only check subwords of length L that would give biggest ratio if they were a piece\n for startingindex in range(len(relator)):\n p=(relator+relator)[startingindex:startingindex+L] # the subword of length L starting at index i in relator as a cyclic word\n # now we need to check if p is a piece\n # we do not need to check lower relatorindices, because we already scanned those relators for pieces\n if any(p in x for x in [(relator+relator)[startingindex+1:len(relator)+startingindex+L-1]]+[drels[i] for i in range(2*relatorindex+1,len(drels))]):# look in this (doubled) relator at higher starting indices, and in all later relators, for other copies of p. If found a matching subword, p is a piece.\n biggestratio=Fraction(len(p),len(relator))\n foundbiggest=True # we search pieces by decreasing length, so first one we find is longest\n if biggestratio>=Fraction(1,Lambda):\n return 1\n break\n if foundbiggest: # if we found the biggest piece in this relator we can move on to the next relator. \n break\n return biggestratio","def _compile(self, expression):\n t = re.split(r'\\s+(\\+|-)\\s+', expression)\n ocomps = t[::2] # output component sub-expressions\n signs = [1.] # implied + in front of expression\n signs.extend(1. if s == '+' else -1 for s in t[1::2]) \n factors = [(1., 1) for i in ocomps]\n for i, s in enumerate(ocomps):\n tt = re.split(r'\\s+(\\*|/)\\s+', s) # split on */ operator\n lval = self._lval(tt[0])\n if len(tt) > 1:\n factors[i] = self._rval(tt[2]), 1 if tt[1] == '*' else -1\n if not isinstance(lval, Output): \n if len(ocomps) == 1: # simple basic output (special case)\n self.is_basic = True\n self._factor = factors[0]\n self._compile_basic(lval)\n return\n else: # compound basic output\n ocomps[i] = Output(parent=self.parent,\n expression=lval,\n factor=factors[i],\n is_basic=True)\n else: # summary output\n ocomps[i] = lval #self.parent.outputs[lval]\n self._ocomps = ocomps\n self._signs = signs\n self._factors = factors","def Mol_SO(Nat, multip, charge, sym, SO_3rdrow_mols_val): # number of atoms, multiplicity, charge, array of atoms in molecule, value of SO_3rdrow_mols (from orca.inp file)\n\n Mol_SO = 0\n \n # Special Case - Acetleyne - S\n if Nat == 4 and multip == 2 and charge == 1:\n countH_temp =0\n countC_temp =0\n for tmp in range(len(sym)):\n if sym[tmp] == \"H\":\n countH_temp= countH_temp +1\n if sym[tmp] == \"C\":\n countC_temp = countC_temp +1\n if countH_temp == 2 and countC_temp == 2:\n Mol_SO = -0.07 #-0.07d0\n \n with open(\"Thermochemistry.out\", \"a\") as ther_chem:\n ther_chem.write(\"DETECTED A C2H2+ SYSTEM: Using SO parameters for acetylene cation\\n\")\n ther_chem.write(\"Ref: JCP 114, 9287, 2001\\n\\n\")\n # Special Case - Acetleyne - E\n \n # For diatomics with multip = 2\n if Nat == 2 and multip == 2 :\n sort_sym = sorted(sym, reverse=True)\n if SO_3rdrow_mols_val == \"true\": # for 3rd_row elements\n \n if charge == 0:\n if sort_sym[0] == 'O' and sort_sym[1] == 'Br': Mol_SO=-2.20\n \n # COMMMENT: paper has it for cation, but it looks like it is for neutral\n if sort_sym[0] == 'Se' and sort_sym[1] == 'H': Mol_SO=-4.21\n \n if charge == +1: ### RECHECK what the values of charge is!!!!!!!!!!!!!!!!!!!!!IMPORTANT\n if sort_sym[0] == 'K' and sort_sym[1] == 'Br': Mol_SO=-2.99\n if sort_sym[0] == 'H' and sort_sym[1] == 'As': Mol_SO=-3.54\n if sort_sym[0] == 'H' and sort_sym[1] == 'Br': Mol_SO=-6.26\n if sort_sym[0] == 'F' and sort_sym[1] == 'Br': Mol_SO=-6.10\n if sort_sym[0] == 'Na' and sort_sym[1] == 'Br': Mol_SO=-3.93\n if sort_sym[0] == 'Br' and sort_sym[1] == 'Br': Mol_SO=-6.55\n \n else: # for non 3rd row elements, first and second rows\n if charge == 0:\n if sort_sym[0] == 'H' and sort_sym[1] == 'C': Mol_SO=-0.07\n if sort_sym[0] == 'O' and sort_sym[1] == 'H': Mol_SO=-0.30\n if sort_sym[0] == 'O' and sort_sym[1] == 'N': Mol_SO=-0.27\n if sort_sym[0] == 'O' and sort_sym[1] == 'Cl': Mol_SO=-0.61\n if sort_sym[0] == 'S' and sort_sym[1] == 'H': Mol_SO=-1.01\n if sort_sym[0] == 'P' and sort_sym[1] == 'O': Mol_SO=-0.53\n if sort_sym[0] == 'Si' and sort_sym[1] == 'H': Mol_SO=-0.34\n \n if charge == -1:\n if sort_sym[0] == 'N' and sort_sym[1] == 'H': Mol_SO=-0.12\n if sort_sym[0] == 'P' and sort_sym[1] == 'H': Mol_SO=-0.45\n if sort_sym[0] == 'O' and sort_sym[1] == 'O': Mol_SO=-0.34\n if sort_sym[0] == 'S' and sort_sym[1] == 'S': Mol_SO=-1.12\n \n if charge == +1:\n if sort_sym[0] == 'H' and sort_sym[1] == 'F': Mol_SO=-0.62\n if sort_sym[0] == 'P' and sort_sym[1] == 'H': Mol_SO=-0.67\n if sort_sym[0] == 'H' and sort_sym[1] == 'Cl': Mol_SO=-1.60\n if sort_sym[0] == 'N' and sort_sym[1] == 'N': Mol_SO=-0.17\n if sort_sym[0] == 'O' and sort_sym[1] == 'O': Mol_SO=-0.43\n if sort_sym[0] == 'P' and sort_sym[1] == 'P': Mol_SO=-0.57\n if sort_sym[0] == 'S' and sort_sym[1] == 'S': Mol_SO=-1.25\n if sort_sym[0] == 'Cl' and sort_sym[1] == 'Cl': Mol_SO=-1.77\n if sort_sym[0] == 'F' and sort_sym[1] == 'Cl': Mol_SO=-1.60\n \n return(Mol_SO)","def visit_Compound(self, node):\n for statement in node.statements:\n self.visit(statement)","def length(cont):\r\n\r\n mySum = 0\r\n\r\n if cont == \"\":\r\n return 0\r\n else:\r\n mySum += 1 + length(cont[1:])\r\n return mySum","def calculate(self) -> complex128:\n\n if not self.__can_calculation_be_performed():\n raise AttributeError\n\n v_vectors = self.__calculate_v_vectors()\n\n permanent = 0\n for v_vector in v_vectors:\n v_sum = sum(v_vector)\n addend = pow(-1, v_sum)\n # Binomials calculation\n for i in range(len(v_vector)):\n addend *= binom(self.__input_state[i], v_vector[i])\n\n # Product calculation\n product = 1\n for j in range(len(self.__input_state)):\n if self.__output_state[j] == 0: # There's no reason to calculate the sum if t_j = 0\n continue\n # Otherwise we calculate the sum\n product_part = 0\n for i in range(len(self.__input_state)):\n product_part += (self.__input_state[i] - 2 * v_vector[i]) * self.__matrix[j][i]\n product_part = pow(product_part, self.__output_state[j])\n product *= product_part\n addend *= product\n permanent += addend\n\n permanent /= pow(2, sum(self.__input_state))\n\n return permanent","def get_number_operators(self) -> int:\n if self.sons:\n return 1 + sum([son.get_number_operators() for son in self.sons])\n return 0","def get_complexes(self):\n q_cmplx = prefixes + \"\"\"\n SELECT ?complexTerm ?childName ?child ?stmt\n WHERE {\n {\n {?stmt belvoc:hasSubject ?complexTerm}\n UNION\n {?stmt belvoc:hasObject ?complexTerm .}\n UNION\n {?stmt belvoc:hasSubject ?term .\n ?term belvoc:hasChild ?complexTerm .}\n UNION\n {?stmt belvoc:hasObject ?term .\n ?term belvoc:hasChild ?complexTerm .}\n }\n ?complexTerm a belvoc:Term .\n ?complexTerm a belvoc:ComplexAbundance .\n ?complexTerm belvoc:hasChild ?child .\n ?child belvoc:hasConcept ?childName .\n }\n \"\"\"\n # Run the query\n res_cmplx = self.g.query(q_cmplx)\n\n # Store the members of each complex in a dict of lists, keyed by the\n # term for the complex\n cmplx_dict = collections.defaultdict(list)\n cmplx_ev = {}\n for stmt in res_cmplx:\n stmt_uri = stmt[3]\n ev = self._get_evidence(stmt_uri)\n for e in ev:\n e.epistemics['direct'] = True\n cmplx_name = term_from_uri(stmt[0])\n cmplx_id = stmt_uri + '#' + cmplx_name\n child = self._get_agent(stmt[1], stmt[2])\n cmplx_dict[cmplx_id].append(child)\n # This might be written multiple times but with the same\n # evidence\n cmplx_ev[cmplx_id] = ev\n # Now iterate over the stored complex information and create binding\n # statements\n for cmplx_id, cmplx_list in cmplx_dict.items():\n if len(cmplx_list) < 2:\n msg = 'Complex %s has less than 2 members! Skipping.' % \\\n cmplx_name\n logger.warning(msg)\n else:\n self.statements.append(Complex(cmplx_list,\n evidence=cmplx_ev[cmplx_id]))","def collect_nested(expr, aggressive=False):\n\n def run(expr):\n # Return semantic (rebuilt expression, factorization candidates)\n\n if expr.is_Number or expr.is_Symbol:\n return expr, [expr]\n elif expr.is_Indexed or expr.is_Atom:\n return expr, []\n elif expr.is_Add:\n rebuilt, candidates = zip(*[run(arg) for arg in expr.args])\n\n w_numbers = [i for i in rebuilt if any(j.is_Number for j in i.args)]\n wo_numbers = [i for i in rebuilt if i not in w_numbers]\n\n w_numbers = collect_const(expr.func(*w_numbers))\n wo_numbers = expr.func(*wo_numbers)\n\n if aggressive is True and wo_numbers:\n for i in flatten(candidates):\n wo_numbers = collect(wo_numbers, i)\n\n rebuilt = expr.func(w_numbers, wo_numbers)\n return rebuilt, []\n elif expr.is_Mul:\n rebuilt, candidates = zip(*[run(arg) for arg in expr.args])\n rebuilt = collect_const(expr.func(*rebuilt))\n return rebuilt, flatten(candidates)\n elif expr.is_Equality:\n rebuilt, candidates = zip(*[run(expr.lhs), run(expr.rhs)])\n return expr.func(*rebuilt, evaluate=False), flatten(candidates)\n else:\n rebuilt, candidates = zip(*[run(arg) for arg in expr.args])\n return expr.func(*rebuilt), flatten(candidates)\n\n return run(expr)[0]","def process():\r\n\t### INPUT ####\r\n\tpq = eat(str)\r\n\tp, q = map(int, pq.split('/'))\r\n\t\r\n\t### COMPUT ####\r\n\td = gcd(p, q)\r\n\tp, q = p//d, q//d\r\n\teprint(bin(q), bin(p))\r\n\tif len(bin(q).strip('0')) != 2:\r\n\t\treturn IMPOSSIBLE\r\n\t#length of p\r\n\tbinp = bin(p)\r\n\tbinq = bin(q)\r\n\treturn len(binq) - len(binp)\r\n\t\r\n\t### OUTPUT ####\r\n\treturn solve()","def convex_conj(self):\n convex_conjs = [func.convex_conj for func in self.functionals]\n return SeparableSum(*convex_conjs)","def __add__(self, other):\n self.sum_complex_num = Complex((self.real + other.real), (self.imaginary + other.imaginary))\n return self.sum_complex_num","def radical_c2(self, atoms):\n\n c1, c2 = atoms.keys()\n c1_ndx, c2_ndx = atoms.values()\n\n chain1, chain2 = self.determine_chains([c1, c2])\n\n # to get indexing right\n c1_ndx -= self.monomer.indices[chain1]['C1']\n c2_ndx -= self.monomer.indices[chain2]['C2']\n\n # types after reaction\n types = {'chain1': {'C1': 'c3', 'C2': 'c2', 'C3': 'c2', 'C4': 'c2', 'H1': 'hc', 'H2': 'hc', 'H3': 'ha',\n 'H4': 'ha', 'H5': 'ha'}, # chain1 contains c1\n 'chain2': {'C1': 'c3', 'C2': 'c3', 'C3': 'c2', 'C4': 'c2', 'H1': 'hc', 'H2': 'hc', 'H3': 'hc',\n 'H4': 'ha', 'H5': 'ha'}} # chain2 contains c2 radical\n\n # update types\n reacted_types = {'chain1': {c1_ndx + self.monomer.indices[chain1][a]: types['chain1'][a]\n for a in types['chain1'].keys()},\n 'chain2': {c2_ndx + self.monomer.indices[chain2][a]: types['chain2'][a]\n for a in types['chain2'].keys()}}\n\n # new bonds\n bonds = [[c1_ndx + self.monomer.indices[chain1]['C1'], c2_ndx + self.monomer.indices[chain2]['C2'], 'carbon']]\n\n # no dummy bonds to add\n\n # define indices of left-over radicals\n radicals = [c1_ndx + self.monomer.indices[chain1]['C2']]\n\n chain1_impropers = ['C1'] # [1]\n chain2_impropers = ['C2'] # [2]\n rm_improper = []\n for c in chain1_impropers:\n rm_improper.append([c1_ndx + self.monomer.indices[chain1][x] for x in self.monomer.impropers[chain1][c]])\n for c in chain2_impropers:\n rm_improper.append([c2_ndx + self.monomer.indices[chain2][x] for x in self.monomer.impropers[chain2][c]])\n\n # define terminated atoms\n terminated = [c1_ndx + self.monomer.indices[chain1]['C1'], c2_ndx + self.monomer.indices[chain2]['C2']]\n\n return reacted_types, bonds, radicals, rm_improper, terminated","def test_complexity():\n file_paths = glob.iglob('*/*.py')\n for file_path in file_paths:\n with open(file_path, 'r') as file_obj:\n blocks = radon.cc_visit(file_obj.read())\n for block in blocks:\n fail_msg = '{} ({}) has a cyclomatic complexity of {}'.format(\n block.name, file_path, block.complexity)\n yield case.assertLessEqual, block.complexity, 10, fail_msg","def RyserFormula(num_coincidence: int, U_st: numpy.ndarray) -> complex:\n\n value_perm = 0\n set = CreateSubset(num_coincidence)\n\n for subset in set:\n num_elements = len(subset)\n value_times = 1\n for i in range(num_coincidence):\n value_sum = 0\n for j in subset:\n value_sum += U_st[i, j]\n value_times *= value_sum\n value_perm += value_times * (-1) ** num_elements\n value_perm *= (-1) ** num_coincidence\n return value_perm","def qed_cc( s, m, r):\n\n l1_t2 = s + m\n l2 = r + s\n\n if l1_t2 % 2 != 0:\n return 0\n\n denom = factorial(s) * factorial(m) * factorial(r)**2\n nom = double_factorial( l1_t2 - 1 ) * factorial( l2 )\n\n return Fraction( nom, denom )","def simplify (self):\n if (self.debug): print(f'enter fraction.simplify')\n hcf = find_hcf(self.value[0], self.value[1])\n self.value = (self.value[0] // hcf.product(), self.value[1] // hcf.product())\n return","def solve_equation_addition_precendence(eq, verbose=False):\n tokens = tokenize(eq)\n if verbose:\n print(f\"eq: {tokens}\")\n\n stack = []\n ops = {\n None: do_push,\n \"(\": do_push,\n \")\": do_parenthesis,\n \"+\": do_addition,\n \"*\": do_push,\n }\n\n for t in tokens:\n if isinstance(t, int):\n op = stack[-1] if len(stack) else None\n ops[op](stack, t)\n elif t == \"+\" or t == \"*\" or t == \"(\":\n stack.append(t)\n elif t == \")\":\n ops[\")\"](stack, t)\n # solve preparenthesis addition\n if len(stack) > 2:\n v = stack.pop()\n assert isinstance(v, int)\n ops[stack[-1]](stack, v)\n else:\n assert False, f\"fail token: {t}\"\n\n if verbose:\n print(f\"stack: {stack}\")\n\n # solve multiplications\n while len(stack) > 1:\n rhs = stack.pop()\n assert isinstance(rhs, int)\n op = stack.pop()\n if op == \"*\":\n lhs = stack.pop()\n assert isinstance(lhs, int)\n stack.append(lhs * rhs)\n else:\n assert False, f\"invalid operator (not *): {op}\"\n\n assert len(stack) == 1\n return stack[0]","def sum_proper_divisors(n):\r\n return sum(proper_divisors(n))","def tree_string(self):\n if self.body is None:\n return 0\n if self.left is None and self.right is None:\n return self.body\n left_sum = self.left.tree_string()\n right_sum = self.right.tree_string()\n if self.body == add:\n return str(left_sum) + '+' + str(right_sum)\n elif self.body == sub:\n return str(left_sum) + '-' + str(right_sum)\n elif self.body == mul:\n return str(left_sum) + '*' + str(right_sum)\n else:\n return str(left_sum) + '/' + str(right_sum)","def n_complex_components(self):\n return self.n_components // 2 + (self.n_components % 2)","def score( canvas ):\n\n score = 0\n\n score += length_score(canvas)\n score += angle_score(canvas)\n\n # 1. Chainbreaks for all junction loops.\n\n # 2. Nucleotides should be at least 15 from ALL other nts. Don't double-count.\n for seqpos1, nt1 in canvas.nucleotides.iteritems():\n for seqpos2, nt2 in canvas.nucleotides.iteritems():\n if seqpos1 >= seqpos2: continue\n #if distance( nt1, nt2 ) < 15: score += 100\n # Don't do a square root you don't have to\n if distance_squared( nt1, nt2 ) < 225: score += 100\n\n\n # 2b. Depending on base pair width, it's possible that the 'best' orientation for two stacks is\n # for them to be overlapping...\n # nt --- nt\n # | nt |-- nt\n # nt -|- nt |\n # | nt |-- nt\n # so, penalize this ( 'between two bp'ed nts' penalized like hitting a nt )\n for seqpos, nt in canvas.nucleotides.iteritems():\n for stem in canvas.stems:\n for bp in stem.base_pairs:\n if nt == bp.nt1 or nt == bp.nt2:\n continue\n # if nt in question is 'in between' nt1 and nt2. how to judge?\n if nt.x > bp.nt1.x and nt.x < bp.nt2.x \\\n and closer_than( nt.y, bp.nt1.y, canvas.bp_offset_height*0.8 ):\n score += 100\n\n # Look at pairs of adjacent nts in stem\n for seqpos1, nt1 in stem.nucleotides.iteritems():\n if seqpos1 + 1 in stem.nucleotides.keys():\n nt2 = stem.nucleotides[ seqpos1 + 1 ]\n if nt.y > nt1.y and nt.y < nt2.y \\\n and closer_than( nt.x, nt1.x, canvas.bp_offset_width*0.8 ):\n score += 100\n\n # 3. Stems should be straight and vertical.\n ### Resolved via kinematics?\n\n # 4. Coaxial stacks, where known, should be colinear.\n for idx1, idx2 in canvas.list_of_coaxialities:\n # idx1 and idx2 are coaxial stems.\n # Any two BPs from these stems should do, but -- because I have no idea\n # how we intend to handle 'alternate-order' stacks (where the first nt in a bp\n # is stacked on the second nt in another), compare either direction.\n bp1 = canvas.stems[idx1].base_pairs[0]\n bp2 = canvas.stems[idx2].base_pairs[0]\n penalty1 = harmonic_penalty( bp1.nt1.x - bp2.nt1.x, 0, 1 ) + harmonic_penalty( bp1.nt2.x - bp2.nt2.x, 0, 1 )\n penalty2 = harmonic_penalty( bp1.nt1.x - bp2.nt2.x, 0, 1 ) + harmonic_penalty( bp1.nt2.x - bp2.nt1.x, 0, 1 )\n score += min( penalty1, penalty2 )\n\n\n # 5. Apical loops should be symmetrical and near a circular path.\n for loop in canvas.loops:\n for seqpos in loop.nucleotides.keys():\n pass\n\n return score","def problem9_complex(n):\n # Start with 1 to avoid triples with zero.\n for u in range(1, n):\n for v in range(u, n):\n # When u == v one of the a, b becomes 0\n if u != v:\n\n # The following two blocks do the same thing.\n # First one uses complex numbers.\n # Second one uses generalised formulas.\n\n # comp = complex(u, v) ** 2\n # a = abs(comp.real)\n # b = abs(comp.imag)\n # c = sqrt(a ** 2 + b ** 2)\n\n a = abs(u ** 2 - v ** 2)\n b = abs(2 * u * v)\n c = abs(u ** 2 + v ** 2)\n\n if a + b + c == n:\n return a * b * c\n return None","def length(formula):\n if isinstance(formula, Atom):\n return 1\n if isinstance(formula, Not):\n return length(formula.inner) + 1\n if isinstance(formula, Implies) or isinstance(formula, And) or isinstance(formula, Or):\n return length(formula.left) + length(formula.right) + 1","def visit_term(self, node, children):\n if self.debug:\n print(\"Term {}\".format(children))\n term = children[0]\n for i in range(2, len(children), 2):\n if children[i-1] == \"*\":\n term *= children[i]\n else:\n term /= children[i]\n if self.debug:\n print(\"Term = {}\".format(term))\n return term","def check_rec(eqparams, tracecombo=(dict(), 0, set(range(10))), p=0):\n # Basic parameters of the equation,\n # maximal digit rank\n # characters with multipliers by rank\n # unique non-zero characters by rank\n # unique zero-allowed characters by rank\n # all unique characters by rank\n maxp, tchars, unzchars, uokzchars, uchars = eqparams\n # recursion cumulative parameters\n # established characters with digits\n # carry-over from the previous level\n # remaining unassigned digits\n prevdict, cover, remdigs = tracecombo\n # the maximal 10-power (beyond the maximal rank)\n # is reached\n if p == maxp:\n # Carry-over is zero, meaning solution is found\n if cover == 0:\n return prevdict\n else:\n # Otherwise the solution in this branch is not found\n # return empty\n return dict()\n diglets = uchars[p] # all new unique letters from the current level\n partsum = cover # Carry over from lower level\n remexp = [] # TBD letters\n # Break down the current level letter into what can be\n # calculated in the partial sum and remaining TBD letter-digits\n for c, v in tchars[p]:\n if c in prevdict:\n partsum += v * prevdict[c]\n else:\n remexp.append((c, v))\n # Generate permutations for the remaining digits and currecnt level\n # non-zero letters and zero-allowed letters\n for newdigs in digPerms(remdigs, unzchars[p], uokzchars[p]):\n # build the dictionary for the new letters and this level\n newdict = dict(zip(diglets, newdigs))\n # complete the partial sum into test sum using the current permutation\n testsum = partsum + sum([newdict[c] * v\n for c, v in remexp])\n # check if the sum is divisible by 10\n d, r = divmod(testsum, 10)\n if r == 0:\n # if divisible, update the dictionary to all established\n newdict.update(prevdict)\n # proceed to the next level of recursion with\n # the same eqparams, but updated digit dictionary,\n # new carry over and remaining digits to assign\n rectest = check_rec(eqparams,\n (newdict, d, remdigs - set(newdigs)),\n p + 1)\n # if the recursive call returned a non-empty dictionary\n # this means the recursion has found a solution\n # otherwise, proceed to the new permutation\n if rectest and len(rectest) > 0:\n return rectest\n # if no permutations are avaialble or no\n # permutation gave the result return None\n return None","def test_ccsd_doubles_a_terms(parthole_drudge):\n\n dr = parthole_drudge\n p = dr.names\n\n a, b, c, d = p.V_dumms[:4]\n i, j, k, l = p.O_dumms[:4]\n u = dr.two_body\n t = IndexedBase('t')\n dr.set_dbbar_base(t, 2)\n\n tau = dr.define_einst(\n IndexedBase('tau')[a, b, i, j],\n Rational(1, 2) * t[a, b, i, j] + t[a, i] * t[b, j]\n )\n\n a_i = dr.define_einst(\n IndexedBase('ai')[k, l, i, j], u[i, c, k, l] * t[c, j]\n )\n\n a_ = dr.define(\n IndexedBase('a')[k, l, i, j],\n u[k, l, i, j] +\n a_i[k, l, i, j] - a_i[k, l, j, i]\n + u[k, l, c, d] * tau[c, d, i, j]\n )\n\n tensor = dr.define_einst(\n IndexedBase('r')[a, b, i, j],\n a_[k, l, i, j] * tau[a, b, k, l]\n )\n targets = [tensor]\n\n eval_seq = optimize(\n targets, substs={p.nv: p.no * 10}, strategy=Strategy.ALL | Strategy.SUM\n )\n assert verify_eval_seq(eval_seq, targets)\n # Here we just assert that the final step is a simple product.\n assert len(eval_seq[-1].rhs_terms) == 1","def test_simple_cc():\n hs_c = LocalSpace('c', dimension=3)\n hs_q = LocalSpace('q1', basis=('g', 'e'))\n Delta_1 = Symbol('Delta_1')\n Omega_1 = Symbol('Omega_1')\n g_1 = Symbol('g_1')\n a = Destroy(hs=hs_c)\n a_dag = Create(hs=hs_c)\n sig_p = LocalSigma('e', 'g', hs=hs_q)\n sig_m = LocalSigma('g', 'e', hs=hs_q)\n coeff = (-I / 2) * (Omega_1 * g_1 / Delta_1)\n jc_expr = coeff * (a * sig_p - a_dag * sig_m)\n\n simplified = rewrite_with_operator_pm_cc(jc_expr)\n assert simplified == coeff * OperatorPlusMinusCC(a * sig_p, sign=-1)\n assert (\n srepr(simplified.term)\n == \"OperatorPlusMinusCC(OperatorTimes(Destroy(hs=LocalSpace('c', \"\n \"dimension=3)), LocalSigma('e', 'g', hs=LocalSpace('q1', \"\n \"basis=('g', 'e')))), sign=-1)\"\n )\n expanded = simplified.doit()\n assert expanded == jc_expr","def normal(e, **kw_args):\n\n if not e:\n return S.Zero\n\n opts = {\n 'simplify_kronecker_deltas': False,\n 'expand': True,\n 'simplify_dummies': False,\n 'keep_only_fully_contracted': False,\n 'lam': 1\n }\n opts.update(kw_args)\n\n # break up any NO-objects, and evaluate commutators\n e = e.doit(wicks=True)\n\n # make sure we have only one term to consider\n e = e.expand()\n if isinstance(e, Add):\n return Add(*[ normal(term, **kw_args) for term in e.args])\n\n # For Mul-objects we can actually do something\n if isinstance(e, Mul):\n\n # we don't want to mess around with commuting part of Mul\n # so we factorize it out before starting recursion\n c_part = []\n string1 = []\n for factor in e.args:\n if factor.is_commutative:\n c_part.append(factor)\n else:\n string1.append(factor)\n n = len(string1)\n\n # catch trivial cases\n if n == 0:\n result = e\n elif n == 1:\n result = e\n else: # non-trivial\n if n > 2:\n # recursive step\n if isinstance(string1[0], CreateBoson) \\\n or (string1[0].is_Pow and \\\n isinstance(string1[0].args[0], CreateBoson)):\n # if the first term is ad^m\n result = string1[0] * normal(Mul(*string1[1:]), **kw_args)\n else:\n # if the first term is a^m,\n # bring the first two terms to normal order first\n result = normal(normal(Mul(*string1[:2]), **kw_args)*Mul(*string1[2:]), **kw_args)\n else: # n = 2,\n result = _normal(string1, opts['lam'])\n result = Mul(*c_part)*result\n\n if opts['expand']:\n result = result.expand()\n # if opts['simplify_kronecker_deltas']:\n # result = evaluate_deltas(result)\n\n return result\n\n # there was nothing to do\n return e","def connectors_calc(level):\n global connectors\n connectors = level*(level+1)/2\n return connectors","def degree_on_basis(self, b):\n return sum(b)","def C(relatorlist,quit_at=float('inf')):\n F,rels=fg.parseinputwords(relatorlist)\n if not all(r==F.cyclic_reduce(r) for r in rels):\n raise ValueError(\"Relators are not cyclically reduced.\")\n thepieces=pieces(rels)\n minnumberpieces=quit_at\n def min_string_piece_expression(whatsleft,thepieces,quit_at):\n # recursively determine the minimal expression of the string whatsleft as a concatenation of elements of thepieces, or stop once it is determined that any such expression requires at least quit_at many pieces\n # find a piece that agrees with a prefix of whatsleft and the recurse on the suffix\n if not whatsleft:\n return 0\n minexp=quit_at\n for p in thepieces:\n if p!=whatsleft[:len(p)]:\n continue\n else:\n minexp=min(minexp,1+min_string_piece_expression(whatsleft[len(p):],thepieces,minexp-1))\n return minexp\n def min_relator_piece_expression(relator,thepieces,quit_at):\n # This is first step in recursive search. Here we want to find a piece p such that for relator r we can write p=xy and r=yzx, with y nontrivial. That is, in this step only we think of r as cyclic word and allow first piece that wraps.\n r=relator()\n minexp=quit_at\n for p in thepieces:\n if len(p)>len(r):\n continue\n possiblestartingindices=[] # for given p there may be different possible choices of y\n for startingindex in range(len(r)-len(p)+1,len(r)+1):\n if p==(r+r)[startingindex:startingindex+len(p)]:\n possiblestartingindices.append(startingindex)\n if not possiblestartingindices:\n continue\n for startingindex in possiblestartingindices:\n # found a way to fit p into r spanning the beginning of r. This accounts for x and y part of r. Now recursively find shortest expression of z=whatsleft as a concatenation of pieces.\n whatsleft=(r+r)[startingindex+len(p):startingindex+len(r)]\n if not whatsleft:\n return 1\n else:\n minexp=min(minexp,1+min_string_piece_expression(whatsleft,thepieces,minexp-1))\n return minexp\n for thisrelator in rels:\n minnumberpieces=min(minnumberpieces,min_relator_piece_expression(thisrelator,thepieces,minnumberpieces))\n return minnumberpieces","def CalcSingleCompoundDescriptor(compos, argVect, atomDict, propDict):\n try:\n atomVarNames = argVect[0]\n compositionVarNames = argVect[1]\n formula = argVect[2]\n formula = _SubForCompoundDescriptors(formula, compositionVarNames, 'propDict')\n formula = _SubForAtomicVars(formula, atomVarNames, 'atomDict')\n evalTarget = _SubMethodArgs(formula, knownMethods)\n except Exception:\n if __DEBUG:\n import traceback\n print('Sub Failure!')\n traceback.print_exc()\n print(evalTarget)\n print(propDict)\n raise RuntimeError('Failure 1')\n else:\n return -666\n\n try:\n v = eval(evalTarget)\n except Exception:\n if __DEBUG:\n import traceback\n outF = open(RDConfig.RDCodeDir + '/ml/descriptors/log.txt', 'a+')\n outF.write('#------------------------------\\n')\n outF.write('formula: %s\\n' % repr(formula))\n outF.write('target: %s\\n' % repr(evalTarget))\n outF.write('propDict: %s\\n' % (repr(propDict)))\n\n outF.write('keys: %s\\n' % (repr(sorted(atomDict))))\n outF.close()\n print('ick!')\n print('formula:', formula)\n print('target:', evalTarget)\n print('propDict:', propDict)\n print('keys:', atomDict.keys())\n traceback.print_exc()\n raise RuntimeError('Failure 2')\n else:\n v = -666\n return v","def all_change(cur: Currency, r: float, max_permutation=1000, only_cents=True) -> List[Union[int, List]]:\n\n # sub problem: combinations to return n < r with a set of coins s' subset of s\n # base case: combinations to return 0 = 1: empty list\n # characteristic equation: sum of combinations using that coin with combinations without using that coin.\n\n # introducing convenient notation working in cents\n m = cur.num_denominations()\n S = [_ for _ in cur.iter_denominations()] if only_cents else [_float2int(x) for x in cur.iter_denominations()]\n n = _float2int(r) if not only_cents else r\n\n # Construct table\n T = [[[0, []] for _ in range(m)] for _ in range(n + 1)]\n\n # Base case (value zero has just one solution: empty list)\n for i in range(m):\n T[0][i] = [1, [[0 for _ in range(m)]]]\n\n # Fill rest of the table entries\n for i in range(1, n + 1):\n for j in range(m):\n # Count of solutions including S[j]\n x = T[i - S[j]][j][0] if i - S[j] >= 0 else 0\n\n # get max_permutation permutation value\n if x > 0:\n k = 0\n while len(T[i][j][1]) < max_permutation and k < len(T[i - S[j]][j][1]):\n sol = T[i - S[j]][j][1][k]\n T[i][j][1].append(sol[:])\n T[i][j][1][-1][j] += 1\n k += 1\n\n # Count of solutions excluding S[j]\n y = T[i][j - 1][0] if j >= 1 else 0\n\n # get max_permutation permutation value\n if y > 0:\n k = 0\n while len(T[i][j][1]) < max_permutation and k < len(T[i][j - 1][1]):\n sol = T[i][j - 1][1][k]\n T[i][j][1].append(sol[:])\n k += 1\n\n # total count\n T[i][j][0] = x + y\n\n return T[-1][-1]","def lucas_recur(n):\n if n == 0:\n return 2\n elif n == 1:\n return 1\n return lucas_recur(n - 1) + lucas_recur(n - 2)","def complex(real, imag):","def computeList(Code):\r\n \r\n l = len(Code);\r\n # Make sure number of left brackets still == no of right brackets\r\n checkBrackets(Code);\r\n \r\n if l == 0:\r\n return None\r\n \r\n # Base case: Code = ['T'] or ['F'] or has brackets.\r\n if l == 1:\r\n \r\n C = Code[0].strip('( )');\r\n \r\n if C in constants: return C;\r\n \r\n else: return Exception(\"output is neither true nor false.\");\r\n \r\n \r\n # Secondary case: No brackets remaining.\r\n elif not containsBrackets(Code):\r\n \r\n sub = {}; # records reduced indices in list, as a result of computation\r\n \r\n order = tuple();\r\n for prec in precedence:\r\n order += orderOfComputation(Code, prec); # Order of looking at the computation\r\n \r\n for i in order:\r\n \r\n s = total_sub(sub, i); # Computes the total to be subtracted from index.\r\n j = i-s; item = Code[j];\r\n \r\n # Negation case.\r\n if inputs[item] == 1:\r\n f = interpret[item]; inp = interpret[Code[j+1]];\r\n result = f(inp); string = inverse[result];\r\n Code = Code[:j] + [string] + Code[j+2:];\r\n \r\n # Update sub\r\n if not i in sub:\r\n sub[i] = 1;\r\n \r\n else:\r\n sub[i] += 1;\r\n \r\n # Binary Relation case.\r\n elif inputs[item] == 2:\r\n f = interpret[item]; \r\n inp = (interpret[Code[j-1]], interpret[Code[j+1]]);\r\n result = f(*inp); string = inverse[result];\r\n Code = Code[:j-1] + [string] + Code[j+2:];\r\n \r\n # Update sub\r\n if not i in sub:\r\n sub[i] = 2;\r\n \r\n else:\r\n sub[i] += 2;\r\n \r\n else:\r\n raise Exception('incomplete inputs set.')\r\n \r\n \r\n # Tertiary case: brackets left inside to compute.\r\n else: # Here, deal with brackets to make sure no brackets are contained in between.\r\n \r\n # Remove the same total number of brackets from each end.\r\n if not hasMidBrackets(Code):\r\n endB = endBrackets(Code); first = endB[0]; last = endB[1];\r\n Code = Code[first+1: last]; \r\n \r\n return computeList(Code);\r\n \r\n # Keep going until right bracket\r\n j = 0;\r\n while not \")\" in Code[j]: j += 1;\r\n \r\n # Go back for left bracket.\r\n i = j-1;\r\n while not \"(\" in Code[i] or i < 0: i -= 1;\r\n \r\n if i < 0: raise Exception(\"improper use of brackets.\");\r\n \r\n Code = Code[:i] + [ computeList(Code[i+1:j]) ] + Code[j+1:];\r\n \r\n return computeList(Code);","def number_of_extensions(M, root=None):\n\n sp_order_formula = [i for i in M.series_partial_order_representation(root) if\n (i.__contains__('series') or i.__contains__('parallel'))]\n\n while sp_order_formula:\n\n # Extend the children of the current operator\n operator = sp_order_formula.pop()\n left, right = M.tree.successors(operator)\n\n for child in [left, right]:\n\n # Recursion if the child is a operator (also known as a sub-tree in Binary Construction Tree).\n if M.tree.node[child]['num_extension'] == 0:\n if child.__contains__('series') or child.__contains__('parallel'):\n M.tree.node[child]['num_extension'] = number_of_extensions(M, child)\n else:\n M.tree.node[child]['num_extension'] = 1\n\n # Employ the property of series-parallel partial order to calculate the number of extension\n if operator.__contains__('series'):\n num_extension = (M.tree.node[left]['num_extension']) * (M.tree.node[right]['num_extension'])\n M.tree.node[operator]['num_extension'] = num_extension\n\n if operator.__contains__('parallel'):\n # n1, n2 is the number of events (labels) on a partial order, we need to store the previous result.\n n1 = len([i for i in M.series_partial_order_representation(left) if\n not (i.__contains__('series') or i.__contains__('parallel'))])\n n2 = len([i for i in M.series_partial_order_representation(right) if\n not (i.__contains__('series') or i.__contains__('parallel'))])\n\n num_extension = (math.factorial(n1 + n2) / (math.factorial(n1) * (math.factorial(n2)))) * (\n M.tree.node[left]['num_extension']) * (M.tree.node[right]['num_extension'])\n\n M.tree.node[operator]['num_extension'] = num_extension\n #\n # # When series structure\n # if operator.__contains__('series') or operator.__contains__('parallel'):\n # try:\n # # Employ the property of series-parallel partial order to calculate the number of extension\n # if operator.__contains__('series'):\n # num_extension = (M.tree.node[left]['num_extension']) * (M.tree.node[right]['num_extension'])\n # M.tree.node[operator]['num_extension'] = num_extension\n #\n # if operator.__contains__('parallel'):\n # # n1, n2 is the number of events (labels) on a partial order, we need to store the previous result.\n # n1 = len(M.series_partial_order_representation(left))\n # n2 = len(M.series_partial_order_representation(right))\n #\n # num_extension = (math.factorial(n1 + n2) / (math.factorial(n1) * (math.factorial(n2)))) * (\n # M.tree.node[left]['num_extension']) * (M.tree.node[right]['num_extension'])\n #\n # M.tree.node[operator]['num_extension'] = num_extension\n #\n # print \"{}:{}\".format(operator, num_extension)\n # sp_order_formula.append(operator)\n # except Exception:\n # raise Exception\n #\n # # When parallel structure\n # else:\n # if len(temp_stack) > 0:\n # temp_left = temp_stack.pop()\n #\n # # When they share the same parent then push the temp_left to sp_order_formula\n # if M.tree.predecessors(temp_left)[0] == M.tree.predecessors(left)[0]:\n # sp_order_formula.append(operator)\n # sp_order_formula.append(right)\n # sp_order_formula.append(left)\n # sp_order_formula.append(temp_left)\n # # otherwise, keep pushing the new operator(parent) to temp_stack\n # else:\n # temp_stack.append(left)\n # sp_order_formula.append(operator)\n # sp_order_formula.append(right)\n #\n # result = sp_order_formula.pop()\n return M.tree.node[root]['num_extension']","def complex_value(self) -> global___Expression.ComplexValue:","def theta(conc, S, educts):\n\n educts_per_reaction = educts.T\n\n # in every reaction j row, element at pos (column, species) i equals conc_i^educt_{ij}\n # educt_{ij} - how many units of i are educts in reaction j\n multiplicative_term_rows = np.power(conc, educts_per_reaction)\n\n # concentrations to educt product ----> product_{i=1}^{n_s}(conc_i^{educt_{ij}}\n concentration_product = np.prod(multiplicative_term_rows, axis=1)\n\n # returns one row with #reactions elements -> fluxes\n return concentration_product * S","def get_contributions(codings, sorted_factors):\n if codings:\n formulae = []\n for prod_of_factors in codings:\n cur_formula = I\n for n, c in codings[prod_of_factors]:\n if c == 'indicator':\n cur_formula = cur_formula * sorted_factors[n].formula\n else:\n cur_formula = cur_formula * sorted_factors[n].drop_first\n formulae.append((cur_formula, ':'.join(prod_of_factors)))\n else:\n formulae = [(Formula([1]),'1')]\n return formulae","def solve_part1(input, verbose=False):\n equations = parse(input)\n\n result = []\n for eq in equations:\n result.append(solve_equation_same_precedence(eq, verbose))\n\n if verbose:\n print(f\"results: {result}\")\n\n return sum(result)"],"string":"[\n \"def _calculate_syntactic_complexity(self):\\n count = 1 # the copula\\n for subterm in self.subterms:\\n count = count + subterm._calculate_syntactic_complexity()\\n\\n return count\",\n \"def _calculate_complexity(workflow):\\n complexity = estimate_complexity(workflow.type_, workflow.reana_specification)\\n workflow.complexity = complexity\\n Session.commit()\\n return complexity\",\n \"def complexity(self):\\n n = 0\\n ctx = self\\n while ctx is not None:\\n n += 1\\n ctx = ctx.parent()\\n return n\",\n \"def simplify(term):\\n simplified_term = term\\n\\n if isinstance(term,StatementTerm):\\n simplified_term = StatementTerm(subject_term=simplify(term.get_subject_term()),\\n predicate_term=simplify(term.get_predicate_term()),\\n copula=term.get_copula(),\\n interval=term.interval)\\n elif isinstance(term,CompoundTerm):\\n if term.connector == NALSyntax.TermConnector.Negation and \\\\\\n len(term.subterms) == 1 and \\\\\\n isinstance(term.subterms[0],CompoundTerm) and \\\\\\n term.subterms[0].connector == NALSyntax.TermConnector.Negation :\\n # (--,(--,(S --> P)) <====> (S --> P)\\n # Double negation theorem. 2 Negations cancel out\\n simplified_term = simplify(term.subterms[0].subterms[0]) # get the inner statement\\n # elif NALSyntax.TermConnector.is_conjunction(term.connector):\\n # #(&&,A,B..C)\\n # new_subterms = []\\n # new_intervals = []\\n # for i in range(len(term.subterms)):\\n # subterm = simplify(term.subterms[i])\\n # if i < len(term.intervals): new_intervals.append(term.intervals[i])\\n # if isinstance(subterm, CompoundTerm) and subterm.connector == term.connector:\\n # # inner conjunction\\n # new_subterms.extend(subterm.subterms)\\n # new_intervals.extend(subterm.intervals)\\n # else:\\n # new_subterms.append(subterm)\\n #\\n # simplified_term = CompoundTerm(subterms=new_subterms,\\n # term_connector=term.connector,\\n # intervals=new_intervals)\\n elif term.connector is NALSyntax.TermConnector.ExtensionalDifference:\\n pass\\n elif term.connector is NALSyntax.TermConnector.IntensionalDifference:\\n pass\\n elif term.connector is NALSyntax.TermConnector.ExtensionalImage:\\n pass\\n elif term.connector is NALSyntax.TermConnector.IntensionalImage:\\n pass\\n\\n\\n return simplified_term\",\n \"def commands_complexity():\\n complexity()\",\n \"def cyclomaticComplexity (self):\\n self.tarjan()\\n return len(self.__edges) - len(self.__nodes) + 2 * len(self.__scc)\",\n \"def __simplifyRecurse(self): # TODO make this work with ^\\n # check if we're a + node, a * node, or a simple node\\n if isinstance(self.poly, (int, float, Variable.Variable)):\\n return self\\n elif self.poly[0] == \\\"+\\\":\\n self.__handlePowPlus()\\n\\n newPoly = Polynomial()\\n newPoly.poly = [\\\"+\\\"]\\n for branch in self.poly[1:]:\\n simplifiedBranch = ensurePoly(branch).__simplifyRecurse()\\n if not simplifiedBranch.isSimple():\\n for additiveTerm in simplifiedBranch.poly[1:]:\\n newPoly.poly.append(additiveTerm)\\n else:\\n newPoly.poly.append(simplifiedBranch)\\n return newPoly\\n elif self.poly[0] == \\\"*\\\":\\n self.__handlePowTimes()\\n\\n nonSimple, simple = self.__partitionSimpleAndNonSimpleBranches()\\n\\n if len(nonSimple) == 0: # this means our * node gives a monomial!\\n return Polynomial(input=self)\\n else:\\n # do the full distribution\\n simplified = self.__distribute(nonSimple, simple)\\n newPoly = Polynomial()\\n newPoly.poly = [\\\"+\\\"]\\n for branch in simplified.poly[1:]:\\n recursive = ensurePoly(branch).__simplifyRecurse()\\n if recursive.poly[0] == \\\"*\\\":\\n newPoly.poly.append(recursive)\\n elif recursive.poly[0] == \\\"+\\\":\\n newPoly.poly.extend(recursive.poly[1:])\\n return newPoly\\n\\n elif self.poly[0] == \\\"^\\\":\\n # this case will only be hit when we have a ^ node as the root\\n newPoly = Polynomial()\\n newPoly.poly = [\\\"*\\\"]\\n for _ in range(self.poly[2]):\\n newPoly.poly.append(self.poly[1])\\n\\n simp = newPoly.__simplifyRecurse()\\n return simp\",\n \"def get_total_complexity(n):\\n total = 0\\n for i in range(1, n + 1):\\n total += get_complexity(i)\\n return total\",\n \"def complexity(self):\\n raise NotImplementedError()\",\n \"def design_complexity(design: Design) -> int:\\n diversity = 3 * len(design.required)\\n abundance = 2 * sum(design.required.values())\\n return diversity + abundance + design.additional\",\n \"def calculate_compound_costs(self, recursive: bool = True):\\n assert self.graph_handler\\n if not self.start_compounds_set:\\n raise RuntimeError(\\\"No start conditions given\\\")\\n if len(self.graph_handler.graph.nodes) == 0:\\n raise RuntimeError(\\\"No nodes in graph\\\")\\n cmps_to_check = [n for n in self.graph_handler.graph.nodes if ';' not in n\\n and n not in self.start_compounds]\\n # # # Set all compounds to be checked to pseudo inf cost\\n for cmp_id in cmps_to_check:\\n self.compound_costs[cmp_id] = self._pseudo_inf\\n # # # Dictionary for current run\\n tmp_compound_costs: Dict[str, float] = {}\\n # # # Determine convergence variables for while loop\\n current_inf_count = sum(value == self._pseudo_inf for value in self.compound_costs.values())\\n prev_inf_count = current_inf_count\\n # # # Convergence criteria\\n compound_costs_change = None\\n compound_costs_opt_change = 1\\n converged = False\\n # # # Find paths until either no costs are unknown or the None count has not changed\\n while (not converged):\\n compound_costs_opt_change = 0\\n print(\\\"Remaining Nodes:\\\", len(cmps_to_check))\\n for tmp_start_node in self.start_compounds:\\n # # # Loop over all nodes to be checked starting from start nodes\\n for target in cmps_to_check:\\n # # # Determine cost and path with dijkstra's algorithm\\n tmp_cost, _ = nx.single_source_dijkstra(self.graph_handler.graph, tmp_start_node, target,\\n cutoff=None, weight=self.__weight_func)\\n # # # Check if the obtained cost is larger than infinity (pseudo_inf)\\n # # # and continue with the next target if this is the case\\n if (tmp_cost - self._pseudo_inf) > 0.0:\\n continue\\n # # # Add cost of the starting node\\n tmp_cost += self.compound_costs[tmp_start_node]\\n # # # Check for value in compound_costs dict and\\n if (self.compound_costs[target] != self._pseudo_inf and\\n 10e-6 < self.compound_costs[target] - tmp_cost):\\n compound_costs_opt_change += 1\\n # # # Not already set check\\n if self.compound_costs[target] == self._pseudo_inf or (\\n self.compound_costs != self._pseudo_inf and 10e-6 < self.compound_costs[target] - tmp_cost):\\n # # # Not discovered in current run OR new tmp cost lower than stored cost\\n if (target not in tmp_compound_costs.keys()):\\n tmp_compound_costs[target] = tmp_cost\\n elif (tmp_cost < tmp_compound_costs[target]):\\n tmp_compound_costs[target] = tmp_cost\\n # # # Write obtained compound_costs to overall dictionary\\n for key, value in tmp_compound_costs.items():\\n self.compound_costs[key] = value\\n # # # Remove found nodes if recursive is false\\n if not recursive:\\n cmps_to_check.remove(key)\\n # # # Reset tmp_pr_cost\\n tmp_compound_costs = {}\\n # # # Convergence Check\\n current_inf_count = sum(value == self._pseudo_inf for value in self.compound_costs.values())\\n compound_costs_change = prev_inf_count - current_inf_count\\n prev_inf_count = current_inf_count\\n\\n print(50 * '-')\\n print(\\\"Current None:\\\", current_inf_count)\\n print(\\\"PR Change:\\\", compound_costs_change)\\n print(\\\"PR Opt Change:\\\", compound_costs_opt_change)\\n # # # Convergence Check\\n if (compound_costs_change == 0 and compound_costs_opt_change == 0):\\n converged = True\\n\\n # # # Final check if all compound costs are solved\\n if current_inf_count == 0:\\n self.compound_costs_solved = True\",\n \"def complexity(self):\\n complexity = 0\\n for k in self.keys():\\n for i, j in combinations(range(1, max(k) + 1), 2):\\n seq = filter(lambda x: x == i or x == j, k)\\n cpxty = len([p for p, q in pairwise(seq) if p != q])\\n complexity = max(cpxty, complexity)\\n return complexity\",\n \"def complexity(self):\\n from kinbaku._pygenie import gettype, getpath\\n from kinbaku.python import Dotpath\\n if not self.contents:\\n return\\n try:\\n stats = measure_complexity(self.contents, self.fname)\\n except SyntaxError:\\n return None\\n\\n out = PrettyPrinter(StringIO()).flatten_stats(stats)\\n out = [ [ gettype(_type),\\n getpath(_type,dotpath),\\n score ] for _type, dotpath, score in out ]\\n return out\",\n \"def calc_complexity_step(self, adj_ens, feat_ens, sizes_subg_ens):\\n num_ensemble = len(feat_ens)\\n dims_ens = []\\n ops = 0\\n for i in range(num_ensemble):\\n if len(self.type_feature_augment) > 0:\\n for ia, _ in enumerate(self.type_feature_augment): # this does not change feat dim\\n ops += np.prod(list(self.aug_layers[i][ia].weight.shape)) * feat_ens[i].shape[0]\\n dims_respool = []\\n dims_conv = (layers.Dims_X(*(feat_ens[i].shape)), layers.Dims_adj(adj_ens[i].shape[0], adj_ens[i].size))\\n for md in self.conv_layers[i]:\\n dims_conv, _ops = md.complexity(*dims_conv)\\n dims_respool.append(dims_conv[0])\\n ops += _ops\\n dims_emb, _ops = self.res_pool_layers[i].complexity(dims_respool, sizes_subg_ens)\\n ops += _ops\\n dims_ens.append(dims_emb)\\n dims_cls, _ops = self.ensembler.complexity(dims_ens)\\n ops += _ops\\n _dims_final, _ops = self.classifier.complexity(dims_cls)\\n ops += _ops\\n return ops\",\n \"def rational_function_coefficient_descent(rational_function, sigma, poly_ring):\\n\\n if rational_function.parent().is_field():\\n S = rational_function.parent().ring()\\n else:\\n S = rational_function.parent()\\n\\n if rational_function == S(0):\\n return poly_ring(0)\\n\\n num = S(rational_function.numerator())\\n denom = S(rational_function.denominator())\\n f = num.coefficients()\\n fe = num.exponents()\\n g = denom.coefficients()\\n ge = denom.exponents()\\n #force the cancellation of common coefficient factors by scaling by f[-1]\\n ff = [ field_descent(sigma, x/f[-1]) for x in f]\\n gg = [ field_descent(sigma, x/f[-1]) for x in g]\\n if None in ff or None in gg:\\n return\\n\\n z = poly_ring.gen(0)\\n numer = sum( poly_ring(ff[i])*z**fe[i] for i in range(len(ff)) )\\n denom = sum( poly_ring(gg[i])*z**ge[i] for i in range(len(gg)) )\\n return numer / denom\",\n \"def complexity(s, **kwargs):\\n num, den = 1, 1\\n for k in range(1, len(s)):\\n k4 = 4**k # For DNA\\n num += min(len(set(s[i:i+k] for i in range(len(s) - k + 1))), k4)\\n den += min(len(s) - k + 1, k4)\\n return num / den\",\n \"def complexity(self) -> str:\\n return pulumi.get(self, \\\"complexity\\\")\",\n \"def parse_toplevel_subterms_and_connector(cls, compound_term_string):\\n compound_term_string = compound_term_string.replace(\\\" \\\",\\\"\\\")\\n subterms = []\\n intervals = []\\n internal_string = compound_term_string[1:-1] # string with no outer parentheses () or set brackets [], {}\\n\\n # check for intensional/extensional set [a,b], {a,b}\\n connector = NALSyntax.TermConnector.get_term_connector_from_string(compound_term_string[0])\\n if connector is None:\\n # otherwise check for regular Term/Statement connectors\\n if internal_string[1] == NALSyntax.StatementSyntax.TermDivider.value:\\n connector_string = internal_string[0] # Term connector\\n else:\\n connector_string = internal_string[0:2] # Statement connector\\n connector = NALSyntax.TermConnector.get_term_connector_from_string(connector_string)\\n\\n assert (internal_string[\\n len(\\n connector.value)] == NALSyntax.StatementSyntax.TermDivider.value), \\\"Connector not followed by comma in CompoundTerm string \\\" + compound_term_string\\n internal_string = internal_string[len(connector.value) + 1:]\\n\\n assert (connector is not None), \\\"Connector could not be parsed from CompoundTerm string.\\\"\\n\\n depth = 0\\n subterm_string = \\\"\\\"\\n for i, c in enumerate(internal_string):\\n if c == NALSyntax.StatementSyntax.Start.value or NALSyntax.TermConnector.is_set_bracket_start(c):\\n depth += 1\\n elif c == NALSyntax.StatementSyntax.End.value or NALSyntax.TermConnector.is_set_bracket_end(c):\\n depth -= 1\\n\\n if c == NALSyntax.StatementSyntax.TermDivider.value and depth == 0:\\n if subterm_string.isdigit():\\n intervals.append(int(subterm_string))\\n else:\\n subterm = Term.from_string(subterm_string)\\n subterms.append(subterm)\\n subterm_string = \\\"\\\"\\n else:\\n subterm_string += c\\n\\n subterm = Term.from_string(subterm_string)\\n subterms.append(subterm)\\n\\n return subterms, connector, intervals\",\n \"def count_consonants_recursive(input):\\n if len(input) == 0:\\n return 0\\n if input[0].lower() in consonants:\\n return 1 + count_consonants_recursive(input[1:])\\n else:\\n return count_consonants_recursive(input[1:])\",\n \"def complex_sum(c_1,c_2):\\n return c_1 + c_2\",\n \"def nth_order_const_coeff(*coeffs: List[Symbol], t: Symbol = t) -> Tuple[List[Symbol], Procedure]:\\n\\n # First, set up characteristic equation.\\n char_eq_r, r = sympy.S.Zero, Dummy('r')\\n\\n for order, coeff in enumerate(coeffs[::-1]):\\n char_eq_r += coeff * r ** order\\n\\n char_eq = Poly(char_eq_r, r)\\n\\n # Can't just call roots because it doesn't return rootof for unsolveable\\n # polynomials.\\n char_eq_roots = roots(char_eq, multiple=True)\\n\\n root_dict = defaultdict(int) # type: Dict[int, int]\\n\\n conjugate_roots = []\\n for root in char_eq_roots:\\n root_dict[root] += 1\\n\\n sols = []\\n for root, mult in root_dict.items():\\n for i in range(mult):\\n if isinstance(root, RootOf):\\n sols.append(t**i * exp(root*t))\\n elif root.is_real:\\n sols.append(t**i*exp(root*t))\\n else:\\n if root in conjugate_roots:\\n continue\\n reroot = re(root)\\n imroot = im(root)\\n conjugate_roots.append(conjugate(root))\\n sols.append(t**i*exp(reroot*t) * sin(abs(imroot) * t))\\n sols.append(t**i*exp(reroot*t) * cos(imroot * t))\\n\\n # collect roots for display\\n p_roots = []\\n count = 1\\n for root, mult in root_dict.items():\\n p_roots.append(Eq(Dummy('r_{}'.format(\\n \\\",\\\".join([str(i) for i in range(count, count + mult)]))), root, evaluate=False))\\n count += mult\\n\\n procedure = Procedure()\\n procedure\\\\\\n .text('Characteristic equation: ', nl=True)\\\\\\n .eq(Eq(char_eq_r, 0, evaluate=False))\\\\\\n .text('Roots: ')\\\\\\n .equarr(p_roots)\\\\\\n .text('General Solution: ', nl=True)\\\\\\n .eq(Eq(Dummy('y'), to_general(sols)[0], evaluate=False))\\n\\n return sols, procedure\",\n \"def _cmplx_add_ ( s , o ) :\\n return o + complex ( s )\",\n \"def __mul__(self, other, nested=False):\\n\\n other = formula(other, namespace=self.namespace)\\n\\n selftermnames = self.termnames()\\n othertermnames = other.termnames()\\n\\n I = len(selftermnames)\\n J = len(othertermnames)\\n\\n terms = []\\n termnames = []\\n\\n for i in range(I):\\n for j in range(J):\\n termname = '%s*%s' % (str(selftermnames[i]), str(othertermnames[j]))\\n pieces = termname.split('*')\\n pieces.sort()\\n termname = '*'.join(pieces)\\n termnames.append(termname)\\n\\n selfnames = self.terms[i].names()\\n othernames = other.terms[j].names()\\n\\n if self.terms[i].name is 'intercept':\\n _term = other.terms[j]\\n _term.namespace = other.namespace\\n\\n elif other.terms[j].name is 'intercept':\\n _term = self.terms[i]\\n _term.namespace = self.namespace\\n else:\\n names = []\\n\\n d1 = len(selfnames) \\n d2 = len(othernames)\\n\\n for r in range(d1):\\n for s in range(d2):\\n name = '%s*%s' % (str(selfnames[r]), str(othernames[s]))\\n pieces = name.split('*')\\n pieces.sort()\\n name = '*'.join(pieces)\\n names.append(name)\\n\\n def product_func(value, d1=d1, d2=d2):\\n\\n out = []\\n for r in range(d1):\\n for s in range(d2):\\n out.append(value[r] * value[d1+s])\\n return N.array(out)\\n\\n sumterms = self + other\\n sumterms.terms = [self, other] # enforce the order we want\\n sumterms.namespace = self.namespace\\n\\n _term = quantitative(names, func=sumterms, termname=termname,\\n transform=product_func)\\n _term.namespace = self.namespace\\n\\n\\n terms.append(_term)\\n\\n return formula(terms, namespace=self.namespace)\",\n \"def simplify(self): # TODO too complex, refactor\\n simplified = self.__simplifyRecurse()\\n # distributed out the polynomial. Now need to collect like terms\\n simplified.vars = self.vars.copy()\\n orderedVars = sorted(list(self.vars))\\n\\n powers = {} # will have keys of tuples. The tuples will represent the power of a variable. Values will be the\\n for monomial in simplified.poly[1:]:\\n power = [0] * len(orderedVars)\\n total = 0\\n\\n if monomial.isSimple():\\n monomial.poly = [\\\"*\\\", monomial.poly]\\n\\n for term in monomial.poly[1:]:\\n term = ensurePoly(term)\\n if isinstance(term.poly, (int, float)):\\n total += term.poly\\n elif isinstance(term.poly, (Variable.Variable)):\\n power[orderedVars.index(term.poly)] += 1\\n\\n power = tuple(power)\\n if power not in powers:\\n powers[power] = total\\n else:\\n powers[power] = min(total, powers[power])\\n\\n finalPoly = Polynomial()\\n finalPoly.poly = [\\\"+\\\"]\\n finalPoly.vars = self.vars.copy()\\n for power in sorted(list(powers.keys())):\\n monomial = Polynomial()\\n monomial.poly = [\\\"*\\\"]\\n if powers[power] != 0:\\n monomial.poly.append(powers[power])\\n\\n for pow, ind in zip(power, range(len(power))):\\n if pow == 0:\\n continue\\n elif pow == 1:\\n monomial.poly.append(orderedVars[ind])\\n else:\\n monomial.poly.append(orderedVars[ind]**pow)\\n finalPoly.poly.append(monomial)\\n return finalPoly\",\n \"def continued_fraction(a) -> list:\\n e = _sympify(a)\\n if all(i.is_Rational for i in e.atoms()):\\n if e.is_Integer:\\n return continued_fraction_periodic(e, 1, 0)\\n elif e.is_Rational:\\n return continued_fraction_periodic(e.p, e.q, 0)\\n elif e.is_Pow and e.exp is S.Half and e.base.is_Integer:\\n return continued_fraction_periodic(0, 1, e.base)\\n elif e.is_Mul and len(e.args) == 2 and (\\n e.args[0].is_Rational and\\n e.args[1].is_Pow and\\n e.args[1].base.is_Integer and\\n e.args[1].exp is S.Half):\\n a, b = e.args\\n return continued_fraction_periodic(0, a.q, b.base, a.p)\\n else:\\n # this should not have to work very hard- no\\n # simplification, cancel, etc... which should be\\n # done by the user. e.g. This is a fancy 1 but\\n # the user should simplify it first:\\n # sqrt(2)*(1 + sqrt(2))/(sqrt(2) + 2)\\n p, d = e.expand().as_numer_denom()\\n if d.is_Integer:\\n if p.is_Rational:\\n return continued_fraction_periodic(p, d)\\n # look for a + b*c\\n # with c = sqrt(s)\\n if p.is_Add and len(p.args) == 2:\\n a, bc = p.args\\n else:\\n a = S.Zero\\n bc = p\\n if a.is_Integer:\\n b = S.NaN\\n if bc.is_Mul and len(bc.args) == 2:\\n b, c = bc.args\\n elif bc.is_Pow:\\n b = Integer(1)\\n c = bc\\n if b.is_Integer and (\\n c.is_Pow and c.exp is S.Half and\\n c.base.is_Integer):\\n # (a + b*sqrt(c))/d\\n c = c.base\\n return continued_fraction_periodic(a, d, c, b)\\n raise ValueError(\\n 'expecting a rational or quadratic irrational, not %s' % e)\",\n \"def time_complexities():\\n return \\\"Best Case: O(n), Average Case: O(n), Worst Case: O(n)\\\"\",\n \"def countRecursiveReferences(self) -> Tuple[Dict[str, List[str]], Dict[str, Dict[str, int]]]:\\n countReferences = {}\\n isReferencedBy = {}\\n for nt in self.non_terminals: # for each non-terminal in the grammar\\n for production in self.grammar[nt]: # for each possible production on that non terminal\\n count = {}\\n for option in production.split(): # iterate over the production's terms\\n count.setdefault(option, 0)\\n if option in self.non_terminals: # if the term is a non terminal\\n count[option] += 1 # the number of times that option has been referenced increases\\n isReferencedBy.setdefault(option, set())\\n isReferencedBy[option].add(nt)\\n \\n for key in count:\\n count.setdefault(key, 0)\\n countReferences.setdefault(key, {})\\n countReferences[key].setdefault(nt, 0)\\n\\n countReferences[key][nt] = max(\\n countReferences[key][nt], count[key]) # the number of references of the non terminal is for this\\n # term is the maximum between all productions in this non terminal\\n\\n return isReferencedBy, countReferences\",\n \"def __mul__(self, other, nested=False):\\n\\n other = Formula(other)\\n\\n selftermnames = self.termnames()\\n othertermnames = other.termnames()\\n\\n I = len(selftermnames)\\n J = len(othertermnames)\\n\\n terms = []\\n termnames = []\\n\\n for i in range(I):\\n for j in range(J):\\n termname = '%s*%s' % (str(selftermnames[i]), str(othertermnames[j]))\\n pieces = sorted(termname.split('*'))\\n termname = '*'.join(pieces)\\n termnames.append(termname)\\n\\n selfnames = self.terms[i].names()\\n othernames = other.terms[j].names()\\n\\n if self.terms[i].name is 'intercept':\\n _term = other.terms[j]\\n _term.namespace = other.namespace\\n elif other.terms[j].name is 'intercept':\\n _term = self.terms[i]\\n _term.namespace = self.namespace\\n else:\\n names = []\\n\\n d1 = len(selfnames)\\n d2 = len(othernames)\\n\\n for r in range(d1):\\n for s in range(d2):\\n name = '%s*%s' % (str(selfnames[r]), str(othernames[s]))\\n pieces = sorted(name.split('*'))\\n name = '*'.join(pieces)\\n names.append(name)\\n\\n def product_func(value, d1=d1, d2=d2):\\n\\n out = []\\n for r in range(d1):\\n for s in range(d2):\\n out.append(value[r] * value[d1+s])\\n return np.array(out)\\n\\n cself = copy.copy(self.terms[i])\\n cother = copy.copy(other.terms[j])\\n sumterms = cself + cother\\n sumterms.terms = [cself, cother] # enforce the order we want\\n\\n _term = Quantitative(names, func=sumterms,\\n termname=termname,\\n transform=product_func)\\n\\n if _namespace_equal(self.namespace, other.namespace):\\n _term.namespace = self.namespace\\n\\n terms.append(_term)\\n\\n return Formula(terms)\",\n \"def test_complexity(tmp_path: Path, capsys) -> None:\\n file_content = '\\\"\\\"\\\"Docstring.\\\"\\\"\\\"\\\\n\\\\n'\\n program = \\\"\\\"\\\"\\n elements = [open(str(i)) for i in range(10)]\\n\\n\\n def foo():\\n \\\\\\\"\\\\\\\"\\\\\\\"Docstring.\\\\\\\"\\\\\\\"\\\\\\\"\\n if elements[0]:\\n aaa = 1\\n elif elements[1]:\\n aaa = 1\\n elif elements[2]:\\n aaa = 1\\n elif elements[3]:\\n aaa = 1\\n elif elements[4]:\\n aaa = 1\\n elif elements[5]:\\n aaa = 1\\n elif elements[6]:\\n aaa = 1\\n elif elements[7]:\\n aaa = 1\\n elif elements[8]:\\n aaa = 1\\n elif elements[9]:\\n aaa = 1\\n print(aaa)\\n \\\"\\\"\\\"\\n file_content += dedent(program)\\n run_linter(tmp_path, capsys, file_content, \\\"'foo' is too complex (11)\\\")\",\n \"def calc_process_cohesion(partitions, graph):\\n ch = 0\\n for part in partitions:\\n crc = calc_community_relation_cohesion(part, graph)\\n cic = calc_community_information_cohesion(part, graph)\\n ch = ch + (crc * cic)\\n ch = ch / len(partitions)\\n return ch\",\n \"def continued_fraction_reduce(cf):\\n from sympy.solvers import solve\\n\\n period = []\\n x = Dummy('x')\\n\\n def untillist(cf):\\n for nxt in cf:\\n if isinstance(nxt, list):\\n period.extend(nxt)\\n yield x\\n break\\n yield nxt\\n\\n a = S.Zero\\n for a in continued_fraction_convergents(untillist(cf)):\\n pass\\n\\n if period:\\n y = Dummy('y')\\n solns = solve(continued_fraction_reduce(period + [y]) - y, y)\\n solns.sort()\\n pure = solns[-1]\\n rv = a.subs(x, pure).radsimp()\\n else:\\n rv = a\\n if rv.is_Add:\\n rv = factor_terms(rv)\\n if rv.is_Mul and rv.args[0] == -1:\\n rv = rv.func(*rv.args)\\n return rv\",\n \"def innerProd(linearCombo1, linearCombo2):\\n innerProd = 0\\n # TODO: I'm starting with simple sets on both sides, not sum of sets, \\n # with coefficient 1. We need to fix this later\\n # TODO: find way to represent dashed vs undashed arrows\\n # For now, assume both are already sums (sets) of dashed subdiagrams\\n\\n # copy linear combinations to make it easier to alter them as needed\\n linearComboCopy1 = deepcopy(linearCombo1)\\n linearComboCopy2 = deepcopy(linearCombo2)\\n print len(linearComboCopy2[0][1])\\n\\n # get list of subdiagrams, get coefficients\\n for coeffAndSubdiagrams1 in linearComboCopy1:\\n subdiagramSet1 = coeffAndSubdiagrams1[1]\\n coeff1 = coeffAndSubdiagrams1[0]\\n subdiagramsToRemove1 = []\\n\\n for coeffAndSubdiagrams2 in linearComboCopy2:\\n subdiagramSet2 = coeffAndSubdiagrams2[1]\\n coeff2 = coeffAndSubdiagrams2[0]\\n subdiagramsToRemove2 = []\\n\\n # look for equivalent pairs of dashed subdiagrams in both lists\\n for subdiagram1 in subdiagramSet1:\\n for subdiagram2 in subdiagramSet2: \\n # for equivalent pairs of dashed subdiagrams, increment innerProd by \\n # product of coefficients and remove the subdiagrams to avoid \\n # over-counting diagrams\\n if equiv(subdiagram1, subdiagram2):\\n innerProd += coeff1 * coeff2\\n subdiagramsToRemove1.append(subdiagram1)\\n subdiagramsToRemove2.append(subdiagram2)\\n print \\\" \\\", innerProd\\n # remove the used subdiagrams\\n # print \\\"sub 2\\\\t\\\" + str(subdiagramSet2)\\n # print \\\" 2 \\\" + str(subdiagramsToRemove2)\\n # print \\\" 1 \\\" + str(subdiagramsToRemove1)\\n for removal2 in subdiagramsToRemove2:\\n # print \\\" remove \\\" + str(removal2)\\n subdiagramSet2.remove(removal2)\\n subdiagramsToRemove2 = []\\n # for removal1 in subdiagramsToRemove1:\\n # subdiagramSet1.remove(removal1) \\n return innerProd\",\n \"def number_of_connectives(formula):\\n pass\\n # ======== YOUR CODE HERE ========\",\n \"def compute(n):\\n if n == 1:\\n return 1\\n else:\\n i = find_i(n)\\n return 2 * compute(n - i) + 2 ** i - 1\",\n \"def parse_algebra(self):\\r\\n # 0.33 or 7 or .34 or 16.\\r\\n number_part = Word(nums)\\r\\n inner_number = (number_part + Optional(\\\".\\\" + Optional(number_part))) | (\\\".\\\" + number_part)\\r\\n # pyparsing allows spaces between tokens--`Combine` prevents that.\\r\\n inner_number = Combine(inner_number)\\r\\n\\r\\n # SI suffixes and percent.\\r\\n number_suffix = MatchFirst(Literal(k) for k in SUFFIXES.keys())\\r\\n\\r\\n # 0.33k or 17\\r\\n plus_minus = Literal('+') | Literal('-')\\r\\n number = Group(\\r\\n Optional(plus_minus) +\\r\\n inner_number +\\r\\n Optional(CaselessLiteral(\\\"E\\\") + Optional(plus_minus) + number_part) +\\r\\n Optional(number_suffix)\\r\\n )\\r\\n number = number(\\\"number\\\")\\r\\n\\r\\n # Predefine recursive variables.\\r\\n expr = Forward()\\r\\n\\r\\n # Handle variables passed in. They must start with letters/underscores\\r\\n # and may contain numbers afterward.\\r\\n inner_varname = Word(alphas + \\\"_\\\", alphanums + \\\"_\\\")\\r\\n varname = Group(inner_varname)(\\\"variable\\\")\\r\\n varname.setParseAction(self.variable_parse_action)\\r\\n\\r\\n # Same thing for functions.\\r\\n function = Group(inner_varname + Suppress(\\\"(\\\") + expr + Suppress(\\\")\\\"))(\\\"function\\\")\\r\\n function.setParseAction(self.function_parse_action)\\r\\n\\r\\n atom = number | function | varname | \\\"(\\\" + expr + \\\")\\\"\\r\\n atom = Group(atom)(\\\"atom\\\")\\r\\n\\r\\n # Do the following in the correct order to preserve order of operation.\\r\\n pow_term = atom + ZeroOrMore(\\\"^\\\" + atom)\\r\\n pow_term = Group(pow_term)(\\\"power\\\")\\r\\n\\r\\n par_term = pow_term + ZeroOrMore('||' + pow_term) # 5k || 4k\\r\\n par_term = Group(par_term)(\\\"parallel\\\")\\r\\n\\r\\n prod_term = par_term + ZeroOrMore((Literal('*') | Literal('/')) + par_term) # 7 * 5 / 4\\r\\n prod_term = Group(prod_term)(\\\"product\\\")\\r\\n\\r\\n sum_term = Optional(plus_minus) + prod_term + ZeroOrMore(plus_minus + prod_term) # -5 + 4 - 3\\r\\n sum_term = Group(sum_term)(\\\"sum\\\")\\r\\n\\r\\n # Finish the recursion.\\r\\n expr << sum_term # pylint: disable=W0104\\r\\n self.tree = (expr + stringEnd).parseString(self.math_expr)[0]\",\n \"def complexity(self, mode='#nodes'):\\n if mode == '#nodes':\\n return len(self.nodes)\",\n \"def get_complexity(n):\\n try:\\n return complexity_map[n]\\n except KeyError:\\n if n - 1 in complexity_map:\\n complexity_map[n] = complexity_map[n - 1] + 1\\n for i in range(2, int(floor(n / 2) + 1)):\\n if n % i == 0:\\n complexity = get_complexity(i) + get_complexity(n / i)\\n if n not in complexity_map or complexity < complexity_map[n]:\\n complexity_map[n] = complexity\\n return complexity_map[n]\",\n \"def _AddCompound(self, kegg_id, how_many):\\n i = self._FindCompoundIndex(kegg_id)\\n if i is not None:\\n self.reactants[i].coeff += how_many\\n else:\\n self.reactants += [CompoundWithCoeff.FromId(how_many, kegg_id)]\\n \\n # clear the cache since the reaction has changed\\n self._catalyzing_enzymes = None\",\n \"def test_linear_comb() -> None:\\n SumStr = FormalLinearCombination(\\n str, complex, complex(0, 0), lambda z1, z2: z1+z2)\\n flc_1a2b3c = SumStr(\\n [(complex(1, 0), \\\"a\\\"), (complex(2, 0), \\\"b\\\"), (complex(3, 0), \\\"c\\\")])\\n assert str(flc_1a2b3c) == \\\"(1+0j)*a+(2+0j)*b+(3+0j)*c\\\"\\n two_flc_1a2b3c = flc_1a2b3c+flc_1a2b3c\\n exp_two_flc_1a2b3c = SumStr(\\n [(complex(2, 0), \\\"a\\\"), (complex(4, 0), \\\"b\\\"), (complex(6, 0), \\\"c\\\")])\\n assert str(two_flc_1a2b3c) == \\\"(2+0j)*a+(4+0j)*b+(6+0j)*c\\\"\\n assert exp_two_flc_1a2b3c == two_flc_1a2b3c\\n assert str(flc_1a2b3c*flc_1a2b3c) == \\\"(1+0j)*aa+(2+0j)*ab+(3+0j)*ac\\\"+\\\\\\n \\\"+(2+0j)*ba+(4+0j)*bb+(6+0j)*bc\\\"+\\\\\\n \\\"+(3+0j)*ca+(6+0j)*cb+(9+0j)*cc\\\"\",\n \"def solve_part2(input, verbose=False):\\n equations = parse(input)\\n\\n result = []\\n for eq in equations:\\n result.append(solve_equation_addition_precendence(eq, verbose))\\n\\n if verbose:\\n print(f\\\"results: {result}\\\")\\n\\n return sum(result)\",\n \"def concretise_ast(node):\\n node.children = list(node.get_children())\\n\\n for child in node.children:\\n counter = concretise_ast(child)\",\n \"def cosh(self):\\n return type(self)(self.parent(),\\n self._simplify(self._express.cosh()))\",\n \"def calculate (self,phrase):\\r\\n\\r\\n\\r\\n def bracketed (phrase,bracketing='()'):\\r\\n\\r\\n \\\"\\\"\\\"Returns TRUE if <phrase> is encompassed by a left bracket and a right bracket\\r\\n at the same hierarchical level\\\"\\\"\\\"\\r\\n\\r\\n level = 0\\r\\n left_point = None\\r\\n right_point = None\\r\\n \\r\\n\\r\\n for count,char in enumerate(phrase):\\r\\n\\r\\n if char == bracketing[0]:\\r\\n if level == 0:\\r\\n left_point = count\\r\\n level+=1\\r\\n if char == bracketing[1]:\\r\\n level-=1\\r\\n if level == 0:\\r\\n right_point = count\\r\\n if not (left_point is None) and (not right_point is None) and left_point == 0 and right_point == len(phrase)-1:\\r\\n return True\\r\\n return False\\r\\n\\r\\n def quoted (phrase):\\r\\n\\r\\n level = 0\\r\\n foundchar = ''\\r\\n left_point = None\\r\\n right_point = None \\r\\n for count,char in enumerate(phrase):\\r\\n\\r\\n if char in ['\\\"',\\\"'\\\"] and level == 0:\\r\\n foundchar = char\\r\\n left_point = count\\r\\n level += 1\\r\\n elif level == 1 and char == foundchar:\\r\\n right_point = count\\r\\n level += 1\\r\\n if not (left_point is None) and (not right_point is None) and left_point == 0 and right_point == len(phrase)-1:\\r\\n return True\\r\\n return False \\r\\n \\r\\n \\r\\n\\r\\n def is_function(phrase):\\r\\n\\r\\n \\\"\\\"\\\"Tests to see if a phrase begins with a predefined function,\\r\\n in which case it returns information about the iarity of function\\\"\\\"\\\"\\r\\n \\r\\n \\r\\n for x in self.functions.keys():\\r\\n\\r\\n if len(x) < len(phrase) and phrase[0:len(x)] == x:\\r\\n if bracketed(phrase[len(x):]):\\r\\n if self.functions[x][1]-1 <= phrase.count(',') <= self.functions[x][2]-1:\\r\\n return x, self.functions[x][0], self.functions[x][2], phrase[len(x):]\\r\\n else:\\r\\n return False,False,False,False \\r\\n \\r\\n\\r\\n def all_simple (phrase):\\r\\n\\r\\n \\\"\\\"\\\"Tests if a phrase is a simple string representing an expression, rather than an operation\\\"\\\"\\\"\\r\\n\\r\\n\\r\\n for x in phrase:\\r\\n if (x not in self.operations and not (isinstance(x,(int,type(ListType()),float,bool) or (isinstance(x,str) and quoted(x)))) or self.current_register.contains(x)):\\r\\n return False\\r\\n return True\\r\\n \\r\\n def parse (phrase):\\r\\n\\r\\n \\r\\n COMPTERMS = ['==','>=','<=','!=','>','<',]\\r\\n\\r\\n\\r\\n def contains_comp (x):\\r\\n \\\"\\\"\\\"True is x contains any of the COMP Terms\\\"\\\"\\\"\\r\\n\\r\\n for comp in COMPTERMS:\\r\\n if comp in x:\\r\\n return True\\r\\n return False\\r\\n\\r\\n\\r\\n \\r\\n \\\"\\\"\\\"Parses and analzes the phrase\\\"\\\"\\\"\\r\\n\\r\\n \\r\\n if phrase in ['bTrue','bFalse','EmptyList']:\\r\\n return {'bTrue':True,\\r\\n 'bFalse':False,\\r\\n 'EmptyList':ListType()}[phrase]\\r\\n\\r\\n if isinstance(phrase,str):\\r\\n \\r\\n if quoted(phrase):\\r\\n return phrase\\r\\n else:\\r\\n try:\\r\\n return float(phrase)\\r\\n except:\\r\\n pass\\r\\n \\r\\n\\r\\n # If the phrase is a string\\r\\n phrase = phrase.strip()\\r\\n\\r\\n func_name, func, iarity, func_phrase = is_function(phrase)\\r\\n # tests is it is function; otherwise the values are false.\\r\\n \\r\\n \\r\\n\\r\\n if func_name:\\r\\n if iarity == 1:\\r\\n # If the function accepts one value\\r\\n return func(parse(func_phrase))\\r\\n if iarity == 2:\\r\\n # Two values \\r\\n func_phrase = func_phrase[1:-1]\\r\\n term1,term2 = func_phrase.split(',')[0],func_phrase.split(',')[1]\\r\\n return func(parse(term1),parse(term2))\\r\\n if iarity == 3:\\r\\n func_phrase = func_phrase[1:-1]\\r\\n term1,term2, term3 = func_phrase.split(',')[0],func_phrase.split(',')[1],func_phrase.split(',')[2]\\r\\n return func(parse(term1),parse(term2),parse(term3))\\r\\n \\r\\n if iarity >3:\\r\\n # A list of values \\r\\n func_phrase = func_phrase[1:-1]\\r\\n return func([parse(x) for x in func_phrase.split(',')])\\r\\n elif phrase and phrase[0] == '-' and bracketed(phrase[1:]):\\r\\n # Translates negative sign (as opposed to operators) into corresponding function \\r\\n return -parse(phrase[2:-1])\\r\\n\\r\\n\\r\\n elif bracketed(phrase):\\r\\n # removes top-level bracket\\r\\n phrase = phrase[1:-1]\\r\\n return parse(phrase)\\r\\n elif phrase in self.operations:\\r\\n return phrase\\r\\n elif self.current_register.contains(phrase):\\r\\n # for variables and constants\\r\\n return self.current_register.get(phrase)\\r\\n elif contains_comp(phrase) and '(' not in phrase and ')' not in phrase:\\r\\n return calc.computer.get(phrase)\\r\\n elif phrase and phrase[0]=='@' and phrase[-1]=='@':\\r\\n # to retrieve values from the log \\r\\n index = int(parse(phrase[1:-1]))\\r\\n if 0<= index <= len(self.lines):\\r\\n return self.lines[index][0]\\r\\n else:\\r\\n \\r\\n phrase = list(phrase)\\r\\n #phrase is converted to a list to allowing indexical assignments\\r\\n operation_sequence = []\\r\\n level = 0\\r\\n inquotes = False\\r\\n quote_form = ''\\r\\n for counter, x in enumerate(phrase):\\r\\n\\r\\n # Search for operators that are not enclosed in parantheses\\r\\n\\r\\n if not inquotes and x in ['\\\"',\\\"'\\\"]:\\r\\n inquotes = True\\r\\n quote_form = x\\r\\n elif inquotes and x == quote_form:\\r\\n if counter < len(phrase)-1:\\r\\n if phrase[counter+1] in ['+']:\\r\\n phrase[counter+1] = '#+#'\\r\\n\\r\\n if x == '(':\\r\\n level +=1\\r\\n\\r\\n if x == ')':\\r\\n level -=1\\r\\n if level == 0:\\r\\n if counter<len(phrase)-1:\\r\\n if phrase[counter+1] in self.operations:\\r\\n # If an operator is found, surround it with pound signs\\r\\n phrase[counter+1] = '#'+phrase[counter+1]+'#'\\r\\n if phrase[counter+2] in self.operations:\\r\\n phrase[counter+2] = '~'\\r\\n # For a minus sign that is not an operator\\r\\n\\r\\n \\r\\n phrase = ''.join(phrase).replace('~','-').split('#')\\r\\n # Split the phrase into expressions linked by operators \\r\\n newphrase = []\\r\\n for x in phrase:\\r\\n # a clumsy way to distinction between numerical values, and string operators\\r\\n try:\\r\\n newphrase.append(float(x))\\r\\n except:\\r\\n newphrase.append(x)\\r\\n phrase = newphrase\\r\\n\\r\\n return parse(phrase)\\r\\n \\r\\n \\r\\n\\r\\n if isinstance(phrase,list):\\r\\n # If the phrase has already been parsed into a list \\r\\n if len(phrase) == 1:\\r\\n return (parse(phrase[0]))\\r\\n if all_simple(phrase):\\r\\n # If every value in the phrase list has been reduced to\\r\\n # a numerical value or an operator\\r\\n \\r\\n\\r\\n for operation in self.operations:\\r\\n\\r\\n #In order to preserve the correct order of operations,\\r\\n #the operations are analyzed in succession\\r\\n\\r\\n while operation in phrase:\\r\\n\\r\\n #This repeat as long as the operation is in the phrase,\\r\\n #since with each pass it only \\\"reduced\\\"\\r\\n #expression/operator/expression triplet\\r\\n \\r\\n\\r\\n newlist = [] # For the result of each pass through the list.\\r\\n lastvalue = None\\r\\n counter = 0\\r\\n stop = False\\r\\n while counter < len(phrase) and not stop:\\r\\n \\r\\n \\r\\n if counter < len(phrase)-2:\\r\\n a = phrase[counter]\\r\\n op = phrase[counter+1]\\r\\n b = phrase[counter+2]\\r\\n #take a triplet of values from the list\\r\\n\\r\\n if op == operation:\\r\\n # if an operator is found, reduced the triplet, and\\r\\n # then add the reduced value, together with the rest\\r\\n # of the list to the \\r\\n if operation == '*':\\r\\n c = a*b\\r\\n elif operation == '+':\\r\\n if isinstance(a,str) and isinstance(b,str):\\r\\n c = a[0:-1]+b[1:]\\r\\n else:\\r\\n c = a+b\\r\\n elif operation == '/':\\r\\n c = a/b\\r\\n elif operation == '^':\\r\\n c = a**b\\r\\n elif operation == '%':\\r\\n c = a % b\\r\\n elif operation == '-':\\r\\n c = a - b\\r\\n newlist.append(c)\\r\\n newlist += phrase[counter+3:] \\r\\n stop = True\\r\\n else:\\r\\n newlist.append(a)\\r\\n else:\\r\\n # otherwise, just add the text value to the new list\\r\\n newlist.append(phrase[counter])\\r\\n counter +=1 \\r\\n \\r\\n \\r\\n phrase = newlist\\r\\n\\r\\n \\r\\n else:\\r\\n # if the list is not yet simple, return a new list after parsing each element.\\r\\n phrase = [parse(x) for x in phrase]\\r\\n return parse(phrase)\\r\\n\\r\\n if isinstance(phrase,(int,float,type(ListType()),bool)):\\r\\n # if a numerical value, stop the recursion\\r\\n \\r\\n return phrase \\r\\n\\r\\n return parse(phrase)\",\n \"def visit_Compound(self, node):\\n for child in node.children:\\n self.visit(child)\",\n \"def get_nested_sum():\\n l_int = [1,2,[], 3,[4,[], 5,[6]],[7],[8,9], 10,[[],11]]\\n print 'Sum:', nested_sum(l_int) \\n return\",\n \"def _calc_C(self, lambdify=True):\\n\\n C = None\\n C_func = None\\n # check to see if we have our term saved in file\\n C, C_func = self._load_from_file('C', lambdify)\\n\\n if C is None and C_func is None:\\n # if no saved file was loaded, generate function\\n print('Generating centrifugal and Coriolis compensation function')\\n\\n # first get the inertia matrix\\n M = self._calc_M(lambdify=False)\\n\\n # C_{kj} = sum_i c_{ijk}(q) \\\\dot{q}_i\\n # c_{ijk} = 1/2 * sum_i (\\\\frac{\\\\partial M_{kj}}{\\\\partial q_j} +\\n # \\\\frac{\\\\partial M_{ki}}{\\\\partial q_j} - \\\\frac{\\\\partial M_{ij}}\\n # {\\\\partial q_k})\\n C = sp.zeros(self.N_JOINTS, self.N_JOINTS)\\n for kk in range(self.N_JOINTS):\\n for jj in range(self.N_JOINTS):\\n for ii in range(self.N_JOINTS):\\n dMkjdqi = M[kk, jj].diff(self.q[ii])\\n dMkidqj = M[kk, ii].diff(self.q[jj])\\n dMijdqk = M[ii, jj].diff(self.q[kk])\\n C[kk, jj] += .5 * (dMkjdqi + dMkidqj - dMijdqk) * self.dq[ii]\\n C[kk, jj] = C[kk, jj]\\n C = sp.Matrix(C)\\n\\n # save to file\\n abr_control.utils.os_utils.makedirs(\\n '%s/C' % self.config_folder)\\n cloudpickle.dump(C, open(\\n '%s/C/C' % self.config_folder, 'wb'))\\n\\n if lambdify is False:\\n # if should return expression not function\\n return C\\n\\n if C_func is None:\\n C_func = self._generate_and_save_function(\\n filename='C', expression=C,\\n parameters=self.q+self.dq)\\n return C_func\",\n \"def complexity(text:str) -> float:\\n words = text.split(' ')\\n freqs = [frequency(w) for w in words]\\n return sum(freqs) / (len(frequency_list) - freqs.count(0)) #sum of the frequencies / all the words that were in the list\",\n \"def get_circuit_size(self, circuit: ACircuit, recursive: bool = False) -> Tuple[int, int]:\",\n \"def combine_expression(self, connector, sub_expressions):\\n lhs, rhs = sub_expressions\\n if connector == '%%':\\n return 'MOD(%s)' % ','.join(sub_expressions)\\n elif connector == '&':\\n return 'BAND(%s)' % ','.join(sub_expressions)\\n elif connector == '|':\\n return 'BOR(%s)' % ','.join(sub_expressions)\\n elif connector == '^':\\n return 'POWER(%s)' % ','.join(sub_expressions)\\n elif connector == '<<':\\n return '(%(lhs)s * POWER(2, %(rhs)s))' % {'lhs': lhs, 'rhs': rhs}\\n elif connector == '>>':\\n return 'FLOOR(%(lhs)s / POWER(2, %(rhs)s))' % {'lhs': lhs, 'rhs': rhs}\\n return super().combine_expression(connector, sub_expressions)\",\n \"def custom_quadratic(n_particles, coefficients, is_bosonic):\\n if is_bosonic:\\n op = bosonic_op if n_particles == 2 else bosonic_op_3\\n else:\\n op = fermionic_op if n_particles == 2 else fermionic_op_3\\n\\n if n_particles == 2:\\n (J_11, J_22), (J_12,) = coefficients\\n return J_11 * op[\\\"a1^dag a1\\\"] + J_12 * (op[\\\"a1^dag a2\\\"] + op[\\\"a2^dag a1\\\"]) + J_22 * op[\\\"a2^dag a2\\\"]\\n\\n elif n_particles == 3:\\n (J_11, J_22, J_33), (J_12, J_13, J_23) = coefficients\\n return (\\n J_11 * op[\\\"a1^dag a1\\\"]\\n + J_12 * (op[\\\"a1^dag a2\\\"] + op[\\\"a2^dag a1\\\"])\\n + J_13 * (op[\\\"a1^dag a3\\\"] + op[\\\"a3^dag a1\\\"])\\n + J_22 * op[\\\"a2^dag a2\\\"]\\n + J_23 * (op[\\\"a2^dag a3\\\"] + op[\\\"a3^dag a2\\\"])\\n + J_33 * op[\\\"a3^dag a3\\\"]\\n )\",\n \"def _nt_sum(cobj, prop, theta):\\n # Build sum term\\n i = 1\\n s = 0\\n while True:\\n try:\\n ni = getattr(cobj, f\\\"{prop}_coeff_n{i}\\\")\\n ti = getattr(cobj, f\\\"{prop}_coeff_t{i}\\\")\\n s += ni * theta**ti\\n i += 1\\n except AttributeError:\\n break\\n return s\",\n \"def dfs(self, nums, cur_sum, S):\\n ways = 0\\n nums_length = len(nums)\\n if nums_length == 0:\\n if cur_sum == S:\\n return 1\\n return 0\\n\\n multiple = [1, -1]\\n for value in multiple:\\n new_num = nums[nums_length - 1]\\n new_nums = nums[0:nums_length - 1]\\n new_sum = cur_sum + new_num * value\\n ways = ways + self.dfs(new_nums, new_sum, S)\\n\\n return ways\",\n \"def associativity(ob):\\n return 0\",\n \"def conjugation(conj_id, present_base, perfect_base, present_ending, participle_base, infinitive):\\n\\t\\n\\t#TODO: Rewrite the following with attribute calls:\\n \\n tense = {}\\n #Tenses, aspects and moods in Latin:\\n tense[\\\"ind_a_pr\\\"] = conj_ind_a_pr(conj_id, present_base)\\n tense[\\\"ind_a_im\\\"] = conj_ind_a_im(conj_id, present_base)\\n tense[\\\"ind_a_fu\\\"] = conj_ind_a_fu(conj_id, present_base)\\n tense[\\\"ind_a_pe\\\"] = conj_ind_a_pe(conj_id, perfect_base)\\n tense[\\\"ind_a_pl\\\"] = conj_ind_a_pl(conj_id, perfect_base)\\n tense[\\\"ind_a_fp\\\"] = conj_ind_a_fp(conj_id, perfect_base)\\n tense[\\\"imp_a_pr\\\"] = conj_imp_a_pr(conj_id, present_base)\\n tense[\\\"imp_p_pr\\\"] = conj_imp_p_pr(conj_id, infinitive, present_base) # c\\n tense[\\\"imp_p_fu\\\"] = conj_imp_p_fu(conj_id, present_base)\\n tense[\\\"imp_a_fu\\\"] = conj_imp_a_fu(conj_id, present_base)\\n tense[\\\"ind_p_pr\\\"] = conj_ind_p_pr(conj_id, present_base, present_ending)\\n tense[\\\"ind_p_im\\\"] = conj_ind_p_im(conj_id, present_base)\\n tense[\\\"ind_p_fu\\\"] = conj_ind_p_fu(conj_id, present_base, present_ending)\\n tense[\\\"sub_a_pr\\\"] = conj_sub_a_pr(conj_id, present_base)\\n tense[\\\"sub_p_pr\\\"] = conj_sub_p_pr(conj_id, present_base)\\n tense[\\\"sub_a_im\\\"] = conj_sub_a_im(infinitive)\\n tense[\\\"sub_p_im\\\"] = conj_sub_p_im(infinitive)\\n tense[\\\"sub_a_pe\\\"] = conj_sub_a_pe(perfect_base)\\n tense[\\\"sub_a_pl\\\"] = conj_sub_a_pl(perfect_base)\\n \\n #TODO: Put the above in dictionary as objects?\\n #\\n tense[\\\"ind_p_pe\\\"] = (Esse.ipra, participle_parpp(participle_base))\\n tense[\\\"ind_p_pl\\\"] = (Esse.iima, participle_parpp(participle_base))\\n tense[\\\"sub_p_pe\\\"] = (Esse.sub_pr, participle_parpp(participle_base))\\n tense[\\\"sub_p_pl\\\"] = (Esse.sub_im, participle_parpp(participle_base))\\n tense[\\\"ind_p_fp\\\"] = (Esse.ind_fu, participle_parpp(participle_base))\\n \\n return tense\",\n \"def __init__(self, children):\\n super().__init__('complex', children, None)\\n self.real = children[0].real\\n self.imag = children[1].imag\\n self.complex = self.real + self.imag*1j\",\n \"def _cmplx_div_ ( s , o ) :\\n return ( 1.0 / o ) * complex ( s )\",\n \"def encode_compound(db, tree):\\n length = 0\\n data = 0\\n sf = 0\\n subfields = []\\n for cn in tree.childNodes:\\n l = 0\\n if cn.nodeName == 'Variable':\\n l, v = encode_variable(db, cn)\\n else:\\n if cn.nodeName == 'Fixed':\\n l, v = encode_fixed(db, cn)\\n else:\\n if cn.nodeName == 'Repetitive':\\n l, v = encode_repetitive(db, cn)\\n else:\\n if cn.nodeName == 'Variable':\\n l, v = encode_variable(db, cn)\\n else:\\n if cn.nodeName == 'Compound':\\n l, v = encode_compound(db, cn)\\n\\n if l > 0:\\n subfields.append(sf)\\n length += l\\n data <<= (8 * l)\\n data += v\\n\\n sf += 1\\n\\n n_octets = max(subfields) / 7 + 1\\n primary_subfield = 0\\n for i in sorted(subfields): # subfields\\n primary_subfield += (1 << (8 * (i / 7) + (8 - (i % 7))))\\n for i in range(n_octets - 1): # FX\\n primary_subfield += (1 << 8 * (i + 1))\\n\\n data += (primary_subfield << (8 * length))\\n\\n return length + n_octets, data\",\n \"def get_covered_terms(self):\\n base = 0\\n x_index = [index for index, item in enumerate(self.bin_str[::-1]) if item == '-']\\n\\n for index, item in enumerate(self.bin_str[::-1]):\\n if item == '1':\\n base += 2 ** index\\n\\n yield base\\n\\n for i in range(len(x_index)):\\n for items in itertools.combinations(x_index, i + 1):\\n accumulator = 0\\n for index in items:\\n accumulator += 2 ** index\\n yield base + accumulator\",\n \"def Cprimebound(relatorlist,Lambda=1):\\n F,rels=fg.parseinputwords(relatorlist)\\n if not all(r==F.cyclic_reduce(r) for r in rels):\\n raise ValueError(\\\"Relators are not cyclically reduced.\\\")\\n biggestratio=Fraction(1,min(len(r) for r in rels))\\n if biggestratio>=Fraction(1,Lambda):\\n return 1\\n rels.sort(key=len) # sort list of relators with shortest first\\n irels=[rel for rel in itertools.chain.from_iterable(zip([w() for w in rels],[(w**(-1))() for w in rels]))] # arrange relators and inverses in a list of the form relator1, inverse of relator1, relator2, inverse of relator2,...\\n drels=[x+x for x in irels] # double the relators to look for pieces that would have wrapped\\n for relatorindex in range(len(rels)):\\n relator=irels[2*relatorindex]\\n foundbiggest=False\\n for L in range(len(relator),int(biggestratio*len(relator)),-1):# only check subwords of length L that would give biggest ratio if they were a piece\\n for startingindex in range(len(relator)):\\n p=(relator+relator)[startingindex:startingindex+L] # the subword of length L starting at index i in relator as a cyclic word\\n # now we need to check if p is a piece\\n # we do not need to check lower relatorindices, because we already scanned those relators for pieces\\n if any(p in x for x in [(relator+relator)[startingindex+1:len(relator)+startingindex+L-1]]+[drels[i] for i in range(2*relatorindex+1,len(drels))]):# look in this (doubled) relator at higher starting indices, and in all later relators, for other copies of p. If found a matching subword, p is a piece.\\n biggestratio=Fraction(len(p),len(relator))\\n foundbiggest=True # we search pieces by decreasing length, so first one we find is longest\\n if biggestratio>=Fraction(1,Lambda):\\n return 1\\n break\\n if foundbiggest: # if we found the biggest piece in this relator we can move on to the next relator. \\n break\\n return biggestratio\",\n \"def _compile(self, expression):\\n t = re.split(r'\\\\s+(\\\\+|-)\\\\s+', expression)\\n ocomps = t[::2] # output component sub-expressions\\n signs = [1.] # implied + in front of expression\\n signs.extend(1. if s == '+' else -1 for s in t[1::2]) \\n factors = [(1., 1) for i in ocomps]\\n for i, s in enumerate(ocomps):\\n tt = re.split(r'\\\\s+(\\\\*|/)\\\\s+', s) # split on */ operator\\n lval = self._lval(tt[0])\\n if len(tt) > 1:\\n factors[i] = self._rval(tt[2]), 1 if tt[1] == '*' else -1\\n if not isinstance(lval, Output): \\n if len(ocomps) == 1: # simple basic output (special case)\\n self.is_basic = True\\n self._factor = factors[0]\\n self._compile_basic(lval)\\n return\\n else: # compound basic output\\n ocomps[i] = Output(parent=self.parent,\\n expression=lval,\\n factor=factors[i],\\n is_basic=True)\\n else: # summary output\\n ocomps[i] = lval #self.parent.outputs[lval]\\n self._ocomps = ocomps\\n self._signs = signs\\n self._factors = factors\",\n \"def Mol_SO(Nat, multip, charge, sym, SO_3rdrow_mols_val): # number of atoms, multiplicity, charge, array of atoms in molecule, value of SO_3rdrow_mols (from orca.inp file)\\n\\n Mol_SO = 0\\n \\n # Special Case - Acetleyne - S\\n if Nat == 4 and multip == 2 and charge == 1:\\n countH_temp =0\\n countC_temp =0\\n for tmp in range(len(sym)):\\n if sym[tmp] == \\\"H\\\":\\n countH_temp= countH_temp +1\\n if sym[tmp] == \\\"C\\\":\\n countC_temp = countC_temp +1\\n if countH_temp == 2 and countC_temp == 2:\\n Mol_SO = -0.07 #-0.07d0\\n \\n with open(\\\"Thermochemistry.out\\\", \\\"a\\\") as ther_chem:\\n ther_chem.write(\\\"DETECTED A C2H2+ SYSTEM: Using SO parameters for acetylene cation\\\\n\\\")\\n ther_chem.write(\\\"Ref: JCP 114, 9287, 2001\\\\n\\\\n\\\")\\n # Special Case - Acetleyne - E\\n \\n # For diatomics with multip = 2\\n if Nat == 2 and multip == 2 :\\n sort_sym = sorted(sym, reverse=True)\\n if SO_3rdrow_mols_val == \\\"true\\\": # for 3rd_row elements\\n \\n if charge == 0:\\n if sort_sym[0] == 'O' and sort_sym[1] == 'Br': Mol_SO=-2.20\\n \\n # COMMMENT: paper has it for cation, but it looks like it is for neutral\\n if sort_sym[0] == 'Se' and sort_sym[1] == 'H': Mol_SO=-4.21\\n \\n if charge == +1: ### RECHECK what the values of charge is!!!!!!!!!!!!!!!!!!!!!IMPORTANT\\n if sort_sym[0] == 'K' and sort_sym[1] == 'Br': Mol_SO=-2.99\\n if sort_sym[0] == 'H' and sort_sym[1] == 'As': Mol_SO=-3.54\\n if sort_sym[0] == 'H' and sort_sym[1] == 'Br': Mol_SO=-6.26\\n if sort_sym[0] == 'F' and sort_sym[1] == 'Br': Mol_SO=-6.10\\n if sort_sym[0] == 'Na' and sort_sym[1] == 'Br': Mol_SO=-3.93\\n if sort_sym[0] == 'Br' and sort_sym[1] == 'Br': Mol_SO=-6.55\\n \\n else: # for non 3rd row elements, first and second rows\\n if charge == 0:\\n if sort_sym[0] == 'H' and sort_sym[1] == 'C': Mol_SO=-0.07\\n if sort_sym[0] == 'O' and sort_sym[1] == 'H': Mol_SO=-0.30\\n if sort_sym[0] == 'O' and sort_sym[1] == 'N': Mol_SO=-0.27\\n if sort_sym[0] == 'O' and sort_sym[1] == 'Cl': Mol_SO=-0.61\\n if sort_sym[0] == 'S' and sort_sym[1] == 'H': Mol_SO=-1.01\\n if sort_sym[0] == 'P' and sort_sym[1] == 'O': Mol_SO=-0.53\\n if sort_sym[0] == 'Si' and sort_sym[1] == 'H': Mol_SO=-0.34\\n \\n if charge == -1:\\n if sort_sym[0] == 'N' and sort_sym[1] == 'H': Mol_SO=-0.12\\n if sort_sym[0] == 'P' and sort_sym[1] == 'H': Mol_SO=-0.45\\n if sort_sym[0] == 'O' and sort_sym[1] == 'O': Mol_SO=-0.34\\n if sort_sym[0] == 'S' and sort_sym[1] == 'S': Mol_SO=-1.12\\n \\n if charge == +1:\\n if sort_sym[0] == 'H' and sort_sym[1] == 'F': Mol_SO=-0.62\\n if sort_sym[0] == 'P' and sort_sym[1] == 'H': Mol_SO=-0.67\\n if sort_sym[0] == 'H' and sort_sym[1] == 'Cl': Mol_SO=-1.60\\n if sort_sym[0] == 'N' and sort_sym[1] == 'N': Mol_SO=-0.17\\n if sort_sym[0] == 'O' and sort_sym[1] == 'O': Mol_SO=-0.43\\n if sort_sym[0] == 'P' and sort_sym[1] == 'P': Mol_SO=-0.57\\n if sort_sym[0] == 'S' and sort_sym[1] == 'S': Mol_SO=-1.25\\n if sort_sym[0] == 'Cl' and sort_sym[1] == 'Cl': Mol_SO=-1.77\\n if sort_sym[0] == 'F' and sort_sym[1] == 'Cl': Mol_SO=-1.60\\n \\n return(Mol_SO)\",\n \"def visit_Compound(self, node):\\n for statement in node.statements:\\n self.visit(statement)\",\n \"def length(cont):\\r\\n\\r\\n mySum = 0\\r\\n\\r\\n if cont == \\\"\\\":\\r\\n return 0\\r\\n else:\\r\\n mySum += 1 + length(cont[1:])\\r\\n return mySum\",\n \"def calculate(self) -> complex128:\\n\\n if not self.__can_calculation_be_performed():\\n raise AttributeError\\n\\n v_vectors = self.__calculate_v_vectors()\\n\\n permanent = 0\\n for v_vector in v_vectors:\\n v_sum = sum(v_vector)\\n addend = pow(-1, v_sum)\\n # Binomials calculation\\n for i in range(len(v_vector)):\\n addend *= binom(self.__input_state[i], v_vector[i])\\n\\n # Product calculation\\n product = 1\\n for j in range(len(self.__input_state)):\\n if self.__output_state[j] == 0: # There's no reason to calculate the sum if t_j = 0\\n continue\\n # Otherwise we calculate the sum\\n product_part = 0\\n for i in range(len(self.__input_state)):\\n product_part += (self.__input_state[i] - 2 * v_vector[i]) * self.__matrix[j][i]\\n product_part = pow(product_part, self.__output_state[j])\\n product *= product_part\\n addend *= product\\n permanent += addend\\n\\n permanent /= pow(2, sum(self.__input_state))\\n\\n return permanent\",\n \"def get_number_operators(self) -> int:\\n if self.sons:\\n return 1 + sum([son.get_number_operators() for son in self.sons])\\n return 0\",\n \"def get_complexes(self):\\n q_cmplx = prefixes + \\\"\\\"\\\"\\n SELECT ?complexTerm ?childName ?child ?stmt\\n WHERE {\\n {\\n {?stmt belvoc:hasSubject ?complexTerm}\\n UNION\\n {?stmt belvoc:hasObject ?complexTerm .}\\n UNION\\n {?stmt belvoc:hasSubject ?term .\\n ?term belvoc:hasChild ?complexTerm .}\\n UNION\\n {?stmt belvoc:hasObject ?term .\\n ?term belvoc:hasChild ?complexTerm .}\\n }\\n ?complexTerm a belvoc:Term .\\n ?complexTerm a belvoc:ComplexAbundance .\\n ?complexTerm belvoc:hasChild ?child .\\n ?child belvoc:hasConcept ?childName .\\n }\\n \\\"\\\"\\\"\\n # Run the query\\n res_cmplx = self.g.query(q_cmplx)\\n\\n # Store the members of each complex in a dict of lists, keyed by the\\n # term for the complex\\n cmplx_dict = collections.defaultdict(list)\\n cmplx_ev = {}\\n for stmt in res_cmplx:\\n stmt_uri = stmt[3]\\n ev = self._get_evidence(stmt_uri)\\n for e in ev:\\n e.epistemics['direct'] = True\\n cmplx_name = term_from_uri(stmt[0])\\n cmplx_id = stmt_uri + '#' + cmplx_name\\n child = self._get_agent(stmt[1], stmt[2])\\n cmplx_dict[cmplx_id].append(child)\\n # This might be written multiple times but with the same\\n # evidence\\n cmplx_ev[cmplx_id] = ev\\n # Now iterate over the stored complex information and create binding\\n # statements\\n for cmplx_id, cmplx_list in cmplx_dict.items():\\n if len(cmplx_list) < 2:\\n msg = 'Complex %s has less than 2 members! Skipping.' % \\\\\\n cmplx_name\\n logger.warning(msg)\\n else:\\n self.statements.append(Complex(cmplx_list,\\n evidence=cmplx_ev[cmplx_id]))\",\n \"def collect_nested(expr, aggressive=False):\\n\\n def run(expr):\\n # Return semantic (rebuilt expression, factorization candidates)\\n\\n if expr.is_Number or expr.is_Symbol:\\n return expr, [expr]\\n elif expr.is_Indexed or expr.is_Atom:\\n return expr, []\\n elif expr.is_Add:\\n rebuilt, candidates = zip(*[run(arg) for arg in expr.args])\\n\\n w_numbers = [i for i in rebuilt if any(j.is_Number for j in i.args)]\\n wo_numbers = [i for i in rebuilt if i not in w_numbers]\\n\\n w_numbers = collect_const(expr.func(*w_numbers))\\n wo_numbers = expr.func(*wo_numbers)\\n\\n if aggressive is True and wo_numbers:\\n for i in flatten(candidates):\\n wo_numbers = collect(wo_numbers, i)\\n\\n rebuilt = expr.func(w_numbers, wo_numbers)\\n return rebuilt, []\\n elif expr.is_Mul:\\n rebuilt, candidates = zip(*[run(arg) for arg in expr.args])\\n rebuilt = collect_const(expr.func(*rebuilt))\\n return rebuilt, flatten(candidates)\\n elif expr.is_Equality:\\n rebuilt, candidates = zip(*[run(expr.lhs), run(expr.rhs)])\\n return expr.func(*rebuilt, evaluate=False), flatten(candidates)\\n else:\\n rebuilt, candidates = zip(*[run(arg) for arg in expr.args])\\n return expr.func(*rebuilt), flatten(candidates)\\n\\n return run(expr)[0]\",\n \"def process():\\r\\n\\t### INPUT ####\\r\\n\\tpq = eat(str)\\r\\n\\tp, q = map(int, pq.split('/'))\\r\\n\\t\\r\\n\\t### COMPUT ####\\r\\n\\td = gcd(p, q)\\r\\n\\tp, q = p//d, q//d\\r\\n\\teprint(bin(q), bin(p))\\r\\n\\tif len(bin(q).strip('0')) != 2:\\r\\n\\t\\treturn IMPOSSIBLE\\r\\n\\t#length of p\\r\\n\\tbinp = bin(p)\\r\\n\\tbinq = bin(q)\\r\\n\\treturn len(binq) - len(binp)\\r\\n\\t\\r\\n\\t### OUTPUT ####\\r\\n\\treturn solve()\",\n \"def convex_conj(self):\\n convex_conjs = [func.convex_conj for func in self.functionals]\\n return SeparableSum(*convex_conjs)\",\n \"def __add__(self, other):\\n self.sum_complex_num = Complex((self.real + other.real), (self.imaginary + other.imaginary))\\n return self.sum_complex_num\",\n \"def radical_c2(self, atoms):\\n\\n c1, c2 = atoms.keys()\\n c1_ndx, c2_ndx = atoms.values()\\n\\n chain1, chain2 = self.determine_chains([c1, c2])\\n\\n # to get indexing right\\n c1_ndx -= self.monomer.indices[chain1]['C1']\\n c2_ndx -= self.monomer.indices[chain2]['C2']\\n\\n # types after reaction\\n types = {'chain1': {'C1': 'c3', 'C2': 'c2', 'C3': 'c2', 'C4': 'c2', 'H1': 'hc', 'H2': 'hc', 'H3': 'ha',\\n 'H4': 'ha', 'H5': 'ha'}, # chain1 contains c1\\n 'chain2': {'C1': 'c3', 'C2': 'c3', 'C3': 'c2', 'C4': 'c2', 'H1': 'hc', 'H2': 'hc', 'H3': 'hc',\\n 'H4': 'ha', 'H5': 'ha'}} # chain2 contains c2 radical\\n\\n # update types\\n reacted_types = {'chain1': {c1_ndx + self.monomer.indices[chain1][a]: types['chain1'][a]\\n for a in types['chain1'].keys()},\\n 'chain2': {c2_ndx + self.monomer.indices[chain2][a]: types['chain2'][a]\\n for a in types['chain2'].keys()}}\\n\\n # new bonds\\n bonds = [[c1_ndx + self.monomer.indices[chain1]['C1'], c2_ndx + self.monomer.indices[chain2]['C2'], 'carbon']]\\n\\n # no dummy bonds to add\\n\\n # define indices of left-over radicals\\n radicals = [c1_ndx + self.monomer.indices[chain1]['C2']]\\n\\n chain1_impropers = ['C1'] # [1]\\n chain2_impropers = ['C2'] # [2]\\n rm_improper = []\\n for c in chain1_impropers:\\n rm_improper.append([c1_ndx + self.monomer.indices[chain1][x] for x in self.monomer.impropers[chain1][c]])\\n for c in chain2_impropers:\\n rm_improper.append([c2_ndx + self.monomer.indices[chain2][x] for x in self.monomer.impropers[chain2][c]])\\n\\n # define terminated atoms\\n terminated = [c1_ndx + self.monomer.indices[chain1]['C1'], c2_ndx + self.monomer.indices[chain2]['C2']]\\n\\n return reacted_types, bonds, radicals, rm_improper, terminated\",\n \"def test_complexity():\\n file_paths = glob.iglob('*/*.py')\\n for file_path in file_paths:\\n with open(file_path, 'r') as file_obj:\\n blocks = radon.cc_visit(file_obj.read())\\n for block in blocks:\\n fail_msg = '{} ({}) has a cyclomatic complexity of {}'.format(\\n block.name, file_path, block.complexity)\\n yield case.assertLessEqual, block.complexity, 10, fail_msg\",\n \"def RyserFormula(num_coincidence: int, U_st: numpy.ndarray) -> complex:\\n\\n value_perm = 0\\n set = CreateSubset(num_coincidence)\\n\\n for subset in set:\\n num_elements = len(subset)\\n value_times = 1\\n for i in range(num_coincidence):\\n value_sum = 0\\n for j in subset:\\n value_sum += U_st[i, j]\\n value_times *= value_sum\\n value_perm += value_times * (-1) ** num_elements\\n value_perm *= (-1) ** num_coincidence\\n return value_perm\",\n \"def qed_cc( s, m, r):\\n\\n l1_t2 = s + m\\n l2 = r + s\\n\\n if l1_t2 % 2 != 0:\\n return 0\\n\\n denom = factorial(s) * factorial(m) * factorial(r)**2\\n nom = double_factorial( l1_t2 - 1 ) * factorial( l2 )\\n\\n return Fraction( nom, denom )\",\n \"def simplify (self):\\n if (self.debug): print(f'enter fraction.simplify')\\n hcf = find_hcf(self.value[0], self.value[1])\\n self.value = (self.value[0] // hcf.product(), self.value[1] // hcf.product())\\n return\",\n \"def solve_equation_addition_precendence(eq, verbose=False):\\n tokens = tokenize(eq)\\n if verbose:\\n print(f\\\"eq: {tokens}\\\")\\n\\n stack = []\\n ops = {\\n None: do_push,\\n \\\"(\\\": do_push,\\n \\\")\\\": do_parenthesis,\\n \\\"+\\\": do_addition,\\n \\\"*\\\": do_push,\\n }\\n\\n for t in tokens:\\n if isinstance(t, int):\\n op = stack[-1] if len(stack) else None\\n ops[op](stack, t)\\n elif t == \\\"+\\\" or t == \\\"*\\\" or t == \\\"(\\\":\\n stack.append(t)\\n elif t == \\\")\\\":\\n ops[\\\")\\\"](stack, t)\\n # solve preparenthesis addition\\n if len(stack) > 2:\\n v = stack.pop()\\n assert isinstance(v, int)\\n ops[stack[-1]](stack, v)\\n else:\\n assert False, f\\\"fail token: {t}\\\"\\n\\n if verbose:\\n print(f\\\"stack: {stack}\\\")\\n\\n # solve multiplications\\n while len(stack) > 1:\\n rhs = stack.pop()\\n assert isinstance(rhs, int)\\n op = stack.pop()\\n if op == \\\"*\\\":\\n lhs = stack.pop()\\n assert isinstance(lhs, int)\\n stack.append(lhs * rhs)\\n else:\\n assert False, f\\\"invalid operator (not *): {op}\\\"\\n\\n assert len(stack) == 1\\n return stack[0]\",\n \"def sum_proper_divisors(n):\\r\\n return sum(proper_divisors(n))\",\n \"def tree_string(self):\\n if self.body is None:\\n return 0\\n if self.left is None and self.right is None:\\n return self.body\\n left_sum = self.left.tree_string()\\n right_sum = self.right.tree_string()\\n if self.body == add:\\n return str(left_sum) + '+' + str(right_sum)\\n elif self.body == sub:\\n return str(left_sum) + '-' + str(right_sum)\\n elif self.body == mul:\\n return str(left_sum) + '*' + str(right_sum)\\n else:\\n return str(left_sum) + '/' + str(right_sum)\",\n \"def n_complex_components(self):\\n return self.n_components // 2 + (self.n_components % 2)\",\n \"def score( canvas ):\\n\\n score = 0\\n\\n score += length_score(canvas)\\n score += angle_score(canvas)\\n\\n # 1. Chainbreaks for all junction loops.\\n\\n # 2. Nucleotides should be at least 15 from ALL other nts. Don't double-count.\\n for seqpos1, nt1 in canvas.nucleotides.iteritems():\\n for seqpos2, nt2 in canvas.nucleotides.iteritems():\\n if seqpos1 >= seqpos2: continue\\n #if distance( nt1, nt2 ) < 15: score += 100\\n # Don't do a square root you don't have to\\n if distance_squared( nt1, nt2 ) < 225: score += 100\\n\\n\\n # 2b. Depending on base pair width, it's possible that the 'best' orientation for two stacks is\\n # for them to be overlapping...\\n # nt --- nt\\n # | nt |-- nt\\n # nt -|- nt |\\n # | nt |-- nt\\n # so, penalize this ( 'between two bp'ed nts' penalized like hitting a nt )\\n for seqpos, nt in canvas.nucleotides.iteritems():\\n for stem in canvas.stems:\\n for bp in stem.base_pairs:\\n if nt == bp.nt1 or nt == bp.nt2:\\n continue\\n # if nt in question is 'in between' nt1 and nt2. how to judge?\\n if nt.x > bp.nt1.x and nt.x < bp.nt2.x \\\\\\n and closer_than( nt.y, bp.nt1.y, canvas.bp_offset_height*0.8 ):\\n score += 100\\n\\n # Look at pairs of adjacent nts in stem\\n for seqpos1, nt1 in stem.nucleotides.iteritems():\\n if seqpos1 + 1 in stem.nucleotides.keys():\\n nt2 = stem.nucleotides[ seqpos1 + 1 ]\\n if nt.y > nt1.y and nt.y < nt2.y \\\\\\n and closer_than( nt.x, nt1.x, canvas.bp_offset_width*0.8 ):\\n score += 100\\n\\n # 3. Stems should be straight and vertical.\\n ### Resolved via kinematics?\\n\\n # 4. Coaxial stacks, where known, should be colinear.\\n for idx1, idx2 in canvas.list_of_coaxialities:\\n # idx1 and idx2 are coaxial stems.\\n # Any two BPs from these stems should do, but -- because I have no idea\\n # how we intend to handle 'alternate-order' stacks (where the first nt in a bp\\n # is stacked on the second nt in another), compare either direction.\\n bp1 = canvas.stems[idx1].base_pairs[0]\\n bp2 = canvas.stems[idx2].base_pairs[0]\\n penalty1 = harmonic_penalty( bp1.nt1.x - bp2.nt1.x, 0, 1 ) + harmonic_penalty( bp1.nt2.x - bp2.nt2.x, 0, 1 )\\n penalty2 = harmonic_penalty( bp1.nt1.x - bp2.nt2.x, 0, 1 ) + harmonic_penalty( bp1.nt2.x - bp2.nt1.x, 0, 1 )\\n score += min( penalty1, penalty2 )\\n\\n\\n # 5. Apical loops should be symmetrical and near a circular path.\\n for loop in canvas.loops:\\n for seqpos in loop.nucleotides.keys():\\n pass\\n\\n return score\",\n \"def problem9_complex(n):\\n # Start with 1 to avoid triples with zero.\\n for u in range(1, n):\\n for v in range(u, n):\\n # When u == v one of the a, b becomes 0\\n if u != v:\\n\\n # The following two blocks do the same thing.\\n # First one uses complex numbers.\\n # Second one uses generalised formulas.\\n\\n # comp = complex(u, v) ** 2\\n # a = abs(comp.real)\\n # b = abs(comp.imag)\\n # c = sqrt(a ** 2 + b ** 2)\\n\\n a = abs(u ** 2 - v ** 2)\\n b = abs(2 * u * v)\\n c = abs(u ** 2 + v ** 2)\\n\\n if a + b + c == n:\\n return a * b * c\\n return None\",\n \"def length(formula):\\n if isinstance(formula, Atom):\\n return 1\\n if isinstance(formula, Not):\\n return length(formula.inner) + 1\\n if isinstance(formula, Implies) or isinstance(formula, And) or isinstance(formula, Or):\\n return length(formula.left) + length(formula.right) + 1\",\n \"def visit_term(self, node, children):\\n if self.debug:\\n print(\\\"Term {}\\\".format(children))\\n term = children[0]\\n for i in range(2, len(children), 2):\\n if children[i-1] == \\\"*\\\":\\n term *= children[i]\\n else:\\n term /= children[i]\\n if self.debug:\\n print(\\\"Term = {}\\\".format(term))\\n return term\",\n \"def check_rec(eqparams, tracecombo=(dict(), 0, set(range(10))), p=0):\\n # Basic parameters of the equation,\\n # maximal digit rank\\n # characters with multipliers by rank\\n # unique non-zero characters by rank\\n # unique zero-allowed characters by rank\\n # all unique characters by rank\\n maxp, tchars, unzchars, uokzchars, uchars = eqparams\\n # recursion cumulative parameters\\n # established characters with digits\\n # carry-over from the previous level\\n # remaining unassigned digits\\n prevdict, cover, remdigs = tracecombo\\n # the maximal 10-power (beyond the maximal rank)\\n # is reached\\n if p == maxp:\\n # Carry-over is zero, meaning solution is found\\n if cover == 0:\\n return prevdict\\n else:\\n # Otherwise the solution in this branch is not found\\n # return empty\\n return dict()\\n diglets = uchars[p] # all new unique letters from the current level\\n partsum = cover # Carry over from lower level\\n remexp = [] # TBD letters\\n # Break down the current level letter into what can be\\n # calculated in the partial sum and remaining TBD letter-digits\\n for c, v in tchars[p]:\\n if c in prevdict:\\n partsum += v * prevdict[c]\\n else:\\n remexp.append((c, v))\\n # Generate permutations for the remaining digits and currecnt level\\n # non-zero letters and zero-allowed letters\\n for newdigs in digPerms(remdigs, unzchars[p], uokzchars[p]):\\n # build the dictionary for the new letters and this level\\n newdict = dict(zip(diglets, newdigs))\\n # complete the partial sum into test sum using the current permutation\\n testsum = partsum + sum([newdict[c] * v\\n for c, v in remexp])\\n # check if the sum is divisible by 10\\n d, r = divmod(testsum, 10)\\n if r == 0:\\n # if divisible, update the dictionary to all established\\n newdict.update(prevdict)\\n # proceed to the next level of recursion with\\n # the same eqparams, but updated digit dictionary,\\n # new carry over and remaining digits to assign\\n rectest = check_rec(eqparams,\\n (newdict, d, remdigs - set(newdigs)),\\n p + 1)\\n # if the recursive call returned a non-empty dictionary\\n # this means the recursion has found a solution\\n # otherwise, proceed to the new permutation\\n if rectest and len(rectest) > 0:\\n return rectest\\n # if no permutations are avaialble or no\\n # permutation gave the result return None\\n return None\",\n \"def test_ccsd_doubles_a_terms(parthole_drudge):\\n\\n dr = parthole_drudge\\n p = dr.names\\n\\n a, b, c, d = p.V_dumms[:4]\\n i, j, k, l = p.O_dumms[:4]\\n u = dr.two_body\\n t = IndexedBase('t')\\n dr.set_dbbar_base(t, 2)\\n\\n tau = dr.define_einst(\\n IndexedBase('tau')[a, b, i, j],\\n Rational(1, 2) * t[a, b, i, j] + t[a, i] * t[b, j]\\n )\\n\\n a_i = dr.define_einst(\\n IndexedBase('ai')[k, l, i, j], u[i, c, k, l] * t[c, j]\\n )\\n\\n a_ = dr.define(\\n IndexedBase('a')[k, l, i, j],\\n u[k, l, i, j] +\\n a_i[k, l, i, j] - a_i[k, l, j, i]\\n + u[k, l, c, d] * tau[c, d, i, j]\\n )\\n\\n tensor = dr.define_einst(\\n IndexedBase('r')[a, b, i, j],\\n a_[k, l, i, j] * tau[a, b, k, l]\\n )\\n targets = [tensor]\\n\\n eval_seq = optimize(\\n targets, substs={p.nv: p.no * 10}, strategy=Strategy.ALL | Strategy.SUM\\n )\\n assert verify_eval_seq(eval_seq, targets)\\n # Here we just assert that the final step is a simple product.\\n assert len(eval_seq[-1].rhs_terms) == 1\",\n \"def test_simple_cc():\\n hs_c = LocalSpace('c', dimension=3)\\n hs_q = LocalSpace('q1', basis=('g', 'e'))\\n Delta_1 = Symbol('Delta_1')\\n Omega_1 = Symbol('Omega_1')\\n g_1 = Symbol('g_1')\\n a = Destroy(hs=hs_c)\\n a_dag = Create(hs=hs_c)\\n sig_p = LocalSigma('e', 'g', hs=hs_q)\\n sig_m = LocalSigma('g', 'e', hs=hs_q)\\n coeff = (-I / 2) * (Omega_1 * g_1 / Delta_1)\\n jc_expr = coeff * (a * sig_p - a_dag * sig_m)\\n\\n simplified = rewrite_with_operator_pm_cc(jc_expr)\\n assert simplified == coeff * OperatorPlusMinusCC(a * sig_p, sign=-1)\\n assert (\\n srepr(simplified.term)\\n == \\\"OperatorPlusMinusCC(OperatorTimes(Destroy(hs=LocalSpace('c', \\\"\\n \\\"dimension=3)), LocalSigma('e', 'g', hs=LocalSpace('q1', \\\"\\n \\\"basis=('g', 'e')))), sign=-1)\\\"\\n )\\n expanded = simplified.doit()\\n assert expanded == jc_expr\",\n \"def normal(e, **kw_args):\\n\\n if not e:\\n return S.Zero\\n\\n opts = {\\n 'simplify_kronecker_deltas': False,\\n 'expand': True,\\n 'simplify_dummies': False,\\n 'keep_only_fully_contracted': False,\\n 'lam': 1\\n }\\n opts.update(kw_args)\\n\\n # break up any NO-objects, and evaluate commutators\\n e = e.doit(wicks=True)\\n\\n # make sure we have only one term to consider\\n e = e.expand()\\n if isinstance(e, Add):\\n return Add(*[ normal(term, **kw_args) for term in e.args])\\n\\n # For Mul-objects we can actually do something\\n if isinstance(e, Mul):\\n\\n # we don't want to mess around with commuting part of Mul\\n # so we factorize it out before starting recursion\\n c_part = []\\n string1 = []\\n for factor in e.args:\\n if factor.is_commutative:\\n c_part.append(factor)\\n else:\\n string1.append(factor)\\n n = len(string1)\\n\\n # catch trivial cases\\n if n == 0:\\n result = e\\n elif n == 1:\\n result = e\\n else: # non-trivial\\n if n > 2:\\n # recursive step\\n if isinstance(string1[0], CreateBoson) \\\\\\n or (string1[0].is_Pow and \\\\\\n isinstance(string1[0].args[0], CreateBoson)):\\n # if the first term is ad^m\\n result = string1[0] * normal(Mul(*string1[1:]), **kw_args)\\n else:\\n # if the first term is a^m,\\n # bring the first two terms to normal order first\\n result = normal(normal(Mul(*string1[:2]), **kw_args)*Mul(*string1[2:]), **kw_args)\\n else: # n = 2,\\n result = _normal(string1, opts['lam'])\\n result = Mul(*c_part)*result\\n\\n if opts['expand']:\\n result = result.expand()\\n # if opts['simplify_kronecker_deltas']:\\n # result = evaluate_deltas(result)\\n\\n return result\\n\\n # there was nothing to do\\n return e\",\n \"def connectors_calc(level):\\n global connectors\\n connectors = level*(level+1)/2\\n return connectors\",\n \"def degree_on_basis(self, b):\\n return sum(b)\",\n \"def C(relatorlist,quit_at=float('inf')):\\n F,rels=fg.parseinputwords(relatorlist)\\n if not all(r==F.cyclic_reduce(r) for r in rels):\\n raise ValueError(\\\"Relators are not cyclically reduced.\\\")\\n thepieces=pieces(rels)\\n minnumberpieces=quit_at\\n def min_string_piece_expression(whatsleft,thepieces,quit_at):\\n # recursively determine the minimal expression of the string whatsleft as a concatenation of elements of thepieces, or stop once it is determined that any such expression requires at least quit_at many pieces\\n # find a piece that agrees with a prefix of whatsleft and the recurse on the suffix\\n if not whatsleft:\\n return 0\\n minexp=quit_at\\n for p in thepieces:\\n if p!=whatsleft[:len(p)]:\\n continue\\n else:\\n minexp=min(minexp,1+min_string_piece_expression(whatsleft[len(p):],thepieces,minexp-1))\\n return minexp\\n def min_relator_piece_expression(relator,thepieces,quit_at):\\n # This is first step in recursive search. Here we want to find a piece p such that for relator r we can write p=xy and r=yzx, with y nontrivial. That is, in this step only we think of r as cyclic word and allow first piece that wraps.\\n r=relator()\\n minexp=quit_at\\n for p in thepieces:\\n if len(p)>len(r):\\n continue\\n possiblestartingindices=[] # for given p there may be different possible choices of y\\n for startingindex in range(len(r)-len(p)+1,len(r)+1):\\n if p==(r+r)[startingindex:startingindex+len(p)]:\\n possiblestartingindices.append(startingindex)\\n if not possiblestartingindices:\\n continue\\n for startingindex in possiblestartingindices:\\n # found a way to fit p into r spanning the beginning of r. This accounts for x and y part of r. Now recursively find shortest expression of z=whatsleft as a concatenation of pieces.\\n whatsleft=(r+r)[startingindex+len(p):startingindex+len(r)]\\n if not whatsleft:\\n return 1\\n else:\\n minexp=min(minexp,1+min_string_piece_expression(whatsleft,thepieces,minexp-1))\\n return minexp\\n for thisrelator in rels:\\n minnumberpieces=min(minnumberpieces,min_relator_piece_expression(thisrelator,thepieces,minnumberpieces))\\n return minnumberpieces\",\n \"def CalcSingleCompoundDescriptor(compos, argVect, atomDict, propDict):\\n try:\\n atomVarNames = argVect[0]\\n compositionVarNames = argVect[1]\\n formula = argVect[2]\\n formula = _SubForCompoundDescriptors(formula, compositionVarNames, 'propDict')\\n formula = _SubForAtomicVars(formula, atomVarNames, 'atomDict')\\n evalTarget = _SubMethodArgs(formula, knownMethods)\\n except Exception:\\n if __DEBUG:\\n import traceback\\n print('Sub Failure!')\\n traceback.print_exc()\\n print(evalTarget)\\n print(propDict)\\n raise RuntimeError('Failure 1')\\n else:\\n return -666\\n\\n try:\\n v = eval(evalTarget)\\n except Exception:\\n if __DEBUG:\\n import traceback\\n outF = open(RDConfig.RDCodeDir + '/ml/descriptors/log.txt', 'a+')\\n outF.write('#------------------------------\\\\n')\\n outF.write('formula: %s\\\\n' % repr(formula))\\n outF.write('target: %s\\\\n' % repr(evalTarget))\\n outF.write('propDict: %s\\\\n' % (repr(propDict)))\\n\\n outF.write('keys: %s\\\\n' % (repr(sorted(atomDict))))\\n outF.close()\\n print('ick!')\\n print('formula:', formula)\\n print('target:', evalTarget)\\n print('propDict:', propDict)\\n print('keys:', atomDict.keys())\\n traceback.print_exc()\\n raise RuntimeError('Failure 2')\\n else:\\n v = -666\\n return v\",\n \"def all_change(cur: Currency, r: float, max_permutation=1000, only_cents=True) -> List[Union[int, List]]:\\n\\n # sub problem: combinations to return n < r with a set of coins s' subset of s\\n # base case: combinations to return 0 = 1: empty list\\n # characteristic equation: sum of combinations using that coin with combinations without using that coin.\\n\\n # introducing convenient notation working in cents\\n m = cur.num_denominations()\\n S = [_ for _ in cur.iter_denominations()] if only_cents else [_float2int(x) for x in cur.iter_denominations()]\\n n = _float2int(r) if not only_cents else r\\n\\n # Construct table\\n T = [[[0, []] for _ in range(m)] for _ in range(n + 1)]\\n\\n # Base case (value zero has just one solution: empty list)\\n for i in range(m):\\n T[0][i] = [1, [[0 for _ in range(m)]]]\\n\\n # Fill rest of the table entries\\n for i in range(1, n + 1):\\n for j in range(m):\\n # Count of solutions including S[j]\\n x = T[i - S[j]][j][0] if i - S[j] >= 0 else 0\\n\\n # get max_permutation permutation value\\n if x > 0:\\n k = 0\\n while len(T[i][j][1]) < max_permutation and k < len(T[i - S[j]][j][1]):\\n sol = T[i - S[j]][j][1][k]\\n T[i][j][1].append(sol[:])\\n T[i][j][1][-1][j] += 1\\n k += 1\\n\\n # Count of solutions excluding S[j]\\n y = T[i][j - 1][0] if j >= 1 else 0\\n\\n # get max_permutation permutation value\\n if y > 0:\\n k = 0\\n while len(T[i][j][1]) < max_permutation and k < len(T[i][j - 1][1]):\\n sol = T[i][j - 1][1][k]\\n T[i][j][1].append(sol[:])\\n k += 1\\n\\n # total count\\n T[i][j][0] = x + y\\n\\n return T[-1][-1]\",\n \"def lucas_recur(n):\\n if n == 0:\\n return 2\\n elif n == 1:\\n return 1\\n return lucas_recur(n - 1) + lucas_recur(n - 2)\",\n \"def complex(real, imag):\",\n \"def computeList(Code):\\r\\n \\r\\n l = len(Code);\\r\\n # Make sure number of left brackets still == no of right brackets\\r\\n checkBrackets(Code);\\r\\n \\r\\n if l == 0:\\r\\n return None\\r\\n \\r\\n # Base case: Code = ['T'] or ['F'] or has brackets.\\r\\n if l == 1:\\r\\n \\r\\n C = Code[0].strip('( )');\\r\\n \\r\\n if C in constants: return C;\\r\\n \\r\\n else: return Exception(\\\"output is neither true nor false.\\\");\\r\\n \\r\\n \\r\\n # Secondary case: No brackets remaining.\\r\\n elif not containsBrackets(Code):\\r\\n \\r\\n sub = {}; # records reduced indices in list, as a result of computation\\r\\n \\r\\n order = tuple();\\r\\n for prec in precedence:\\r\\n order += orderOfComputation(Code, prec); # Order of looking at the computation\\r\\n \\r\\n for i in order:\\r\\n \\r\\n s = total_sub(sub, i); # Computes the total to be subtracted from index.\\r\\n j = i-s; item = Code[j];\\r\\n \\r\\n # Negation case.\\r\\n if inputs[item] == 1:\\r\\n f = interpret[item]; inp = interpret[Code[j+1]];\\r\\n result = f(inp); string = inverse[result];\\r\\n Code = Code[:j] + [string] + Code[j+2:];\\r\\n \\r\\n # Update sub\\r\\n if not i in sub:\\r\\n sub[i] = 1;\\r\\n \\r\\n else:\\r\\n sub[i] += 1;\\r\\n \\r\\n # Binary Relation case.\\r\\n elif inputs[item] == 2:\\r\\n f = interpret[item]; \\r\\n inp = (interpret[Code[j-1]], interpret[Code[j+1]]);\\r\\n result = f(*inp); string = inverse[result];\\r\\n Code = Code[:j-1] + [string] + Code[j+2:];\\r\\n \\r\\n # Update sub\\r\\n if not i in sub:\\r\\n sub[i] = 2;\\r\\n \\r\\n else:\\r\\n sub[i] += 2;\\r\\n \\r\\n else:\\r\\n raise Exception('incomplete inputs set.')\\r\\n \\r\\n \\r\\n # Tertiary case: brackets left inside to compute.\\r\\n else: # Here, deal with brackets to make sure no brackets are contained in between.\\r\\n \\r\\n # Remove the same total number of brackets from each end.\\r\\n if not hasMidBrackets(Code):\\r\\n endB = endBrackets(Code); first = endB[0]; last = endB[1];\\r\\n Code = Code[first+1: last]; \\r\\n \\r\\n return computeList(Code);\\r\\n \\r\\n # Keep going until right bracket\\r\\n j = 0;\\r\\n while not \\\")\\\" in Code[j]: j += 1;\\r\\n \\r\\n # Go back for left bracket.\\r\\n i = j-1;\\r\\n while not \\\"(\\\" in Code[i] or i < 0: i -= 1;\\r\\n \\r\\n if i < 0: raise Exception(\\\"improper use of brackets.\\\");\\r\\n \\r\\n Code = Code[:i] + [ computeList(Code[i+1:j]) ] + Code[j+1:];\\r\\n \\r\\n return computeList(Code);\",\n \"def number_of_extensions(M, root=None):\\n\\n sp_order_formula = [i for i in M.series_partial_order_representation(root) if\\n (i.__contains__('series') or i.__contains__('parallel'))]\\n\\n while sp_order_formula:\\n\\n # Extend the children of the current operator\\n operator = sp_order_formula.pop()\\n left, right = M.tree.successors(operator)\\n\\n for child in [left, right]:\\n\\n # Recursion if the child is a operator (also known as a sub-tree in Binary Construction Tree).\\n if M.tree.node[child]['num_extension'] == 0:\\n if child.__contains__('series') or child.__contains__('parallel'):\\n M.tree.node[child]['num_extension'] = number_of_extensions(M, child)\\n else:\\n M.tree.node[child]['num_extension'] = 1\\n\\n # Employ the property of series-parallel partial order to calculate the number of extension\\n if operator.__contains__('series'):\\n num_extension = (M.tree.node[left]['num_extension']) * (M.tree.node[right]['num_extension'])\\n M.tree.node[operator]['num_extension'] = num_extension\\n\\n if operator.__contains__('parallel'):\\n # n1, n2 is the number of events (labels) on a partial order, we need to store the previous result.\\n n1 = len([i for i in M.series_partial_order_representation(left) if\\n not (i.__contains__('series') or i.__contains__('parallel'))])\\n n2 = len([i for i in M.series_partial_order_representation(right) if\\n not (i.__contains__('series') or i.__contains__('parallel'))])\\n\\n num_extension = (math.factorial(n1 + n2) / (math.factorial(n1) * (math.factorial(n2)))) * (\\n M.tree.node[left]['num_extension']) * (M.tree.node[right]['num_extension'])\\n\\n M.tree.node[operator]['num_extension'] = num_extension\\n #\\n # # When series structure\\n # if operator.__contains__('series') or operator.__contains__('parallel'):\\n # try:\\n # # Employ the property of series-parallel partial order to calculate the number of extension\\n # if operator.__contains__('series'):\\n # num_extension = (M.tree.node[left]['num_extension']) * (M.tree.node[right]['num_extension'])\\n # M.tree.node[operator]['num_extension'] = num_extension\\n #\\n # if operator.__contains__('parallel'):\\n # # n1, n2 is the number of events (labels) on a partial order, we need to store the previous result.\\n # n1 = len(M.series_partial_order_representation(left))\\n # n2 = len(M.series_partial_order_representation(right))\\n #\\n # num_extension = (math.factorial(n1 + n2) / (math.factorial(n1) * (math.factorial(n2)))) * (\\n # M.tree.node[left]['num_extension']) * (M.tree.node[right]['num_extension'])\\n #\\n # M.tree.node[operator]['num_extension'] = num_extension\\n #\\n # print \\\"{}:{}\\\".format(operator, num_extension)\\n # sp_order_formula.append(operator)\\n # except Exception:\\n # raise Exception\\n #\\n # # When parallel structure\\n # else:\\n # if len(temp_stack) > 0:\\n # temp_left = temp_stack.pop()\\n #\\n # # When they share the same parent then push the temp_left to sp_order_formula\\n # if M.tree.predecessors(temp_left)[0] == M.tree.predecessors(left)[0]:\\n # sp_order_formula.append(operator)\\n # sp_order_formula.append(right)\\n # sp_order_formula.append(left)\\n # sp_order_formula.append(temp_left)\\n # # otherwise, keep pushing the new operator(parent) to temp_stack\\n # else:\\n # temp_stack.append(left)\\n # sp_order_formula.append(operator)\\n # sp_order_formula.append(right)\\n #\\n # result = sp_order_formula.pop()\\n return M.tree.node[root]['num_extension']\",\n \"def complex_value(self) -> global___Expression.ComplexValue:\",\n \"def theta(conc, S, educts):\\n\\n educts_per_reaction = educts.T\\n\\n # in every reaction j row, element at pos (column, species) i equals conc_i^educt_{ij}\\n # educt_{ij} - how many units of i are educts in reaction j\\n multiplicative_term_rows = np.power(conc, educts_per_reaction)\\n\\n # concentrations to educt product ----> product_{i=1}^{n_s}(conc_i^{educt_{ij}}\\n concentration_product = np.prod(multiplicative_term_rows, axis=1)\\n\\n # returns one row with #reactions elements -> fluxes\\n return concentration_product * S\",\n \"def get_contributions(codings, sorted_factors):\\n if codings:\\n formulae = []\\n for prod_of_factors in codings:\\n cur_formula = I\\n for n, c in codings[prod_of_factors]:\\n if c == 'indicator':\\n cur_formula = cur_formula * sorted_factors[n].formula\\n else:\\n cur_formula = cur_formula * sorted_factors[n].drop_first\\n formulae.append((cur_formula, ':'.join(prod_of_factors)))\\n else:\\n formulae = [(Formula([1]),'1')]\\n return formulae\",\n \"def solve_part1(input, verbose=False):\\n equations = parse(input)\\n\\n result = []\\n for eq in equations:\\n result.append(solve_equation_same_precedence(eq, verbose))\\n\\n if verbose:\\n print(f\\\"results: {result}\\\")\\n\\n return sum(result)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7616266","0.5851079","0.58404595","0.5798227","0.5710593","0.5690459","0.5667346","0.55477387","0.54747677","0.5441864","0.5319728","0.5311709","0.52989227","0.5249006","0.5198195","0.51958025","0.51696","0.51376545","0.50467896","0.5002992","0.4932325","0.49014446","0.48635545","0.48592967","0.4823495","0.4801549","0.4753817","0.4753037","0.47435987","0.47122344","0.47068757","0.47014347","0.46979955","0.46964228","0.468982","0.4679752","0.4660977","0.46569645","0.4651411","0.46403033","0.46366104","0.46312556","0.46310514","0.46139333","0.46092874","0.46039033","0.46032614","0.45967492","0.45921457","0.45888758","0.45854315","0.45839334","0.45834818","0.45808828","0.45679787","0.45634115","0.4561928","0.45566612","0.4548738","0.45417252","0.4537491","0.45338556","0.45337915","0.45322016","0.45313218","0.4531213","0.45281953","0.45273647","0.4521044","0.45162946","0.45115831","0.4494461","0.44940346","0.44939423","0.4489931","0.44876346","0.44846824","0.44830155","0.44773337","0.44771385","0.44757548","0.44729602","0.44724283","0.44719797","0.44709262","0.44617775","0.44595993","0.4459142","0.44566065","0.4450678","0.44500998","0.4447469","0.44474423","0.4446355","0.44453308","0.4442907","0.44424585","0.444078","0.4432372","0.44218776"],"string":"[\n \"0.7616266\",\n \"0.5851079\",\n \"0.58404595\",\n \"0.5798227\",\n \"0.5710593\",\n \"0.5690459\",\n \"0.5667346\",\n \"0.55477387\",\n \"0.54747677\",\n \"0.5441864\",\n \"0.5319728\",\n \"0.5311709\",\n \"0.52989227\",\n \"0.5249006\",\n \"0.5198195\",\n \"0.51958025\",\n \"0.51696\",\n \"0.51376545\",\n \"0.50467896\",\n \"0.5002992\",\n \"0.4932325\",\n \"0.49014446\",\n \"0.48635545\",\n \"0.48592967\",\n \"0.4823495\",\n \"0.4801549\",\n \"0.4753817\",\n \"0.4753037\",\n \"0.47435987\",\n \"0.47122344\",\n \"0.47068757\",\n \"0.47014347\",\n \"0.46979955\",\n \"0.46964228\",\n \"0.468982\",\n \"0.4679752\",\n \"0.4660977\",\n \"0.46569645\",\n \"0.4651411\",\n \"0.46403033\",\n \"0.46366104\",\n \"0.46312556\",\n \"0.46310514\",\n \"0.46139333\",\n \"0.46092874\",\n \"0.46039033\",\n \"0.46032614\",\n \"0.45967492\",\n \"0.45921457\",\n \"0.45888758\",\n \"0.45854315\",\n \"0.45839334\",\n \"0.45834818\",\n \"0.45808828\",\n \"0.45679787\",\n \"0.45634115\",\n \"0.4561928\",\n \"0.45566612\",\n \"0.4548738\",\n \"0.45417252\",\n \"0.4537491\",\n \"0.45338556\",\n \"0.45337915\",\n \"0.45322016\",\n \"0.45313218\",\n \"0.4531213\",\n \"0.45281953\",\n \"0.45273647\",\n \"0.4521044\",\n \"0.45162946\",\n \"0.45115831\",\n \"0.4494461\",\n \"0.44940346\",\n \"0.44939423\",\n \"0.4489931\",\n \"0.44876346\",\n \"0.44846824\",\n \"0.44830155\",\n \"0.44773337\",\n \"0.44771385\",\n \"0.44757548\",\n \"0.44729602\",\n \"0.44724283\",\n \"0.44719797\",\n \"0.44709262\",\n \"0.44617775\",\n \"0.44595993\",\n \"0.4459142\",\n \"0.44566065\",\n \"0.4450678\",\n \"0.44500998\",\n \"0.4447469\",\n \"0.44474423\",\n \"0.4446355\",\n \"0.44453308\",\n \"0.4442907\",\n \"0.44424585\",\n \"0.444078\",\n \"0.4432372\",\n \"0.44218776\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.79506034"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":79090,"cells":{"query":{"kind":"string","value":"Create a compound term from a string representing a compound term"},"document":{"kind":"string","value":"def from_string(cls, compound_term_string):\n compound_term_string = compound_term_string.replace(\" \", \"\")\n subterms, connector, intervals = cls.parse_toplevel_subterms_and_connector(compound_term_string)\n return cls(subterms, connector,intervals=intervals)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def from_string(cls, term_string):\n term_string = term_string.replace(\" \", \"\")\n\n if term_string in cls.term_dict:\n return cls.term_dict[term_string]\n\n if term_string[0] == NALSyntax.StatementSyntax.Start.value:\n \"\"\"\n Compound or Statement Term\n \"\"\"\n assert (term_string[-1] == NALSyntax.StatementSyntax.End.value), \"Compound/Statement term must have ending parenthesis: \" + term_string\n\n copula, copula_idx = NALSyntax.Copula.get_top_level_copula(term_string)\n if copula is None:\n # compound term\n term = CompoundTerm.from_string(term_string)\n else:\n term = StatementTerm.from_string(term_string)\n elif NALSyntax.TermConnector.is_set_bracket_start(term_string[0]):\n # set term\n term = CompoundTerm.from_string(term_string)\n elif term_string[0] == NALSyntax.TermConnector.Array.value:\n if NALSyntax.StatementSyntax.ArrayElementIndexStart.value in term_string:\n term = ArrayTermElementTerm.from_string(term_string)\n else:\n term = ArrayTerm.from_string(term_string)\n elif term_string[0] == VariableTerm.VARIABLE_SYM or term_string[0] == VariableTerm.QUERY_SYM:\n # variable term\n dependency_list_start_idx = term_string.find(\"(\")\n if dependency_list_start_idx == -1:\n variable_name = term_string[1:]\n dependency_list_string = \"\"\n else:\n variable_name = term_string[1:dependency_list_start_idx]\n dependency_list_string = term_string[term_string.find(\"(\") + 1:term_string.find(\")\")]\n\n term = VariableTerm.from_string(variable_name=variable_name,\n variable_type_symbol=term_string[0],\n dependency_list_string=dependency_list_string)\n else:\n term_string = re.sub(\",\\d+\", \"\", term_string)\n term = AtomicTerm(term_string)\n\n cls.term_dict[term_string] = term\n\n return term","def parse(s: str):\n Term.str = s\n new_Formula = None\n while Term.str != '':\n new_Formula, Term.str = Formula.parse_prefix(Term.str)\n return new_Formula\n # Task 7.4.2","def term_to_rdflib(term: str) -> Term:\n if term.startswith('?'):\n return Variable(term[1:])\n elif term.startswith(\"\\\"\"):\n return from_n3(term)\n else:\n return URIRef(term)","def from_string_expr(cls, expr):\n if \"*\" in expr:\n ch = \"*\"\n op = \"cross\"\n elif \"+\" in expr:\n ch = \"+\"\n op = \"blend\"\n elif \"/\" in expr:\n ch = \"/\"\n op = \"nest\"\n factors = [cls(s.strip()) for s in expr.split(ch)]\n return cls(op=op, factors=factors)","def from_term(term):\n if term is None:\n return term\n elif isinstance(term, (six.string_types, int, float)):\n return term\n elif isinstance(term, dict):\n return {k: from_term(v) for k, v in term.items()}\n elif isinstance(term, list):\n return [from_term(t) for i, t in enumerate(term)]\n elif issubclass(term.__class__, (Matcher,)):\n return term.generate()\n else:\n raise ValueError('Unknown type: %s' % type(term))","def make_terms_from_string(s):\n u = s\n return u.split()","def parse(s):\n Term.str = s\n new_term = None\n while Term.str != '':\n new_term, Term.str = Term.parse_prefix(Term.str)\n return new_term","def parse_term(s, ctx, mctx, ops):\n s = strip_parens(s.strip())\n if re.search(\"^\\w*$\",s): # If a single word, either a variable or a constant\n if s in ops:\n return Con(ops[s], [], ctx, mctx)\n elif s in ctx:\n return Var(s, ctx, mctx)\n elif s in mctx:\n return MVar(s, [], ctx, mctx)\n elif s.startswith(\"O\") and s[1:] in mctx:\n return MVar(s, [], ctx, mctx, is_hole=True)\n else:\n raise Exception(\"Unbound variable: \" + \"'\" + s + \"'\")\n\n elif re.search(\"^\\w*\\[.*\\]$\", s): # If a metavariable\n m = re.search(\"^(\\w)*\\[(.*)\\]$\", s)\n mvar = m.group(1)\n env = m.group(2)\n if not env:\n return MVar(mvar, [], ctx, mctx, is_hole=mvar.startswith(\"O\"))\n else:\n return MVar(mvar, [Term.parse_term(t, ctx, mctx, ops) for t in split_tuple(env)], ctx, mctx)\n\n elif re.search(\"^([\\w ]*)\\.(.*)$\", s): # If a variable under binders\n m = re.search(\"^([\\w ]*)\\.(.*)$\", s)\n bound = m.group(1).split()\n tm = m.group(2)\n return Term.parse_term(tm, bound + ctx, mctx, ops)\n\n elif re.search(\"^(\\w*) *\\((.*)\\)$\", s): # If an expression\n m = re.search(\"^(\\w*) *\\((.*)\\)$\", s)\n op = m.group(1)\n args = m.group(2)\n return Con(ops[op], [Term.parse_term(t, ctx, mctx, ops) for t in split_tuple(args)], ctx, mctx)\n else:\n raise Exception(\"Can't parse: \" + s)","def parse_toplevel_subterms_and_connector(cls, compound_term_string):\n compound_term_string = compound_term_string.replace(\" \",\"\")\n subterms = []\n intervals = []\n internal_string = compound_term_string[1:-1] # string with no outer parentheses () or set brackets [], {}\n\n # check for intensional/extensional set [a,b], {a,b}\n connector = NALSyntax.TermConnector.get_term_connector_from_string(compound_term_string[0])\n if connector is None:\n # otherwise check for regular Term/Statement connectors\n if internal_string[1] == NALSyntax.StatementSyntax.TermDivider.value:\n connector_string = internal_string[0] # Term connector\n else:\n connector_string = internal_string[0:2] # Statement connector\n connector = NALSyntax.TermConnector.get_term_connector_from_string(connector_string)\n\n assert (internal_string[\n len(\n connector.value)] == NALSyntax.StatementSyntax.TermDivider.value), \"Connector not followed by comma in CompoundTerm string \" + compound_term_string\n internal_string = internal_string[len(connector.value) + 1:]\n\n assert (connector is not None), \"Connector could not be parsed from CompoundTerm string.\"\n\n depth = 0\n subterm_string = \"\"\n for i, c in enumerate(internal_string):\n if c == NALSyntax.StatementSyntax.Start.value or NALSyntax.TermConnector.is_set_bracket_start(c):\n depth += 1\n elif c == NALSyntax.StatementSyntax.End.value or NALSyntax.TermConnector.is_set_bracket_end(c):\n depth -= 1\n\n if c == NALSyntax.StatementSyntax.TermDivider.value and depth == 0:\n if subterm_string.isdigit():\n intervals.append(int(subterm_string))\n else:\n subterm = Term.from_string(subterm_string)\n subterms.append(subterm)\n subterm_string = \"\"\n else:\n subterm_string += c\n\n subterm = Term.from_string(subterm_string)\n subterms.append(subterm)\n\n return subterms, connector, intervals","def term_from_uri(uri):\n if uri is None:\n return None\n # This insures that if we get a Literal with an integer value (as we\n # do for modification positions), it will get converted to a string,\n # not an integer.\n if isinstance(uri, rdflib.Literal):\n uri = str(uri.toPython())\n # This is to handle URIs like\n # http://www.openbel.org/bel/namespace//MAPK%20Erk1/3%20Family\n # or\n # http://www.openbel.org/bel/namespace/MAPK%20Erk1/3%20Family\n # In the current implementation, the order of the patterns\n # matters.\n patterns = ['http://www.openbel.org/bel/namespace//(.*)',\n 'http://www.openbel.org/vocabulary//(.*)',\n 'http://www.openbel.org/bel//(.*)',\n 'http://www.openbel.org/bel/namespace/(.*)',\n 'http://www.openbel.org/vocabulary/(.*)',\n 'http://www.openbel.org/bel/(.*)']\n for pr in patterns:\n match = re.match(pr, uri)\n if match is not None:\n term = match.groups()[0]\n term = unquote(term)\n return term\n # If none of the patterns match then the URI is actually a simple term\n # for instance a site: \"341\" or a substitution: \"sub(V,600,E)\"\n return uri","def parse_prefix(s):\n\n Term.str = replace_string(s) # replace operators with more than one letter to be one letter\n second = None\n\n # if there is a left parentheses it means that we are having an operator that is enclosed by parenthesis\n if is_left_parenthese(Term.str[0]):\n Term.eat() # eat left parentheses\n first, Term.str = Formula.parse_prefix(Term.str) # take first formula of the operator\n root = switch_root_to_str(Term.str[0]) # take the root\n Term.eat() # eat the root\n second, Term.str = Formula.parse_prefix(Term.str) # take second formula of the operator\n Term.eat() # eat right parentheses\n\n # if first letter is a quantifier ('A' or 'E')\n elif is_quantifier(Term.str[0]):\n root = Term.str[0] # take the quantifier as root\n Term.eat() # eat the root ( quantifier)\n first = Term.get_whole_name() # take the name of the variable\n Term.eat() # eat the left bracket\n second, Term.str = Formula.parse_prefix(Term.str) # take the formula\n Term.eat() # eat the right bracket\n\n # if first letter is a relation (starts with capital letter)\n elif is_relation(Term.str[0]):\n root = Term.get_whole_name() # take the name of the relation\n first = []\n Term.eat() # eat left parentheses\n\n # if we didn't find closing parenthesis - than there must be at least one Term inside the parenthesis.\n # take it.\n if not is_right_parenthese(Term.str[0]):\n term_obj, Term.str = Term.parse_prefix(Term.str)\n first.append(term_obj)\n\n # while there is a comma, take the next term\n while is_comma(Term.str[0]):\n Term.eat() # eat left parentheses\n term_obj, Term.str = Term.parse_prefix(Term.str)\n first.append(term_obj)\n Term.eat() # eat right parentheses\n\n # else , it is an operator\n else:\n\n # if it's an unary operator\n if is_unary(Term.str[0]):\n root = Term.str[0]\n Term.eat()\n first, Term.str = Formula.parse_prefix(Term.str)\n\n # else , the operator is binary or equaluty\n else:\n first, Term.str = Term.parse_prefix(Term.str)\n # if it's a binary operator\n if is_binary(Term.str[0]):\n root = Term.str[0:2]\n Term.eat()\n\n # if it's an equal operator\n else:\n root = Term.str[0]\n Term.eat()\n second, Term.str = Term.parse_prefix(Term.str)\n returned_formula = Formula(root, first, second)\n return returned_formula, Term.str","def from_str(klass, s):\n # Special cases\n if s == \"nan\" :\n return RatTerm(RatNum(1, 0), 1)\n elif s == \"0\" :\n return RatTerm(RatNum(0, 1), 1)\n elif s == \"x\" :\n return RatTerm(RatNum(1, 1), 1)\n elif s == \"-x\" :\n return RatTerm(RatNum(-1, 1), 1)\n \n # Exponent\n if \"^\" in s :\n expo = int(s.split(\"^\")[1])\n else :\n expo = 0\n \n # Rational coefficient \n co = s.split(\"*\")[0]\n if \"/\" in co :\n nom, sep, denom = s.partition(\"/\")\n nom = int(nom)\n denom = int(denom.split(\"*\")[0])\n # coefficient = 1\n elif s.startswith(\"x\") :\n nom = 1\n denom = 1\n # coefficient = -1\n elif s.startswith(\"-x\") :\n nom = -1\n denom = 1\n else :\n nom = int(s.split(\"*\")[0])\n denom = 1\n \n return RatTerm(RatNum(nom, denom), expo)","def parseTerm(element):\n tag, text = element.tag, element.text\n if tag == RESULTS_NS_ET + 'literal':\n if text is None:\n text = ''\n datatype = None\n lang = None\n if element.get('datatype', None):\n datatype = URIRef(element.get('datatype'))\n elif element.get(\"{%s}lang\" % XML_NAMESPACE, None):\n lang = element.get(\"{%s}lang\" % XML_NAMESPACE)\n\n ret = Literal(text, datatype=datatype, lang=lang)\n\n return ret\n elif tag == RESULTS_NS_ET + 'uri':\n return URIRef(text)\n elif tag == RESULTS_NS_ET + 'bnode':\n return BNode(text)\n else:\n raise TypeError(\"unknown binding type %r\" % element)","def __generate_object_term__(self, datatype, value):\n if datatype == NS_MGR.xsd.anyURI.rdflib:\n term = rdflib.URIRef(value)\n elif datatype:\n term = rdflib.Literal(value, datatype=datatype)\n else:\n term = rdflib.Literal(value)\n return term","def BNF():\n\n sect_begin = Literal(\"{\").suppress()\n sect_end = Literal(\"}\").suppress()\n array_begin = Literal(\"[\").suppress()\n array_end = Literal(\"]\").suppress()\n tag_begin = Literal(\"<\").suppress()\n tag_end = Literal(\">\").suppress()\n eql = Literal(\"=\").suppress()\n dmark = Literal('$').suppress()\n end_data = Literal('$end').suppress()\n prtable = alphanums + r'!$%&*+-./<>?@^_|~'\n int_t = Regex('[-]?\\d+')\n float_t = Regex('-?\\d+\\.\\d*([eE]?[+-]?\\d+)?')\n bool_t = Regex('([Yy]es|[Nn]o|[Tt]rue|[Ff]alse|[Oo]n|[Oo]ff)')\n\n # Helper definitions\n kstr = quotedString.setParseAction(\n removeQuotes) ^ float_t ^ int_t ^ bool_t ^ Word(prtable)\n name = Word(alphas + \"_\", alphanums + \"_\")\n vec = array_begin + delimitedList(\n float_t ^ int_t ^ bool_t ^ Word(prtable) ^ Literal(\"\\n\").suppress() ^\n quotedString.setParseAction(removeQuotes)) + array_end\n sect = name + sect_begin\n tag_sect = name + Group(tag_begin + name + tag_end) + sect_begin\n\n # Grammar\n keyword = name + eql + kstr\n vector = name + eql + vec\n data = Combine(dmark + name) + SkipTo(end_data) + end_data\n #section = Forward()\n sect_def = (sect | tag_sect)\n #input = section | data | vector | keyword\n input = sect_def | data | vector | keyword | sect_end\n #section << sect_def + ZeroOrMore(input) + sect_end\n\n # Parsing actions\n int_t.setParseAction(token_actions.to_int)\n float_t.setParseAction(token_actions.to_float)\n bool_t.setParseAction(token_actions.to_bool)\n keyword.setParseAction(token_actions.to_scalar)\n vector.setParseAction(token_actions.to_array)\n data.setParseAction(token_actions.to_data)\n sect.setParseAction(token_actions.to_section)\n tag_sect.setParseAction(token_actions.to_section)\n sect_end.setParseAction(token_actions.end_of_section)\n\n bnf = ZeroOrMore(input) + StringEnd().setFailAction(\n token_actions.parse_error)\n bnf.ignore(pythonStyleComment)\n\n return Dict(bnf)","def makeTermType(tag, keyword, G):\n string = \"<%s>\" % tag\n\n l = G(\"%sLSL\" % keyword)\n lsym = G(\"%sLSLSymbol\" % keyword)\n s = G(\"%sS\" % keyword)\n mult = G(\"%sLSMultiplicity\" % keyword)\n senior = G(\"%sLSSeniority\" % keyword)\n\n if l and s:\n string += \"<LS>\"\n string += \"<L><Value>%s</Value>\"% l\n if lsym: string += \"<Symbol>%s</Symbol>\" % lsym\n string += \"</L><S>%s</S>\" % s\n if mult: string += \"<Multiplicity>%s</Multiplicity>\" % mult\n if senior: string += \"<Seniority>%s</Seniority>\" % senior\n string += \"</LS>\"\n\n jj = makeiter(G(\"%sJJ\" % keyword))\n if jj:\n string += \"<jj>\"\n for j in jj:\n string += \"<j>%s</j>\" % j\n string += \"</jj>\"\n j1j2 = makeiter(G(\"%sJ1J2\" % keyword))\n if j1j2:\n string += \"<j1j2>\"\n for j in j1j2:\n string += \"<j>%s</j>\" % j\n string += \"</j1j2>\"\n K = G(\"%sK\" % keyword)\n if K:\n string += \"<jK>\"\n j = G(\"%sJKJ\" % keyword)\n if j:\n string += \"<j>%s</j>\" % j\n S2 = G(\"%sJKS\" % keyword)\n if S2:\n string += \"<S2>%s</S2>\" % S2\n string += \"<K>%s</K>\" % K\n string += \"</jK>\"\n l = G(\"%sLKL\" % keyword)\n k = G(\"%sLKK\" % keyword)\n if l and k:\n string += \"<LK>\"\n string += \"<L><Value>%s</Value><Symbol>%s</Symbol></L>\" % (l, G(\"%sLKLSymbol\" % keyword))\n string += \"<K>%s</K>\" % k\n string += \"<S2>%s</S2>\" % G(\"%sLKS2\" % keyword)\n string += \"</LK>\"\n tlabel = G(\"%sLabel\" % keyword)\n if tlabel:\n string += \"<TermLabel>%s</TermLabel>\" % tlabel\n string += \"</%s>\" % tag\n return string","def tree(string, token=[WORD, POS, CHUNK, PNP, REL, ANCHOR, LEMMA]):\n return Text(string, token)","def parse_term(self) -> SyntaxNode:\n return self._parse_cat_binary(\"M\", self.parse_value)","def format_literal(term: Literal) -> str:\n lang = term.language\n dtype = term.datatype\n lit = str(term)\n if lang is not None or dtype is not None:\n return term.n3()\n if re.fullmatch(r_integer, lit):\n dtype = XSD.integer\n elif re.fullmatch(r_decimal, lit):\n dtype = XSD.decimal\n elif re.fullmatch(r_double, lit):\n dtype = XSD.double\n elif re.fullmatch(r_boolean, lit):\n dtype = XSD.boolean\n return Literal(lit, lang, dtype).n3()","def quote_poly_term(term: str):\n match = re.match(r\"^(\\w+)\\^(\\d+)$\", term)\n if match:\n return (match[1], int(match[2]))\n else:\n return (term, 1)","def from_dict(terms):\n op = MajoranaOperator()\n op.terms = terms\n return op","def cry(s : str) -> CryptolTerm:\n return CryptolTerm(s)","def extract_compounds(text):\n comp_idx = 0\n compound = []\n compound_nps = []\n tok_idx = 0\n for idx, tok in enumerate(nlp(text)):\n if tok.dep_ == \"compound\":\n\n # capture hyphenated compounds\n children = \"\".join([c.text for c in tok.children])\n if \"-\" in children:\n compound.append(\"\".join([children, tok.text]))\n else:\n compound.append(tok.text)\n\n # remember starting index of first child in compound or word\n try:\n tok_idx = [c for c in tok.children][0].idx\n except IndexError:\n if len(compound) == 1:\n tok_idx = tok.idx\n comp_idx = tok.i\n\n # append the last word in a compound phrase\n if tok.i - comp_idx == 1:\n compound.append(tok.text)\n if len(compound) > 1:\n compound = \" \".join(compound)\n compound_nps.append(\n (compound, tok_idx, tok_idx + len(compound), \"COMPOUND\")\n )\n\n # reset parameters\n tok_idx = 0\n compound = []\n\n if len(compound_nps) != 0:\n return compound_nps[0][0]\n else:\n return \"\"","def parse_NFelt(K, s):\n return K([QQ(c) for c in s.split(\",\")])","def to_rdflib_term(value):\n if value.startswith('http'):\n return URIRef(value)\n elif '\"^^http' in value:\n index = value.find('\"^^http')\n value = \"{}<{}>\".format(value[0:index + 3], value[index + 3:])\n return from_n3(value)","def format_term(term: Union[BNode, Literal, URIRef, Variable]) -> str:\n if isinstance(term, URIRef):\n return str(term)\n elif isinstance(term, BNode):\n return '?v_' + str(term)\n elif isinstance(term, Literal):\n return format_literal(term)\n else:\n return term.n3()","def _form_term_from_wick_bcast(term, contrs, phase, resolvers, wick_scheme):\n return _form_term_from_wick(\n term, contrs, phase, resolvers.value, wick_scheme\n )","def build(uri):\n return uri if type(uri) is TaxonomyURI else TaxonomyURI.from_str(uri)","def from_str(triple):\n def nodeIsBlank(element):\n return (element == '%p') or (element.startswith('?'))\n\n elements = triple.strip().split(' ')\n # check if current triple pattern is well formed\n if (len(elements) < 3) or (len(elements) > 3):\n raise SyntaxError('The pattern {} is not well formed : '\n 'it must contains exactly three nodes.'\n .format(triple.strip()))\n\n # seralize it\n subject = Node(elements[0], nodeIsBlank(elements[0]))\n predicate = Node(elements[1], nodeIsBlank(elements[1]))\n obj = Node(elements[2], nodeIsBlank(elements[2]))\n return TriplePattern(subject, predicate, obj)","def _translate(s):\r\n\t\t\r\n\t\t# new term is determined by a space followed by + or -\r\n\t\t# replace with _ and split into terms\r\n\t\ts = s.replace(' +','_+')\r\n\t\ts = s.replace(' -','_-')\r\n\t\t\r\n\t\t# split string into terms\r\n\t\tp = s.split('_')\r\n\t\tt = [Te(i) for i in p]\r\n\t\t\r\n\t\treturn t","def __init__(self, **terms):\n self.terms = []\n for op, v in terms.iteritems():\n # use '_xx' to differentiate terms with same operator\n op = op.split('_')[0]\n if op == 'search':\n val = RegExp(v)\n elif op == 'match':\n val = RegExp(v, match=True)\n else:\n val = v\n try:\n op = self.operators[op]\n except KeyError:\n raise UnknownOperatorError(\"Operator '%s'\" % op)\n self.terms.append((op, val))","def __init__(self, term=None, coefficient=1.0):\n self.terms = {}\n if term is not None:\n term, parity = _sort_majorana_term(term)\n self.terms[term] = coefficient * (-1)**parity","def from_string(\n cls,\n string: str,\n primitive_set: dict,\n to_pipeline: Optional[Callable] = None,\n strict: bool = True,\n ) -> \"Individual\":\n expression = PrimitiveNode.from_string(string, primitive_set, strict)\n return cls(expression, to_pipeline=to_pipeline)","def fold_term(self, init_repr, term):\n if isinstance(term, Var):\n return self.var(init_repr, term.name)\n elif isinstance(term, Const):\n return self.const(init_repr, term.name)\n elif isinstance(term, Dist):\n return self.dist(init_repr, term.name)\n elif isinstance(term, Func):\n return self.func(\n init_repr,\n term.funcname,\n [ self.fold_term(init_repr, x)\n for x in term.args ])\n elif isinstance(term, Eq):\n return self.eq(\n init_repr,\n term.pos,\n self.fold_term(init_repr, term.t1),\n self.fold_term(init_repr, term.t2))\n elif isinstance(term, Disj):\n return self.disj(\n init_repr,\n term.role,\n [ self.fold_term(init_repr, eq)\n for eq in term.eqs ])\n elif isinstance(term, Conj):\n return self.conj(\n init_repr,\n [ self.fold_term(init_repr, disj)\n for disj in term.disjs ])","def _form_term_from_wick(term, contrs, phase, resolvers, wick_scheme):\n\n sums_dict = term.dumms\n\n perm, n_contred = wick_scheme\n phase = _get_perm_phase(perm, phase)\n\n amp = phase\n substs = {}\n for contr_i in range(0, n_contred, 2):\n contr_amp, contr_substs = contrs[perm[contr_i]][perm[contr_i + 1]]\n amp, _ = compose_simplified_delta(\n amp * contr_amp, contr_substs,\n substs, sums_dict=sums_dict, resolvers=resolvers\n )\n continue\n\n vecs = tuple(term.vecs[i] for i in perm[n_contred:])\n return term.subst(\n substs, amp=amp * term.amp, vecs=vecs, purge_sums=True\n )","def read_tree(cls, string):\n \n # first, remove the brackets ()\n string = string.strip()\n if len(string) == 0:\n raise ValueError(\"empty string cannot be a Synstactic Tree\")\n if string[0] == \"(\" and string[-1] == \")\":\n string = string[1:-1]\n \n # split the string with blank character\n # if the string has exactly or fewer than one element, it cannot be a \n # tree\n # if it has two elements, it must be a tree with a terminal node as the\n # root\n # if it has more than two elements, take the first element as the root\n # and other elements as the branches \n elements = string.split()\n if len(elements) <= 1 or elements[1] == \"\":\n raise ValueError(\"%s cannot be a tree or subtree\" %string)\n else:\n if len(elements) == 2:\n # TODO: if the label comes from CCG parser, turn [] into ()\n root = cls._read_terminal_node(elements)\n else:\n branch_string = \" \".join(elements[1:])\n root = SyntacticNode(elements[0])\n branches = cls._read_branches(branch_string)\n for branch in branches:\n root.add_child(branch._root)\n \n return SyntacticTree(root)","def create_from_str(cls, name, size, v_str):\n from re import split\n\n def try_parse(s):\n funcs = [int, float]\n for f in funcs:\n try:\n return f(s)\n except ValueError:\n pass\n return s\n\n if isinstance(try_parse(v_str), (int, float)):\n v_str = \"Constant({})\".format(try_parse(v_str))\n\n parsed = split(\"[()]\", v_str)\n kind = parsed[0]\n args = parsed[1] if len(parsed) >= 2 else \"\"\n entries = (\n tuple(try_parse(a) for a in args.split(\",\")) if args != \"\" else tuple()\n )\n entries_dict = (\n cls.labels.get(kind.lower(), cls.labels[\"input\"]).parse_entries(entries)\n if len(entries) > 0\n else {}\n )\n\n dtype = type(entries[0]) if kind.lower() == \"constant\" else np.float64\n\n v_dict = {\"name\": name, \"kind\": kind, \"size\": size, \"dtype\": dtype}\n v_dict = {**v_dict, **entries_dict}\n return cls.create(**v_dict)","def _add_compound_words(number, word, language_data):\n power_of_10 = _count_zero(number)\n first_dig = str(number)[0]\n if power_of_10 == 0 or first_dig == \"1\":\n return\n\n if \"[\" in word:\n root_word = word.split(\"[\")[0].strip()\n else:\n root_word = word.split(\">\")[0].strip()\n\n if root_word == \"\":\n return\n\n if power_of_10 == 1:\n language_data[\"TENS\"][root_word] = number\n elif power_of_10 == 2:\n language_data[\"HUNDREDS\"][root_word] = number","def parse(s: str) -> StateFormula:\n tree = PCTL_PARSER.parse(s.replace(\" \", \"\"))\n return PCTLTransformer.transform(tree)","def from_normalised_string(string):\n if string[0] == '_':\n return RealPred.from_normalised_string(string)\n else:\n return GPred.from_normalised_string(string)","def from_string(data, format):\n # Using ConjunctiveGraph instead of Graph for nquads support.\n graph = rdflib.ConjunctiveGraph()\n graph.parse(data=data, format=format)\n return graph","def fold_term(self, term):\n if isinstance(term, Var):\n return self.var(term.name)\n elif isinstance(term, Const):\n return self.const(term.name)\n elif isinstance(term, Dist):\n return self.dist(term.name)\n elif isinstance(term, Func):\n return self.func(\n term.funcname,\n tuple( self.fold_term(x)\n for x in term.args ))\n elif isinstance(term, Eq):\n return self.encode_eq(term)\n elif isinstance(term, Disj):\n return self.encode_disj(term)\n elif isinstance(term, Conj):\n return self.encode_conj(term)\n raise RuntimeError('Invalid term {}'.format(term))","def from_str(string):\n if string.lower() == \"happiness\":\n return Expression(1)\n elif string.lower() == \"happy\":\n return Expression(1)\n elif string.lower() == \"fear\":\n return Expression(2)\n elif string.lower() == \"afraid\":\n return Expression(2)\n elif string.lower() == \"anger\":\n return Expression(3)\n elif string.lower() == \"angry\":\n return Expression(3)\n elif string.lower() == \"disgust\":\n return Expression(4)\n elif string.lower() == \"sadness\":\n return Expression(5)\n elif string.lower() == \"sad\":\n return Expression(5)\n elif string.lower() == \"surprise\":\n return Expression(6)\n elif string.lower() == \"neutral\":\n return Expression(7)\n elif string.lower() == \"confusion\":\n return Expression(8)\n elif string.lower() == \"confusing\":\n return Expression(8)\n elif string.lower() == \"contempt\":\n return Expression(9)\n else:\n return None","def term_name_key(name_tuple: tuple[str, list[float]]) -> tuple[str, str]:\n t_type, atoms = name_tuple[0].split('(', 1)\n atoms = atoms[:-1] # Delete the last closing parenthesis\n t_type_words = t_type.rstrip('0123456789') # In case of polyterm, delete the numbers in the end\n match = re.match(r\"([a-zA-Z]+)([0-9]+)\", t_type, re.I)\n t_type_numbers = int(match.groups()[-1]) if match else ''\n return t_type_words, atoms, t_type_numbers","def eval_compound_literal(self, expr: expressions.CompoundLiteral):\n compound_literal_var = self.codegenerator.gen_global_compound_literal(\n expr\n )\n cval = (ir.ptr, compound_literal_var.name)\n return cval","def parse_entity(self, term):\n pass","def get_compound_noun( ngram ):\n try:\n pattern = re.compile( '((?: ?\\\\b[^\\\\s]+(?:/NN.?/[a-z]+/[\\\\d]+)){2,})' )\n match = re.search( pattern, ngram )\n if match:\n compound = ''\n contains_root = False\n tokens = match.group().strip().split(' ')\n for t in tokens:\n # embed()\n items = t.split('/')\n compound += ( items[0] + ' ' )\n if items[3] == 0:\n contains_root = True\n if contains_root:\n return compound\n else:\n return None\n else:\n return None\n \n except ValueError:\n return None","def convert_term(var_map, s, t):\n def convert(t):\n if t.head in var_map:\n if len(t.args) == 0:\n return s(Ident(to_binary(var_map[t.head])))\n elif len(t.args) == 1:\n return s(Para(Ident(to_binary(var_map[t.head])), t.arg))\n else:\n raise NotImplementedError\n elif t.is_equals():\n return Term.mk_equals(convert(t.arg1), convert(t.arg))\n elif logic.is_neg(t):\n return logic.neg(convert(t.arg))\n elif logic.is_conj(t):\n return logic.conj(convert(t.arg1), convert(t.arg))\n elif logic.is_disj(t):\n return logic.disj(convert(t.arg1), convert(t.arg))\n elif t.get_type() == boolT:\n return BoolV(t)\n elif t.get_type() == natT:\n return NatV(t)\n else:\n raise NotImplementedError\n\n return convert(t)","def AddTerm(con, cur, term, parent='na', ontologyname='scdb', synonyms=[], commit=True):\n try:\n # convert everything to lower case before interacting with the database\n term = term.lower()\n parent = parent.lower()\n ontologyname = ontologyname.lower()\n synonyms = [csyn.lower() for csyn in synonyms]\n\n # add/get the ontology term\n err, termid = dbidval.AddItem(con, cur, table='OntologyTable', description=term, commit=False)\n if err:\n return err, None\n # add/get the ontology parent term\n err, parentid = dbidval.AddItem(con, cur, table='OntologyTable', description=parent, commit=False)\n if err:\n return err, None\n # add/get the ontology name\n err, ontologynameid = dbidval.AddItem(con, cur, table='OntologyNamesTable', description=ontologyname, commit=False)\n if err:\n return err, None\n # add the tree info\n err, treeid = AddTreeTerm(con, cur, termid, parentid, ontologynameid, commit=False)\n if err:\n return err, None\n # add the synonyms\n if synonyms:\n for csyn in synonyms:\n err, cid = AddSynonym(con, cur, termid, csyn, commit=False)\n debug(2, 'added ontology term %s. id is %d' % (term, termid))\n if commit:\n con.commit()\n return '', termid\n\n except psycopg2.DatabaseError as e:\n debug(7, \"error %s enountered in ontology.AddTerm\" % e)\n return \"error %s enountered in ontology.AddTerm\" % e, -2","def make_order_specification(cls, order_string):\n try:\n return parse_order(order_string)\n except ParseException as err:\n raise ValueError('Expression parameters have errors. %s' % err)","def compile_term(self):\n\n\t\tself.outfile.write('<term>\\n')\n\n\t\tcount = 0\n\n\t\twhile(self.tokenizer.get_token() not in [')',']',';',',', '/', '|', '<', '>', '=', '*', '+', '&']):\n\t\t\tif self.tokenizer.get_token().isdigit():\n\t\t\t\tself.outfile.write(self.tokenizer.int_value())\n\t\t\telif '\"' in self.tokenizer.get_token():\n\t\t\t\tself.outfile.write(self.tokenizer.str_value())\n\t\t\telif self.tokenizer.get_token() in ['true', 'false', 'null', 'this']:\n\t\t\t\tself.outfile.write(self.tokenizer.keyword())\n\t\t\telif self.tokenizer.get_token() == '-' and count == 0:\n\t\t\t\tself.outfile.write(self.tokenizer.symbol())\n\t\t\t\tself.compile_term()\n\t\t\telif self.tokenizer.get_token() == '-' and count > 0:\n\t\t\t\tbreak\n\t\t\telif self.tokenizer.get_token() == '~':\n\t\t\t\tself.outfile.write(self.tokenizer.symbol())\n\n\t\t\t\tif self.tokenizer.get_token() != '(':\n\t\t\t\t\tself.compile_term()\n\n\t\t\t\telse:\n\t\t\t\t\tself.outfile.write('<term>\\n' + self.tokenizer.symbol())\n\t\t\t\t\tself.compile_expression()\n\t\t\t\t\txml = self.tokenizer.symbol() + '</term>\\n'\n\t\t\t\t\tself.outfile.write(xml)\n\n\t\t\telif self.tokenizer.get_token() == '(':\n\n\t\t\t\tself.outfile.write(self.tokenizer.symbol())\n\t\t\t\tself.compile_expression()\n\t\t\t\tself.outfile.write(self.tokenizer.symbol())\n\n\t\t\telif self.tokenizer.get_token() == '[':\n\t\t\t\txml = self.tokenizer.symbol()\n\t\t\t\tself.outfile.write(xml)\n\n\t\t\t\tself.compile_expression()\n\n\t\t\t\tself.outfile.write(self.tokenizer.symbol())\n\n\t\t\telif self.tokenizer.get_token() == '.':\n\t\t\t\txml = self.tokenizer.symbol() + self.tokenizer.identifier() + self.tokenizer.symbol() + '<expressionList>\\n'\n\t\t\t\tself.outfile.write(xml)\n\n\t\t\t\tif self.tokenizer.get_token() != ')':\n\t\t\t\t\tself.compile_expression_list()\n\n\t\t\t\tself.outfile.write('</expressionList>\\n' + self.tokenizer.symbol())\n\t\t\n\t\t\telse:\n\t\t\t\tself.outfile.write(self.tokenizer.identifier())\n\n\t\t\tcount = count + 1\n\n\t\tself.outfile.write('</term>\\n')\n\n\t\tif self.tokenizer.get_token() in self.tokenizer._operands:\n\t\t\tif self.tokenizer.get_token() in ['<', '>', '\"', '&']:\n\t\t\t\txml = '<symbol> ' + CompilationEngine._operands.get(self.tokenizer.get_token()) + ' </symbol>\\n'\n\t\t\t\tself.tokenizer.advance()\n\t\t\telse:\n\t\t\t\txml = self.tokenizer.symbol()\n\n\t\t\tself.outfile.write(xml)\n\t\t\tself.compile_term()","def simplify(term):\n simplified_term = term\n\n if isinstance(term,StatementTerm):\n simplified_term = StatementTerm(subject_term=simplify(term.get_subject_term()),\n predicate_term=simplify(term.get_predicate_term()),\n copula=term.get_copula(),\n interval=term.interval)\n elif isinstance(term,CompoundTerm):\n if term.connector == NALSyntax.TermConnector.Negation and \\\n len(term.subterms) == 1 and \\\n isinstance(term.subterms[0],CompoundTerm) and \\\n term.subterms[0].connector == NALSyntax.TermConnector.Negation :\n # (--,(--,(S --> P)) <====> (S --> P)\n # Double negation theorem. 2 Negations cancel out\n simplified_term = simplify(term.subterms[0].subterms[0]) # get the inner statement\n # elif NALSyntax.TermConnector.is_conjunction(term.connector):\n # #(&&,A,B..C)\n # new_subterms = []\n # new_intervals = []\n # for i in range(len(term.subterms)):\n # subterm = simplify(term.subterms[i])\n # if i < len(term.intervals): new_intervals.append(term.intervals[i])\n # if isinstance(subterm, CompoundTerm) and subterm.connector == term.connector:\n # # inner conjunction\n # new_subterms.extend(subterm.subterms)\n # new_intervals.extend(subterm.intervals)\n # else:\n # new_subterms.append(subterm)\n #\n # simplified_term = CompoundTerm(subterms=new_subterms,\n # term_connector=term.connector,\n # intervals=new_intervals)\n elif term.connector is NALSyntax.TermConnector.ExtensionalDifference:\n pass\n elif term.connector is NALSyntax.TermConnector.IntensionalDifference:\n pass\n elif term.connector is NALSyntax.TermConnector.ExtensionalImage:\n pass\n elif term.connector is NALSyntax.TermConnector.IntensionalImage:\n pass\n\n\n return simplified_term","def from_string(representation):\r\n gramm = Grammar()\r\n\r\n for rule in representation.strip().split('\\n'):\r\n gramm._add_rule(rule)\r\n\r\n return gramm","def parse_datalog_atom(atom_str: str) -> Atom:\n if '(' not in atom_str:\n return Atom(atom_str, [])\n name, body = atom_str.split(\"(\")\n body = body[:-1]\n values = [parse_atom_value(atom_value) for atom_value in body.split(\",\")]\n return Atom(name, values)","def parse_relation(self, term):\n pass","def parse(text):\n parts = text.split(' ')\n noun = Noun(parts[0], int(parts[1]))\n\n parts = parts[2:]\n while len(parts) > 0:\n noun.add_adjectives(Word(parts[0], int(parts[1])))\n parts = parts[2:]\n return noun","def parse(operators, *term_strs):\n scope = Scope()\n rvs = []\n for ts in term_strs:\n p = Parser(operators, ts, scope)\n try:\n term = p.parse()\n except SyntaxError:\n print 'While parsing: %s' % ts\n raise\n rvs.append(term)\n rvs.append(scope)\n return tuple(rvs)","def compile_word(word):\r\n\r\n if word.isupper():\r\n terms = [('%s*%s' % (10**i, d)) for (i,d) in enumerate(word[::-1])]\r\n return '(' + '+'.join(terms) + ')'\r\n else:\r\n return word","def parse_atom(dlstr):\n\n try:\n tokens = dlstr.split()\n atom = {\"id\": \"{} {}\".format(tokens[0], tokens[1])}\n except IndexError:\n raise ValueError(\"Unrecognised Atom: {!s}\".format(dlstr))\n\n return atom","def fromTerm(cls, term, swipl):\n\n if isinstance(term, Term):\n term = term.handle\n elif not isinstance(term, (c_void_p, int)):\n raise ArgumentTypeError((str(Term), str(int)), str(type(term)))\n\n f = functor_t()\n if swipl.PL_get_functor(term, byref(f)):\n # get args\n args = []\n arity = swipl.PL_functor_arity(f.value)\n # let's have all args be consecutive\n a0 = swipl.PL_new_term_refs(arity)\n for i, a in enumerate(range(1, arity + 1)):\n if swipl.PL_get_arg(a, term, a0 + i):\n args.append(getTerm(a0 + i, swipl))\n\n return cls(f.value, swipl, args=args, a0=a0)","def tag_terms(text, terms, nlp=None):\n from spacy.lang.en.stop_words import STOP_WORDS\n spacy.tokens.token.Token.set_extension('workaround', default='', force=True)\n \n HEURISTIC_TOKENS = [\"-\", \"plant\", \"substance\", \"atom\"]\n \n # default to Stanford NLP pipeline wrapped in Spacy\n if nlp is None:\n snlp = stanfordnlp.Pipeline(lang=\"en\")\n nlp = StanfordNLPLanguage(snlp)\n \n # preprocess with spacy if needed\n if type(terms[0]) != spacy.tokens.doc.Doc:\n terms = [nlp(term) for term in terms]\n if (type(text) != spacy.tokens.doc.Doc and type(text) != spacy.tokens.span.Span):\n text = nlp(text)\n \n # set up a custom representation of the text where we can add term type annotations\n for token in text:\n token._.workaround = token.text_with_ws\n\n lemmatized_text = [token.lemma_ for token in text]\n tokenized_text = [token.text for token in text]\n tags = ['O'] * len(text)\n found_terms = defaultdict(lambda: {\"text\": [], \"indices\": [], \"pos\": [], \"type\": []})\n \n # iterate through terms from longest to shortest\n terms = sorted(terms, key=len)[::-1]\n for spacy_term in terms:\n term_length = len(spacy_term)\n lemma_term_list = [token.lemma_ for token in spacy_term]\n text_term_list = [token.text for token in spacy_term]\n term_lemma = \" \".join(lemma_term_list)\n \n # skip short acronyms that can cause problems\n if len(term_lemma) <= 2:\n continue\n \n # additional check to check for simple plural of uncommon biology terms\n match_uncommon_plural = lemma_term_list.copy()\n match_uncommon_plural[-1] = match_uncommon_plural[-1] + \"s\"\n\n # additional check using heuristics on lemmatized version\n match_heuristic = []\n if lemma_term_list[0] not in HEURISTIC_TOKENS:\n for token in lemma_term_list:\n if token not in HEURISTIC_TOKENS:\n match_heuristic += token.split(\"-\")\n heuristic_length = len(match_heuristic)\n else:\n heuristic_term = lemma_term_list\n heuristic_length = len(lemma_term_list)\n \n for ix in range(len(text) - term_length):\n \n heuristic_match = (lemmatized_text[ix:ix + heuristic_length] == match_heuristic)\n plural_match = (lemmatized_text[ix:ix + term_length] == match_uncommon_plural)\n lemma_match = (lemmatized_text[ix:ix + term_length] == lemma_term_list)\n text_match = (tokenized_text[ix:ix + term_length] == text_term_list)\n lower_match = ([t.lower() for t in tokenized_text[ix:ix + term_length]] ==\n [t.lower() for t in text_term_list])\n \n # Only match on text if lemmatized version is a stop word (i.e. lower casing acronym)\n if term_lemma in STOP_WORDS:\n valid_match = text_match\n else:\n valid_match = heuristic_match or plural_match or text_match or lemma_match or lower_match\n \n if valid_match:\n \n if heuristic_match and not lemma_match:\n match_length = heuristic_length\n else:\n match_length = term_length\n \n term_text = \" \".join([t.text for t in text[ix:ix + match_length]])\n term_tag = \" \".join([t.tag_ for t in text[ix:ix + match_length]])\n \n # only tag term if not part of larger term\n if tags[ix:ix + match_length] == [\"O\"] * match_length:\n \n # classify term type\n term_type = determine_term_type(spacy_term)\n \n # collect term information\n found_terms[term_lemma][\"text\"].append(term_text)\n found_terms[term_lemma][\"indices\"].append((ix, ix + match_length))\n found_terms[term_lemma][\"pos\"].append(term_tag)\n found_terms[term_lemma][\"type\"].append(term_type)\n \n # update sentence tags\n tags = tag_bioes(tags, ix, match_length)\n \n # annotate token representations with term type\n text[ix]._.workaround = f\"<{term_type}>\" + text[ix]._.workaround\n end_ix = ix + match_length - 1\n if text[end_ix]._.workaround.endswith(\" \"):\n text[end_ix]._.workaround = text[end_ix]._.workaround[:-1] + f\"</{term_type}> \"\n else:\n text[end_ix]._.workaround += f\"</{term_type}>\"\n \n # reconstruct fully annotated input text\n annotated_text = \"\"\n for token in text:\n annotated_text += token._.workaround\n \n return {\n \"tokenized_text\": tokenized_text, \n \"tags\": tags, \n \"annotated_text\": annotated_text,\n \"found_terms\": dict(found_terms)\n }","def quantity_from_string(quantity_str):\n\n # Strip out (possible) surrounding quotes\n quote_pattern = '[^\\'\"]+'\n try:\n quantity_str = re.search(quote_pattern, quantity_str).group()\n except AttributeError as e:\n raise AttributeError(\"Please pass a quantity in format of '#*unit'. e.g. '1*atmosphere'\")\n # Parse String\n operators = ['(', ')', '*', '/']\n def find_operator(passed_str):\n # Process the current string until the next operator\n for i, char in enumerate(passed_str):\n if char in operators:\n break\n return i\n\n\n def nested_string(passed_str):\n def exponent_unit(passed_str):\n # Attempt to cast argument as an exponenet\n future_operator_loc = find_operator(passed_str)\n future_operator = passed_str[future_operator_loc]\n if future_operator == '(': # This catches things like x**(3*2), rare, but it could happen\n exponent, exponent_type, exp_count_indices = nested_string(passed_str[future_operator_loc+1:])\n elif future_operator_loc == 0:\n # No more operators\n exponent = passed_str\n future_operator_loc = len(passed_str)\n exp_count_indices = future_operator_loc + 2 # +2 to skip the **\n else:\n exponent = passed_str[:future_operator_loc]\n exp_count_indices = future_operator_loc + 2 # +2 to skip the **\n exponent = float(exponent) # These should only ever be numbers, not quantities, let error occur if they aren't\n if exponent.is_integer(): # Method of float\n exponent = int(exponent)\n return exponent, exp_count_indices\n # Loop through a given string level, returns how many indicies of the string it got through\n last_char_loop = 0\n number_pass_string = len(passed_str)\n last_operator = None\n final_quantity = None\n # Close Parenthisis flag\n paren_closed = False\n while last_char_loop < number_pass_string:\n next_char_loop = find_operator(passed_str[last_char_loop:]) + last_char_loop\n next_char = passed_str[next_char_loop]\n # Figure out what the operator is\n if (next_char_loop == number_pass_string - 1 and (next_char != ')')) or (next_char_loop == 0 and next_char != '(' and next_char != ')'):\n # Case of no new operators found\n argument = passed_str[last_char_loop:]\n else:\n argument = passed_str[last_char_loop:next_char_loop]\n # Strip leading/trailing spaces\n argument = argument.strip(' ')\n # Determine if argument is a unit\n try:\n arg_unit = getattr(unit, argument)\n arg_type = 'unit'\n except Exception as e:\n # Assume its float\n try:\n arg_unit = float(argument)\n arg_type = 'float'\n except: # Usually empty string\n if argument == '':\n arg_unit = None\n arg_type = 'None'\n else:\n raise e # Raise the syntax error\n # See if we are at the end\n augment = None\n count_indices = 1 # How much to offset by to move past operator\n if next_char_loop != number_pass_string:\n next_operator = passed_str[next_char_loop]\n if next_operator == '*':\n try: # Exponent\n if passed_str[next_char_loop+1] == '*':\n exponent, exponent_offset = exponent_unit(passed_str[next_char_loop+2:])\n try:\n next_char_loop += exponent_offset\n # Set the actual next operator (Does not handle nested **)\n next_operator = passed_str[next_char_loop]\n except IndexError:\n # End of string\n next_operator = None\n # Apply exponent\n arg_unit **= exponent\n except:\n pass\n # Check for parenthises\n if next_operator == '(':\n augment, augment_type, count_indices = nested_string(passed_str[next_char_loop+1:])\n count_indices += 1 # add 1 more to offset the '(' itself\n elif next_operator == ')':\n paren_closed = True\n else:\n # Case of no found operators\n next_operator = None\n # Handle the conditions\n if (last_operator is None):\n if (final_quantity is None) and (arg_type is 'None') and (augment is None):\n raise TypeError(\"Given Quantity could not be interpreted as presented\")\n elif (final_quantity is None) and (augment is None):\n final_quantity = arg_unit\n final_type = arg_type\n elif (final_quantity is None) and (arg_type is 'None'):\n final_quantity = augment\n final_type = augment_type\n else:\n if augment is None:\n augment = arg_unit\n augment_type = arg_type\n if last_operator == '*':\n final_quantity *= augment\n elif last_operator == '/':\n final_quantity /= augment\n # Assign type\n if augment_type == 'unit':\n final_type = 'unit'\n elif augment_type == 'float':\n final_type = 'float'\n last_operator = next_operator\n last_char_loop = next_char_loop + count_indices # Set the new position here skipping over processed terms\n if paren_closed:\n # Determine if the next term is a ** to exponentiate augment\n try:\n if passed_str[last_char_loop:last_char_loop+2] == '**':\n exponent, exponent_offset = exponent_unit(passed_str[last_char_loop+2:])\n final_quantity **= exponent\n last_char_loop += exponent_offset\n except:\n pass\n break\n return final_quantity, final_type, last_char_loop\n\n quantity, final_type, x = nested_string(quantity_str)\n return quantity","def parse(s):\n return expr.parseString(s, parseAll=True)","def stringToAxiom(string):\n sentence = []\n splitted = string.split(\" \")\n for mod in splitted:\n sentence.append(stringToMod(mod.strip()))\n return(sentence)","def visit_term(self, node, children):\n if self.debug:\n print(\"Term {}\".format(children))\n term = children[0]\n for i in range(2, len(children), 2):\n if children[i-1] == \"*\":\n term *= children[i]\n else:\n term /= children[i]\n if self.debug:\n print(\"Term = {}\".format(term))\n return term","def _make_product(terms):\n if terms:\n product = terms[0]\n for term in terms[1:]:\n product = Mul((product, term))\n return product \n else:\n return Const(1)","def parse(seq):\n\tdef eval_expr(z, list):\n\t\treturn reduce(lambda s, (f, x): f(s, x), list, z)\n\tunarg = lambda f: lambda x: f(*x)\n\tconst = lambda x: lambda _: x # like ^^^ in Scala\n\n\ttokval = lambda x: x.value # returns the value of a token\n\top = lambda s: a(Token('Op', s)) >> tokval # return the value if token is Op\n\top_ = lambda s: skip(op(s)) # checks if token is Op and ignores it\n\ttoktype = lambda t: some(lambda x: x.type == t) >> tokval # checks type of token\n\tdef lst(h,t):\n\t\treturn [h,] + t\n\tcall = lambda x: Call(x[0], x[1])\n\n\tmakeop = lambda s, f: op(s) >> const(f)\n\n\tadd = makeop('+', Plus)\n\tsub = makeop('-', Minus)\n\tmul = makeop('*', Times)\n\tdiv = makeop('/', Div)\n\n\tdef make_const(i):\n\t\treturn const(int(i))\n\n\tnumber = toktype('Number') >> Const\n\n\tmul_op = mul | div\n\tadd_op = add | sub\n\n\tfactor = with_forward_decls(lambda:\n\t\tnumber | op_('(') + exp + op_(')') | call)\n\tterm = factor + many(mul_op + factor) >> unarg(eval_expr)\n\texp = term + many(add_op + term) >> unarg(eval_expr)\n\texp_lst = with_forward_decls(lambda:\n\t\texp + many(op_(',') + exp) >> unarg(lst))\n\tcall = toktype('Name') + op_('(') + exp_lst + op_(')') >> call\n\n\treturn exp.parse(seq)","def decurify(n3_str, nsm=None):\n assert isinstance(n3_str, six.text_type) and \\\n not isinstance(n3_str, rdflib.term.Identifier)\n if nsm is None:\n nsm = _nsm\n if n3_str.startswith('?'):\n return Variable(n3_str)\n return rdflib.util.from_n3(n3_str, nsm=nsm)","def term( ):\n\n\ttok = tokens.peek( )\n\tif debug: print (\"Term: \", tok)\n\tleft = factor( )\n\ttok = tokens.peek( )\n\twhile tok == \"*\" or tok == \"/\":\n\t\ttokens.next()\n\t\tright = factor( )\n\t\tleft = BinaryExpr( tok, left, right )\n\t\ttok = tokens.peek( )\n\treturn left","def _transform_compound(self, compound):\n assert isinstance(compound, str), \"Input is not a string!\"\n cmpd_features = np.array(compound_short_descriptors(compound),\n dtype=np.float)\n cmpd_features = np.pad(cmpd_features, (0, 80-cmpd_features.shape[0]),\n mode='constant')\n cmpd_features = np.nan_to_num(cmpd_features)\n\n return cmpd_features","def grammarpred(cls, predstr):\n return cls.abstract(predstr)","def ontology_term(self, term=None, parent_ID=None, specified=None, vtype=None,\n desc=None, units=None, **kwargs):\n if specified:\n specified=str2bool(specified)\n\n payload={\"name\":term,\"description\":desc,\"type\":vtype,\"specified\":specified,\"units\":units}\n r=self.post(self.ONTOLOGY_TERM_RT,None,parent_ID,payload,**kwargs)\n return r","def terms(self) -> Tuple[Term, ...]:\n ...","def cnf_from_str(prop):\n splitted = prop.split('and')\n clauses = []\n\n for clause in splitted:\n clause = clause.replace('(', '').replace(')', '')\n str_clause = clause.split('or')\n\n int_litterals = [int(el) for el in str_clause]\n\n clauses.append(int_litterals)\n \n return clauses","def eval_word(word):\n\tbasis = Generators.standard_basis((2,1))\n\tproduct = Automorphism(basis, basis)\n\tassert product.is_identity()\n\twhile len(word) >= 2:\n\t\tletter, sub, word = word[0], int(word[1]), word[2:]\n\t\taut = genrs[sub]\n\t\tif letter == 'y':\n\t\t\taut = ~aut\n\t\tproduct *= aut\n\treturn product","def parse(s, tagVocabulary, pre=False):\n n=RootNode(globalTagDict=tagVocabulary)\n n.parse(lex(s, pre))\n return n","def __init__(self, ty, base_ty):\n\t\t\tassert isinstance(ty, Term)\n\t\t\tassert isinstance(base_ty, Term)\n\t\t\tself.ty = ty\n\t\t\tself.base_ty = ty","def add_compound(neograph, uid, props):\n compounds = neograph.get_or_create_index(neo4j.Node, \"uid\") \n # TODO add try\n # http://blog.safaribooksonline.com/2013/08/07/managing-uniqueness-with-py2neo/\n comp = compounds.get_or_create(\"uid\", uid, props)\n comp.add_labels(\"compound\")\n comp.set_properties(props)\n return comp","def _marshal_term(term):\n if isinstance(term, int):\n term = str(term)\n return term","def create_from_string(root_str):\n\n root_dict = root_str.replace(' ', '').replace(',next:None', '').replace(\n 'val:', '\"val\":').replace('next:', '\"next\":')\n\n data = json.loads(root_dict)\n\n return create_from_dict(data)","def generate_term(self, **kwargs):\n term_map = kwargs.pop('term_map')\n if hasattr(term_map, \"termType\") and\\\n term_map.termType == NS_MGR.rr.BlankNode.rdflib:\n return rdflib.BNode()\n if not hasattr(term_map, 'datatype'):\n term_map.datatype = NS_MGR.xsd.anyURI.rdflib\n if hasattr(term_map, \"template\") and term_map.template is not None:\n template_vars = kwargs\n template_vars.update(self.constants)\n # Call any functions to generate values\n for key, value in template_vars.items():\n if hasattr(value, \"__call__\"):\n template_vars[key] = value()\n raw_value = term_map.template.format(**template_vars)\n if term_map.datatype == NS_MGR.xsd.anyURI.rdflib:\n return rdflib.URIRef(raw_value)\n return rdflib.Literal(raw_value,\n datatype=term_map.datatype)\n if term_map.reference is not None:\n # Each child will have different mechanisms for referencing the\n # source based\n return self.__generate_reference__(term_map, **kwargs)","def fromTerm(cls, term, swipl):\n\n if isinstance(term, Term):\n term = term.handle\n elif not isinstance(term, (c_void_p, int)):\n raise ArgumentTypeError((str(Term), str(c_void_p)), str(type(term)))\n\n a = atom_t()\n if swipl.PL_get_atom(term, byref(a)):\n return cls(a.value, swipl)","def act_on_literal(self, *, value):\n assert not isinstance(value, PolarsTerm)\n if isinstance(value, (Dict, List, Set)):\n return PolarsTerm(polars_term=None, is_literal=True, lit_value=value)\n else:\n return PolarsTerm(polars_term=_build_lit(value), is_literal=True, lit_value=value)","def assign_terms(atoms, term_dict):\n for atom in atoms:\n atom_type = atom.type.upper()\n if atom_type == \"O.3\":\n atom_type = \"O.OH\"\n try:\n atom.poly_terms = term_dict[atom_type]\n except KeyError:\n raise KeyError(\n f\"Unable to find polynomial terms for atom type {atom_type}\"\n )\n return atoms","def __add__(self, other):\n\n other = formula(other, namespace=self.namespace)\n terms = self.terms + other.terms\n pieces = [(term.name, term) for term in terms]\n pieces.sort()\n terms = [piece[1] for piece in pieces]\n return formula(terms, namespace=self.namespace)","def tag_crf(self, untagged_string: str):\n untagged_tokens = wordpunct_tokenize(untagged_string)\n tagger = self._load_model(\"crf\")\n tagged_text = tagger.tag(untagged_tokens)\n return tagged_text","def __init__(self, coeff, compound, phase, name=None):\n self.compound = compound\n self.coeff = coeff\n self.phase = phase\n self._name = name","def test2():\r\n xmlstr = u\"\"\"\r\n<math xmlns=\"http://www.w3.org/1998/Math/MathML\">\r\n <apply>\r\n <plus/>\r\n <cn>1</cn>\r\n <apply>\r\n <times/>\r\n <cn>2</cn>\r\n <ci>α</ci>\r\n </apply>\r\n </apply>\r\n</math>\r\n \"\"\"\r\n return formula(xmlstr)","def testTermInstantiation(self):\n \n action = Parser.parse_as(normalized_drive.split(\"\\n\"), Action, self.domain)\n term = Builder(action)(\"location-of\", \"?t\")\n action.instantiate({\"?from\" : term})\n pre2 = action.precondition.copy(copy_instance=True)\n self.assertEqual(pre2.pddl_str(), \"(and (= (location-of ?t) (location-of ?t)) (= (city-of (location-of ?t)) ?c) (= (city-of ?to) ?c))\")\n action.uninstantiate()","def parseTerms(fp):\n\n try:\n # match \"Terminais\", with or without a comment etc., using RegEx\n # to know more, search for 'python regular expressions'\n ln = fp.readline()\n p = re.compile(r'^Terminais\\s*(?:#.*)?$')\n m = p.match(ln)\n if m == None:\n raise ParseError(ParseError.termsMsg)\n\n # match and capture \"{ a, b }\" etc.\n ln = fp.readline()\n p = re.compile(r'^\\{\\s*(.*)\\s*\\}\\s*(?:#.*)?$')\n m = p.match(ln)\n if m == None:\n raise ParseError(ParseError.termsMsg)\n\n # split the string by ',', trim spaces and return as a set\n a = m.group(1).split(',') # group(1) contains each captured group\n a[:] = map(str.strip, a) # trim spaces in each element of a\n return set(a) # remove duplicates\n\n except:\n raise","def from_word(cls, word):\n return cls(word=word.word, definition=word.definition)","def phon_constructor(loader, node): \n value = loader.construct_scalar(node)\n stem, affix = [normalize(s) for s in value.split('+')]\n return Phon(stem, affix)","def test_build_from_info():\n terms = [Intercept(),\n LinearTerm(0),\n SplineTerm(0),\n FactorTerm(0),\n TensorTerm(0,1)]\n\n for term in terms:\n assert Term.build_from_info(term.info) == term\n\n assert te(0, 1) == TensorTerm(SplineTerm(0, n_splines=10), SplineTerm(1, n_splines=10))","def from_string(orb_str):\n for orb in Orbital.all_orbitals:\n if str(orb) == orb_str:\n return orb\n raise ValueError(\"Illegal orbital definition!\")","def from_str ( cls, vstr ):\n return cls ( cls.OV_KEYWORDS[vstr] )","def from_definition_string(string):\n tokens = Lexer(string).tokenize()\n parser = DirectiveParser(tokens)\n\n (identifier, args) = parser.macro_definition()\n\n # Any remaining tokens after an \"=\" are the macro expansion\n if not parser.eol():\n parser.match_value(Operator, \"=\")\n expansion = parser.tokens[parser.pos:]\n parser.pos = len(parser.tokens)\n else:\n expansion = []\n\n return Macro(identifier, args, expansion)","def Tokens(string):\n return _predicate_sum_from_string(string, Token)","def from_normalised_string(string):\n if string[0] == '_':\n raise PydmrsValueError(\"GPred strings must not begin with an underscore\")\n else:\n return GPred(string)","def generate_operand(uri):\n pass","def test3():\r\n xmlstr = \"\"\"\r\n<math xmlns=\"http://www.w3.org/1998/Math/MathML\">\r\n <apply>\r\n <divide/>\r\n <cn>1</cn>\r\n <apply>\r\n <plus/>\r\n <cn>2</cn>\r\n <ci>γ</ci>\r\n </apply>\r\n </apply>\r\n</math>\r\n \"\"\"\r\n return formula(xmlstr)"],"string":"[\n \"def from_string(cls, term_string):\\n term_string = term_string.replace(\\\" \\\", \\\"\\\")\\n\\n if term_string in cls.term_dict:\\n return cls.term_dict[term_string]\\n\\n if term_string[0] == NALSyntax.StatementSyntax.Start.value:\\n \\\"\\\"\\\"\\n Compound or Statement Term\\n \\\"\\\"\\\"\\n assert (term_string[-1] == NALSyntax.StatementSyntax.End.value), \\\"Compound/Statement term must have ending parenthesis: \\\" + term_string\\n\\n copula, copula_idx = NALSyntax.Copula.get_top_level_copula(term_string)\\n if copula is None:\\n # compound term\\n term = CompoundTerm.from_string(term_string)\\n else:\\n term = StatementTerm.from_string(term_string)\\n elif NALSyntax.TermConnector.is_set_bracket_start(term_string[0]):\\n # set term\\n term = CompoundTerm.from_string(term_string)\\n elif term_string[0] == NALSyntax.TermConnector.Array.value:\\n if NALSyntax.StatementSyntax.ArrayElementIndexStart.value in term_string:\\n term = ArrayTermElementTerm.from_string(term_string)\\n else:\\n term = ArrayTerm.from_string(term_string)\\n elif term_string[0] == VariableTerm.VARIABLE_SYM or term_string[0] == VariableTerm.QUERY_SYM:\\n # variable term\\n dependency_list_start_idx = term_string.find(\\\"(\\\")\\n if dependency_list_start_idx == -1:\\n variable_name = term_string[1:]\\n dependency_list_string = \\\"\\\"\\n else:\\n variable_name = term_string[1:dependency_list_start_idx]\\n dependency_list_string = term_string[term_string.find(\\\"(\\\") + 1:term_string.find(\\\")\\\")]\\n\\n term = VariableTerm.from_string(variable_name=variable_name,\\n variable_type_symbol=term_string[0],\\n dependency_list_string=dependency_list_string)\\n else:\\n term_string = re.sub(\\\",\\\\d+\\\", \\\"\\\", term_string)\\n term = AtomicTerm(term_string)\\n\\n cls.term_dict[term_string] = term\\n\\n return term\",\n \"def parse(s: str):\\n Term.str = s\\n new_Formula = None\\n while Term.str != '':\\n new_Formula, Term.str = Formula.parse_prefix(Term.str)\\n return new_Formula\\n # Task 7.4.2\",\n \"def term_to_rdflib(term: str) -> Term:\\n if term.startswith('?'):\\n return Variable(term[1:])\\n elif term.startswith(\\\"\\\\\\\"\\\"):\\n return from_n3(term)\\n else:\\n return URIRef(term)\",\n \"def from_string_expr(cls, expr):\\n if \\\"*\\\" in expr:\\n ch = \\\"*\\\"\\n op = \\\"cross\\\"\\n elif \\\"+\\\" in expr:\\n ch = \\\"+\\\"\\n op = \\\"blend\\\"\\n elif \\\"/\\\" in expr:\\n ch = \\\"/\\\"\\n op = \\\"nest\\\"\\n factors = [cls(s.strip()) for s in expr.split(ch)]\\n return cls(op=op, factors=factors)\",\n \"def from_term(term):\\n if term is None:\\n return term\\n elif isinstance(term, (six.string_types, int, float)):\\n return term\\n elif isinstance(term, dict):\\n return {k: from_term(v) for k, v in term.items()}\\n elif isinstance(term, list):\\n return [from_term(t) for i, t in enumerate(term)]\\n elif issubclass(term.__class__, (Matcher,)):\\n return term.generate()\\n else:\\n raise ValueError('Unknown type: %s' % type(term))\",\n \"def make_terms_from_string(s):\\n u = s\\n return u.split()\",\n \"def parse(s):\\n Term.str = s\\n new_term = None\\n while Term.str != '':\\n new_term, Term.str = Term.parse_prefix(Term.str)\\n return new_term\",\n \"def parse_term(s, ctx, mctx, ops):\\n s = strip_parens(s.strip())\\n if re.search(\\\"^\\\\w*$\\\",s): # If a single word, either a variable or a constant\\n if s in ops:\\n return Con(ops[s], [], ctx, mctx)\\n elif s in ctx:\\n return Var(s, ctx, mctx)\\n elif s in mctx:\\n return MVar(s, [], ctx, mctx)\\n elif s.startswith(\\\"O\\\") and s[1:] in mctx:\\n return MVar(s, [], ctx, mctx, is_hole=True)\\n else:\\n raise Exception(\\\"Unbound variable: \\\" + \\\"'\\\" + s + \\\"'\\\")\\n\\n elif re.search(\\\"^\\\\w*\\\\[.*\\\\]$\\\", s): # If a metavariable\\n m = re.search(\\\"^(\\\\w)*\\\\[(.*)\\\\]$\\\", s)\\n mvar = m.group(1)\\n env = m.group(2)\\n if not env:\\n return MVar(mvar, [], ctx, mctx, is_hole=mvar.startswith(\\\"O\\\"))\\n else:\\n return MVar(mvar, [Term.parse_term(t, ctx, mctx, ops) for t in split_tuple(env)], ctx, mctx)\\n\\n elif re.search(\\\"^([\\\\w ]*)\\\\.(.*)$\\\", s): # If a variable under binders\\n m = re.search(\\\"^([\\\\w ]*)\\\\.(.*)$\\\", s)\\n bound = m.group(1).split()\\n tm = m.group(2)\\n return Term.parse_term(tm, bound + ctx, mctx, ops)\\n\\n elif re.search(\\\"^(\\\\w*) *\\\\((.*)\\\\)$\\\", s): # If an expression\\n m = re.search(\\\"^(\\\\w*) *\\\\((.*)\\\\)$\\\", s)\\n op = m.group(1)\\n args = m.group(2)\\n return Con(ops[op], [Term.parse_term(t, ctx, mctx, ops) for t in split_tuple(args)], ctx, mctx)\\n else:\\n raise Exception(\\\"Can't parse: \\\" + s)\",\n \"def parse_toplevel_subterms_and_connector(cls, compound_term_string):\\n compound_term_string = compound_term_string.replace(\\\" \\\",\\\"\\\")\\n subterms = []\\n intervals = []\\n internal_string = compound_term_string[1:-1] # string with no outer parentheses () or set brackets [], {}\\n\\n # check for intensional/extensional set [a,b], {a,b}\\n connector = NALSyntax.TermConnector.get_term_connector_from_string(compound_term_string[0])\\n if connector is None:\\n # otherwise check for regular Term/Statement connectors\\n if internal_string[1] == NALSyntax.StatementSyntax.TermDivider.value:\\n connector_string = internal_string[0] # Term connector\\n else:\\n connector_string = internal_string[0:2] # Statement connector\\n connector = NALSyntax.TermConnector.get_term_connector_from_string(connector_string)\\n\\n assert (internal_string[\\n len(\\n connector.value)] == NALSyntax.StatementSyntax.TermDivider.value), \\\"Connector not followed by comma in CompoundTerm string \\\" + compound_term_string\\n internal_string = internal_string[len(connector.value) + 1:]\\n\\n assert (connector is not None), \\\"Connector could not be parsed from CompoundTerm string.\\\"\\n\\n depth = 0\\n subterm_string = \\\"\\\"\\n for i, c in enumerate(internal_string):\\n if c == NALSyntax.StatementSyntax.Start.value or NALSyntax.TermConnector.is_set_bracket_start(c):\\n depth += 1\\n elif c == NALSyntax.StatementSyntax.End.value or NALSyntax.TermConnector.is_set_bracket_end(c):\\n depth -= 1\\n\\n if c == NALSyntax.StatementSyntax.TermDivider.value and depth == 0:\\n if subterm_string.isdigit():\\n intervals.append(int(subterm_string))\\n else:\\n subterm = Term.from_string(subterm_string)\\n subterms.append(subterm)\\n subterm_string = \\\"\\\"\\n else:\\n subterm_string += c\\n\\n subterm = Term.from_string(subterm_string)\\n subterms.append(subterm)\\n\\n return subterms, connector, intervals\",\n \"def term_from_uri(uri):\\n if uri is None:\\n return None\\n # This insures that if we get a Literal with an integer value (as we\\n # do for modification positions), it will get converted to a string,\\n # not an integer.\\n if isinstance(uri, rdflib.Literal):\\n uri = str(uri.toPython())\\n # This is to handle URIs like\\n # http://www.openbel.org/bel/namespace//MAPK%20Erk1/3%20Family\\n # or\\n # http://www.openbel.org/bel/namespace/MAPK%20Erk1/3%20Family\\n # In the current implementation, the order of the patterns\\n # matters.\\n patterns = ['http://www.openbel.org/bel/namespace//(.*)',\\n 'http://www.openbel.org/vocabulary//(.*)',\\n 'http://www.openbel.org/bel//(.*)',\\n 'http://www.openbel.org/bel/namespace/(.*)',\\n 'http://www.openbel.org/vocabulary/(.*)',\\n 'http://www.openbel.org/bel/(.*)']\\n for pr in patterns:\\n match = re.match(pr, uri)\\n if match is not None:\\n term = match.groups()[0]\\n term = unquote(term)\\n return term\\n # If none of the patterns match then the URI is actually a simple term\\n # for instance a site: \\\"341\\\" or a substitution: \\\"sub(V,600,E)\\\"\\n return uri\",\n \"def parse_prefix(s):\\n\\n Term.str = replace_string(s) # replace operators with more than one letter to be one letter\\n second = None\\n\\n # if there is a left parentheses it means that we are having an operator that is enclosed by parenthesis\\n if is_left_parenthese(Term.str[0]):\\n Term.eat() # eat left parentheses\\n first, Term.str = Formula.parse_prefix(Term.str) # take first formula of the operator\\n root = switch_root_to_str(Term.str[0]) # take the root\\n Term.eat() # eat the root\\n second, Term.str = Formula.parse_prefix(Term.str) # take second formula of the operator\\n Term.eat() # eat right parentheses\\n\\n # if first letter is a quantifier ('A' or 'E')\\n elif is_quantifier(Term.str[0]):\\n root = Term.str[0] # take the quantifier as root\\n Term.eat() # eat the root ( quantifier)\\n first = Term.get_whole_name() # take the name of the variable\\n Term.eat() # eat the left bracket\\n second, Term.str = Formula.parse_prefix(Term.str) # take the formula\\n Term.eat() # eat the right bracket\\n\\n # if first letter is a relation (starts with capital letter)\\n elif is_relation(Term.str[0]):\\n root = Term.get_whole_name() # take the name of the relation\\n first = []\\n Term.eat() # eat left parentheses\\n\\n # if we didn't find closing parenthesis - than there must be at least one Term inside the parenthesis.\\n # take it.\\n if not is_right_parenthese(Term.str[0]):\\n term_obj, Term.str = Term.parse_prefix(Term.str)\\n first.append(term_obj)\\n\\n # while there is a comma, take the next term\\n while is_comma(Term.str[0]):\\n Term.eat() # eat left parentheses\\n term_obj, Term.str = Term.parse_prefix(Term.str)\\n first.append(term_obj)\\n Term.eat() # eat right parentheses\\n\\n # else , it is an operator\\n else:\\n\\n # if it's an unary operator\\n if is_unary(Term.str[0]):\\n root = Term.str[0]\\n Term.eat()\\n first, Term.str = Formula.parse_prefix(Term.str)\\n\\n # else , the operator is binary or equaluty\\n else:\\n first, Term.str = Term.parse_prefix(Term.str)\\n # if it's a binary operator\\n if is_binary(Term.str[0]):\\n root = Term.str[0:2]\\n Term.eat()\\n\\n # if it's an equal operator\\n else:\\n root = Term.str[0]\\n Term.eat()\\n second, Term.str = Term.parse_prefix(Term.str)\\n returned_formula = Formula(root, first, second)\\n return returned_formula, Term.str\",\n \"def from_str(klass, s):\\n # Special cases\\n if s == \\\"nan\\\" :\\n return RatTerm(RatNum(1, 0), 1)\\n elif s == \\\"0\\\" :\\n return RatTerm(RatNum(0, 1), 1)\\n elif s == \\\"x\\\" :\\n return RatTerm(RatNum(1, 1), 1)\\n elif s == \\\"-x\\\" :\\n return RatTerm(RatNum(-1, 1), 1)\\n \\n # Exponent\\n if \\\"^\\\" in s :\\n expo = int(s.split(\\\"^\\\")[1])\\n else :\\n expo = 0\\n \\n # Rational coefficient \\n co = s.split(\\\"*\\\")[0]\\n if \\\"/\\\" in co :\\n nom, sep, denom = s.partition(\\\"/\\\")\\n nom = int(nom)\\n denom = int(denom.split(\\\"*\\\")[0])\\n # coefficient = 1\\n elif s.startswith(\\\"x\\\") :\\n nom = 1\\n denom = 1\\n # coefficient = -1\\n elif s.startswith(\\\"-x\\\") :\\n nom = -1\\n denom = 1\\n else :\\n nom = int(s.split(\\\"*\\\")[0])\\n denom = 1\\n \\n return RatTerm(RatNum(nom, denom), expo)\",\n \"def parseTerm(element):\\n tag, text = element.tag, element.text\\n if tag == RESULTS_NS_ET + 'literal':\\n if text is None:\\n text = ''\\n datatype = None\\n lang = None\\n if element.get('datatype', None):\\n datatype = URIRef(element.get('datatype'))\\n elif element.get(\\\"{%s}lang\\\" % XML_NAMESPACE, None):\\n lang = element.get(\\\"{%s}lang\\\" % XML_NAMESPACE)\\n\\n ret = Literal(text, datatype=datatype, lang=lang)\\n\\n return ret\\n elif tag == RESULTS_NS_ET + 'uri':\\n return URIRef(text)\\n elif tag == RESULTS_NS_ET + 'bnode':\\n return BNode(text)\\n else:\\n raise TypeError(\\\"unknown binding type %r\\\" % element)\",\n \"def __generate_object_term__(self, datatype, value):\\n if datatype == NS_MGR.xsd.anyURI.rdflib:\\n term = rdflib.URIRef(value)\\n elif datatype:\\n term = rdflib.Literal(value, datatype=datatype)\\n else:\\n term = rdflib.Literal(value)\\n return term\",\n \"def BNF():\\n\\n sect_begin = Literal(\\\"{\\\").suppress()\\n sect_end = Literal(\\\"}\\\").suppress()\\n array_begin = Literal(\\\"[\\\").suppress()\\n array_end = Literal(\\\"]\\\").suppress()\\n tag_begin = Literal(\\\"<\\\").suppress()\\n tag_end = Literal(\\\">\\\").suppress()\\n eql = Literal(\\\"=\\\").suppress()\\n dmark = Literal('$').suppress()\\n end_data = Literal('$end').suppress()\\n prtable = alphanums + r'!$%&*+-./<>?@^_|~'\\n int_t = Regex('[-]?\\\\d+')\\n float_t = Regex('-?\\\\d+\\\\.\\\\d*([eE]?[+-]?\\\\d+)?')\\n bool_t = Regex('([Yy]es|[Nn]o|[Tt]rue|[Ff]alse|[Oo]n|[Oo]ff)')\\n\\n # Helper definitions\\n kstr = quotedString.setParseAction(\\n removeQuotes) ^ float_t ^ int_t ^ bool_t ^ Word(prtable)\\n name = Word(alphas + \\\"_\\\", alphanums + \\\"_\\\")\\n vec = array_begin + delimitedList(\\n float_t ^ int_t ^ bool_t ^ Word(prtable) ^ Literal(\\\"\\\\n\\\").suppress() ^\\n quotedString.setParseAction(removeQuotes)) + array_end\\n sect = name + sect_begin\\n tag_sect = name + Group(tag_begin + name + tag_end) + sect_begin\\n\\n # Grammar\\n keyword = name + eql + kstr\\n vector = name + eql + vec\\n data = Combine(dmark + name) + SkipTo(end_data) + end_data\\n #section = Forward()\\n sect_def = (sect | tag_sect)\\n #input = section | data | vector | keyword\\n input = sect_def | data | vector | keyword | sect_end\\n #section << sect_def + ZeroOrMore(input) + sect_end\\n\\n # Parsing actions\\n int_t.setParseAction(token_actions.to_int)\\n float_t.setParseAction(token_actions.to_float)\\n bool_t.setParseAction(token_actions.to_bool)\\n keyword.setParseAction(token_actions.to_scalar)\\n vector.setParseAction(token_actions.to_array)\\n data.setParseAction(token_actions.to_data)\\n sect.setParseAction(token_actions.to_section)\\n tag_sect.setParseAction(token_actions.to_section)\\n sect_end.setParseAction(token_actions.end_of_section)\\n\\n bnf = ZeroOrMore(input) + StringEnd().setFailAction(\\n token_actions.parse_error)\\n bnf.ignore(pythonStyleComment)\\n\\n return Dict(bnf)\",\n \"def makeTermType(tag, keyword, G):\\n string = \\\"<%s>\\\" % tag\\n\\n l = G(\\\"%sLSL\\\" % keyword)\\n lsym = G(\\\"%sLSLSymbol\\\" % keyword)\\n s = G(\\\"%sS\\\" % keyword)\\n mult = G(\\\"%sLSMultiplicity\\\" % keyword)\\n senior = G(\\\"%sLSSeniority\\\" % keyword)\\n\\n if l and s:\\n string += \\\"<LS>\\\"\\n string += \\\"<L><Value>%s</Value>\\\"% l\\n if lsym: string += \\\"<Symbol>%s</Symbol>\\\" % lsym\\n string += \\\"</L><S>%s</S>\\\" % s\\n if mult: string += \\\"<Multiplicity>%s</Multiplicity>\\\" % mult\\n if senior: string += \\\"<Seniority>%s</Seniority>\\\" % senior\\n string += \\\"</LS>\\\"\\n\\n jj = makeiter(G(\\\"%sJJ\\\" % keyword))\\n if jj:\\n string += \\\"<jj>\\\"\\n for j in jj:\\n string += \\\"<j>%s</j>\\\" % j\\n string += \\\"</jj>\\\"\\n j1j2 = makeiter(G(\\\"%sJ1J2\\\" % keyword))\\n if j1j2:\\n string += \\\"<j1j2>\\\"\\n for j in j1j2:\\n string += \\\"<j>%s</j>\\\" % j\\n string += \\\"</j1j2>\\\"\\n K = G(\\\"%sK\\\" % keyword)\\n if K:\\n string += \\\"<jK>\\\"\\n j = G(\\\"%sJKJ\\\" % keyword)\\n if j:\\n string += \\\"<j>%s</j>\\\" % j\\n S2 = G(\\\"%sJKS\\\" % keyword)\\n if S2:\\n string += \\\"<S2>%s</S2>\\\" % S2\\n string += \\\"<K>%s</K>\\\" % K\\n string += \\\"</jK>\\\"\\n l = G(\\\"%sLKL\\\" % keyword)\\n k = G(\\\"%sLKK\\\" % keyword)\\n if l and k:\\n string += \\\"<LK>\\\"\\n string += \\\"<L><Value>%s</Value><Symbol>%s</Symbol></L>\\\" % (l, G(\\\"%sLKLSymbol\\\" % keyword))\\n string += \\\"<K>%s</K>\\\" % k\\n string += \\\"<S2>%s</S2>\\\" % G(\\\"%sLKS2\\\" % keyword)\\n string += \\\"</LK>\\\"\\n tlabel = G(\\\"%sLabel\\\" % keyword)\\n if tlabel:\\n string += \\\"<TermLabel>%s</TermLabel>\\\" % tlabel\\n string += \\\"</%s>\\\" % tag\\n return string\",\n \"def tree(string, token=[WORD, POS, CHUNK, PNP, REL, ANCHOR, LEMMA]):\\n return Text(string, token)\",\n \"def parse_term(self) -> SyntaxNode:\\n return self._parse_cat_binary(\\\"M\\\", self.parse_value)\",\n \"def format_literal(term: Literal) -> str:\\n lang = term.language\\n dtype = term.datatype\\n lit = str(term)\\n if lang is not None or dtype is not None:\\n return term.n3()\\n if re.fullmatch(r_integer, lit):\\n dtype = XSD.integer\\n elif re.fullmatch(r_decimal, lit):\\n dtype = XSD.decimal\\n elif re.fullmatch(r_double, lit):\\n dtype = XSD.double\\n elif re.fullmatch(r_boolean, lit):\\n dtype = XSD.boolean\\n return Literal(lit, lang, dtype).n3()\",\n \"def quote_poly_term(term: str):\\n match = re.match(r\\\"^(\\\\w+)\\\\^(\\\\d+)$\\\", term)\\n if match:\\n return (match[1], int(match[2]))\\n else:\\n return (term, 1)\",\n \"def from_dict(terms):\\n op = MajoranaOperator()\\n op.terms = terms\\n return op\",\n \"def cry(s : str) -> CryptolTerm:\\n return CryptolTerm(s)\",\n \"def extract_compounds(text):\\n comp_idx = 0\\n compound = []\\n compound_nps = []\\n tok_idx = 0\\n for idx, tok in enumerate(nlp(text)):\\n if tok.dep_ == \\\"compound\\\":\\n\\n # capture hyphenated compounds\\n children = \\\"\\\".join([c.text for c in tok.children])\\n if \\\"-\\\" in children:\\n compound.append(\\\"\\\".join([children, tok.text]))\\n else:\\n compound.append(tok.text)\\n\\n # remember starting index of first child in compound or word\\n try:\\n tok_idx = [c for c in tok.children][0].idx\\n except IndexError:\\n if len(compound) == 1:\\n tok_idx = tok.idx\\n comp_idx = tok.i\\n\\n # append the last word in a compound phrase\\n if tok.i - comp_idx == 1:\\n compound.append(tok.text)\\n if len(compound) > 1:\\n compound = \\\" \\\".join(compound)\\n compound_nps.append(\\n (compound, tok_idx, tok_idx + len(compound), \\\"COMPOUND\\\")\\n )\\n\\n # reset parameters\\n tok_idx = 0\\n compound = []\\n\\n if len(compound_nps) != 0:\\n return compound_nps[0][0]\\n else:\\n return \\\"\\\"\",\n \"def parse_NFelt(K, s):\\n return K([QQ(c) for c in s.split(\\\",\\\")])\",\n \"def to_rdflib_term(value):\\n if value.startswith('http'):\\n return URIRef(value)\\n elif '\\\"^^http' in value:\\n index = value.find('\\\"^^http')\\n value = \\\"{}<{}>\\\".format(value[0:index + 3], value[index + 3:])\\n return from_n3(value)\",\n \"def format_term(term: Union[BNode, Literal, URIRef, Variable]) -> str:\\n if isinstance(term, URIRef):\\n return str(term)\\n elif isinstance(term, BNode):\\n return '?v_' + str(term)\\n elif isinstance(term, Literal):\\n return format_literal(term)\\n else:\\n return term.n3()\",\n \"def _form_term_from_wick_bcast(term, contrs, phase, resolvers, wick_scheme):\\n return _form_term_from_wick(\\n term, contrs, phase, resolvers.value, wick_scheme\\n )\",\n \"def build(uri):\\n return uri if type(uri) is TaxonomyURI else TaxonomyURI.from_str(uri)\",\n \"def from_str(triple):\\n def nodeIsBlank(element):\\n return (element == '%p') or (element.startswith('?'))\\n\\n elements = triple.strip().split(' ')\\n # check if current triple pattern is well formed\\n if (len(elements) < 3) or (len(elements) > 3):\\n raise SyntaxError('The pattern {} is not well formed : '\\n 'it must contains exactly three nodes.'\\n .format(triple.strip()))\\n\\n # seralize it\\n subject = Node(elements[0], nodeIsBlank(elements[0]))\\n predicate = Node(elements[1], nodeIsBlank(elements[1]))\\n obj = Node(elements[2], nodeIsBlank(elements[2]))\\n return TriplePattern(subject, predicate, obj)\",\n \"def _translate(s):\\r\\n\\t\\t\\r\\n\\t\\t# new term is determined by a space followed by + or -\\r\\n\\t\\t# replace with _ and split into terms\\r\\n\\t\\ts = s.replace(' +','_+')\\r\\n\\t\\ts = s.replace(' -','_-')\\r\\n\\t\\t\\r\\n\\t\\t# split string into terms\\r\\n\\t\\tp = s.split('_')\\r\\n\\t\\tt = [Te(i) for i in p]\\r\\n\\t\\t\\r\\n\\t\\treturn t\",\n \"def __init__(self, **terms):\\n self.terms = []\\n for op, v in terms.iteritems():\\n # use '_xx' to differentiate terms with same operator\\n op = op.split('_')[0]\\n if op == 'search':\\n val = RegExp(v)\\n elif op == 'match':\\n val = RegExp(v, match=True)\\n else:\\n val = v\\n try:\\n op = self.operators[op]\\n except KeyError:\\n raise UnknownOperatorError(\\\"Operator '%s'\\\" % op)\\n self.terms.append((op, val))\",\n \"def __init__(self, term=None, coefficient=1.0):\\n self.terms = {}\\n if term is not None:\\n term, parity = _sort_majorana_term(term)\\n self.terms[term] = coefficient * (-1)**parity\",\n \"def from_string(\\n cls,\\n string: str,\\n primitive_set: dict,\\n to_pipeline: Optional[Callable] = None,\\n strict: bool = True,\\n ) -> \\\"Individual\\\":\\n expression = PrimitiveNode.from_string(string, primitive_set, strict)\\n return cls(expression, to_pipeline=to_pipeline)\",\n \"def fold_term(self, init_repr, term):\\n if isinstance(term, Var):\\n return self.var(init_repr, term.name)\\n elif isinstance(term, Const):\\n return self.const(init_repr, term.name)\\n elif isinstance(term, Dist):\\n return self.dist(init_repr, term.name)\\n elif isinstance(term, Func):\\n return self.func(\\n init_repr,\\n term.funcname,\\n [ self.fold_term(init_repr, x)\\n for x in term.args ])\\n elif isinstance(term, Eq):\\n return self.eq(\\n init_repr,\\n term.pos,\\n self.fold_term(init_repr, term.t1),\\n self.fold_term(init_repr, term.t2))\\n elif isinstance(term, Disj):\\n return self.disj(\\n init_repr,\\n term.role,\\n [ self.fold_term(init_repr, eq)\\n for eq in term.eqs ])\\n elif isinstance(term, Conj):\\n return self.conj(\\n init_repr,\\n [ self.fold_term(init_repr, disj)\\n for disj in term.disjs ])\",\n \"def _form_term_from_wick(term, contrs, phase, resolvers, wick_scheme):\\n\\n sums_dict = term.dumms\\n\\n perm, n_contred = wick_scheme\\n phase = _get_perm_phase(perm, phase)\\n\\n amp = phase\\n substs = {}\\n for contr_i in range(0, n_contred, 2):\\n contr_amp, contr_substs = contrs[perm[contr_i]][perm[contr_i + 1]]\\n amp, _ = compose_simplified_delta(\\n amp * contr_amp, contr_substs,\\n substs, sums_dict=sums_dict, resolvers=resolvers\\n )\\n continue\\n\\n vecs = tuple(term.vecs[i] for i in perm[n_contred:])\\n return term.subst(\\n substs, amp=amp * term.amp, vecs=vecs, purge_sums=True\\n )\",\n \"def read_tree(cls, string):\\n \\n # first, remove the brackets ()\\n string = string.strip()\\n if len(string) == 0:\\n raise ValueError(\\\"empty string cannot be a Synstactic Tree\\\")\\n if string[0] == \\\"(\\\" and string[-1] == \\\")\\\":\\n string = string[1:-1]\\n \\n # split the string with blank character\\n # if the string has exactly or fewer than one element, it cannot be a \\n # tree\\n # if it has two elements, it must be a tree with a terminal node as the\\n # root\\n # if it has more than two elements, take the first element as the root\\n # and other elements as the branches \\n elements = string.split()\\n if len(elements) <= 1 or elements[1] == \\\"\\\":\\n raise ValueError(\\\"%s cannot be a tree or subtree\\\" %string)\\n else:\\n if len(elements) == 2:\\n # TODO: if the label comes from CCG parser, turn [] into ()\\n root = cls._read_terminal_node(elements)\\n else:\\n branch_string = \\\" \\\".join(elements[1:])\\n root = SyntacticNode(elements[0])\\n branches = cls._read_branches(branch_string)\\n for branch in branches:\\n root.add_child(branch._root)\\n \\n return SyntacticTree(root)\",\n \"def create_from_str(cls, name, size, v_str):\\n from re import split\\n\\n def try_parse(s):\\n funcs = [int, float]\\n for f in funcs:\\n try:\\n return f(s)\\n except ValueError:\\n pass\\n return s\\n\\n if isinstance(try_parse(v_str), (int, float)):\\n v_str = \\\"Constant({})\\\".format(try_parse(v_str))\\n\\n parsed = split(\\\"[()]\\\", v_str)\\n kind = parsed[0]\\n args = parsed[1] if len(parsed) >= 2 else \\\"\\\"\\n entries = (\\n tuple(try_parse(a) for a in args.split(\\\",\\\")) if args != \\\"\\\" else tuple()\\n )\\n entries_dict = (\\n cls.labels.get(kind.lower(), cls.labels[\\\"input\\\"]).parse_entries(entries)\\n if len(entries) > 0\\n else {}\\n )\\n\\n dtype = type(entries[0]) if kind.lower() == \\\"constant\\\" else np.float64\\n\\n v_dict = {\\\"name\\\": name, \\\"kind\\\": kind, \\\"size\\\": size, \\\"dtype\\\": dtype}\\n v_dict = {**v_dict, **entries_dict}\\n return cls.create(**v_dict)\",\n \"def _add_compound_words(number, word, language_data):\\n power_of_10 = _count_zero(number)\\n first_dig = str(number)[0]\\n if power_of_10 == 0 or first_dig == \\\"1\\\":\\n return\\n\\n if \\\"[\\\" in word:\\n root_word = word.split(\\\"[\\\")[0].strip()\\n else:\\n root_word = word.split(\\\">\\\")[0].strip()\\n\\n if root_word == \\\"\\\":\\n return\\n\\n if power_of_10 == 1:\\n language_data[\\\"TENS\\\"][root_word] = number\\n elif power_of_10 == 2:\\n language_data[\\\"HUNDREDS\\\"][root_word] = number\",\n \"def parse(s: str) -> StateFormula:\\n tree = PCTL_PARSER.parse(s.replace(\\\" \\\", \\\"\\\"))\\n return PCTLTransformer.transform(tree)\",\n \"def from_normalised_string(string):\\n if string[0] == '_':\\n return RealPred.from_normalised_string(string)\\n else:\\n return GPred.from_normalised_string(string)\",\n \"def from_string(data, format):\\n # Using ConjunctiveGraph instead of Graph for nquads support.\\n graph = rdflib.ConjunctiveGraph()\\n graph.parse(data=data, format=format)\\n return graph\",\n \"def fold_term(self, term):\\n if isinstance(term, Var):\\n return self.var(term.name)\\n elif isinstance(term, Const):\\n return self.const(term.name)\\n elif isinstance(term, Dist):\\n return self.dist(term.name)\\n elif isinstance(term, Func):\\n return self.func(\\n term.funcname,\\n tuple( self.fold_term(x)\\n for x in term.args ))\\n elif isinstance(term, Eq):\\n return self.encode_eq(term)\\n elif isinstance(term, Disj):\\n return self.encode_disj(term)\\n elif isinstance(term, Conj):\\n return self.encode_conj(term)\\n raise RuntimeError('Invalid term {}'.format(term))\",\n \"def from_str(string):\\n if string.lower() == \\\"happiness\\\":\\n return Expression(1)\\n elif string.lower() == \\\"happy\\\":\\n return Expression(1)\\n elif string.lower() == \\\"fear\\\":\\n return Expression(2)\\n elif string.lower() == \\\"afraid\\\":\\n return Expression(2)\\n elif string.lower() == \\\"anger\\\":\\n return Expression(3)\\n elif string.lower() == \\\"angry\\\":\\n return Expression(3)\\n elif string.lower() == \\\"disgust\\\":\\n return Expression(4)\\n elif string.lower() == \\\"sadness\\\":\\n return Expression(5)\\n elif string.lower() == \\\"sad\\\":\\n return Expression(5)\\n elif string.lower() == \\\"surprise\\\":\\n return Expression(6)\\n elif string.lower() == \\\"neutral\\\":\\n return Expression(7)\\n elif string.lower() == \\\"confusion\\\":\\n return Expression(8)\\n elif string.lower() == \\\"confusing\\\":\\n return Expression(8)\\n elif string.lower() == \\\"contempt\\\":\\n return Expression(9)\\n else:\\n return None\",\n \"def term_name_key(name_tuple: tuple[str, list[float]]) -> tuple[str, str]:\\n t_type, atoms = name_tuple[0].split('(', 1)\\n atoms = atoms[:-1] # Delete the last closing parenthesis\\n t_type_words = t_type.rstrip('0123456789') # In case of polyterm, delete the numbers in the end\\n match = re.match(r\\\"([a-zA-Z]+)([0-9]+)\\\", t_type, re.I)\\n t_type_numbers = int(match.groups()[-1]) if match else ''\\n return t_type_words, atoms, t_type_numbers\",\n \"def eval_compound_literal(self, expr: expressions.CompoundLiteral):\\n compound_literal_var = self.codegenerator.gen_global_compound_literal(\\n expr\\n )\\n cval = (ir.ptr, compound_literal_var.name)\\n return cval\",\n \"def parse_entity(self, term):\\n pass\",\n \"def get_compound_noun( ngram ):\\n try:\\n pattern = re.compile( '((?: ?\\\\\\\\b[^\\\\\\\\s]+(?:/NN.?/[a-z]+/[\\\\\\\\d]+)){2,})' )\\n match = re.search( pattern, ngram )\\n if match:\\n compound = ''\\n contains_root = False\\n tokens = match.group().strip().split(' ')\\n for t in tokens:\\n # embed()\\n items = t.split('/')\\n compound += ( items[0] + ' ' )\\n if items[3] == 0:\\n contains_root = True\\n if contains_root:\\n return compound\\n else:\\n return None\\n else:\\n return None\\n \\n except ValueError:\\n return None\",\n \"def convert_term(var_map, s, t):\\n def convert(t):\\n if t.head in var_map:\\n if len(t.args) == 0:\\n return s(Ident(to_binary(var_map[t.head])))\\n elif len(t.args) == 1:\\n return s(Para(Ident(to_binary(var_map[t.head])), t.arg))\\n else:\\n raise NotImplementedError\\n elif t.is_equals():\\n return Term.mk_equals(convert(t.arg1), convert(t.arg))\\n elif logic.is_neg(t):\\n return logic.neg(convert(t.arg))\\n elif logic.is_conj(t):\\n return logic.conj(convert(t.arg1), convert(t.arg))\\n elif logic.is_disj(t):\\n return logic.disj(convert(t.arg1), convert(t.arg))\\n elif t.get_type() == boolT:\\n return BoolV(t)\\n elif t.get_type() == natT:\\n return NatV(t)\\n else:\\n raise NotImplementedError\\n\\n return convert(t)\",\n \"def AddTerm(con, cur, term, parent='na', ontologyname='scdb', synonyms=[], commit=True):\\n try:\\n # convert everything to lower case before interacting with the database\\n term = term.lower()\\n parent = parent.lower()\\n ontologyname = ontologyname.lower()\\n synonyms = [csyn.lower() for csyn in synonyms]\\n\\n # add/get the ontology term\\n err, termid = dbidval.AddItem(con, cur, table='OntologyTable', description=term, commit=False)\\n if err:\\n return err, None\\n # add/get the ontology parent term\\n err, parentid = dbidval.AddItem(con, cur, table='OntologyTable', description=parent, commit=False)\\n if err:\\n return err, None\\n # add/get the ontology name\\n err, ontologynameid = dbidval.AddItem(con, cur, table='OntologyNamesTable', description=ontologyname, commit=False)\\n if err:\\n return err, None\\n # add the tree info\\n err, treeid = AddTreeTerm(con, cur, termid, parentid, ontologynameid, commit=False)\\n if err:\\n return err, None\\n # add the synonyms\\n if synonyms:\\n for csyn in synonyms:\\n err, cid = AddSynonym(con, cur, termid, csyn, commit=False)\\n debug(2, 'added ontology term %s. id is %d' % (term, termid))\\n if commit:\\n con.commit()\\n return '', termid\\n\\n except psycopg2.DatabaseError as e:\\n debug(7, \\\"error %s enountered in ontology.AddTerm\\\" % e)\\n return \\\"error %s enountered in ontology.AddTerm\\\" % e, -2\",\n \"def make_order_specification(cls, order_string):\\n try:\\n return parse_order(order_string)\\n except ParseException as err:\\n raise ValueError('Expression parameters have errors. %s' % err)\",\n \"def compile_term(self):\\n\\n\\t\\tself.outfile.write('<term>\\\\n')\\n\\n\\t\\tcount = 0\\n\\n\\t\\twhile(self.tokenizer.get_token() not in [')',']',';',',', '/', '|', '<', '>', '=', '*', '+', '&']):\\n\\t\\t\\tif self.tokenizer.get_token().isdigit():\\n\\t\\t\\t\\tself.outfile.write(self.tokenizer.int_value())\\n\\t\\t\\telif '\\\"' in self.tokenizer.get_token():\\n\\t\\t\\t\\tself.outfile.write(self.tokenizer.str_value())\\n\\t\\t\\telif self.tokenizer.get_token() in ['true', 'false', 'null', 'this']:\\n\\t\\t\\t\\tself.outfile.write(self.tokenizer.keyword())\\n\\t\\t\\telif self.tokenizer.get_token() == '-' and count == 0:\\n\\t\\t\\t\\tself.outfile.write(self.tokenizer.symbol())\\n\\t\\t\\t\\tself.compile_term()\\n\\t\\t\\telif self.tokenizer.get_token() == '-' and count > 0:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\telif self.tokenizer.get_token() == '~':\\n\\t\\t\\t\\tself.outfile.write(self.tokenizer.symbol())\\n\\n\\t\\t\\t\\tif self.tokenizer.get_token() != '(':\\n\\t\\t\\t\\t\\tself.compile_term()\\n\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tself.outfile.write('<term>\\\\n' + self.tokenizer.symbol())\\n\\t\\t\\t\\t\\tself.compile_expression()\\n\\t\\t\\t\\t\\txml = self.tokenizer.symbol() + '</term>\\\\n'\\n\\t\\t\\t\\t\\tself.outfile.write(xml)\\n\\n\\t\\t\\telif self.tokenizer.get_token() == '(':\\n\\n\\t\\t\\t\\tself.outfile.write(self.tokenizer.symbol())\\n\\t\\t\\t\\tself.compile_expression()\\n\\t\\t\\t\\tself.outfile.write(self.tokenizer.symbol())\\n\\n\\t\\t\\telif self.tokenizer.get_token() == '[':\\n\\t\\t\\t\\txml = self.tokenizer.symbol()\\n\\t\\t\\t\\tself.outfile.write(xml)\\n\\n\\t\\t\\t\\tself.compile_expression()\\n\\n\\t\\t\\t\\tself.outfile.write(self.tokenizer.symbol())\\n\\n\\t\\t\\telif self.tokenizer.get_token() == '.':\\n\\t\\t\\t\\txml = self.tokenizer.symbol() + self.tokenizer.identifier() + self.tokenizer.symbol() + '<expressionList>\\\\n'\\n\\t\\t\\t\\tself.outfile.write(xml)\\n\\n\\t\\t\\t\\tif self.tokenizer.get_token() != ')':\\n\\t\\t\\t\\t\\tself.compile_expression_list()\\n\\n\\t\\t\\t\\tself.outfile.write('</expressionList>\\\\n' + self.tokenizer.symbol())\\n\\t\\t\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.outfile.write(self.tokenizer.identifier())\\n\\n\\t\\t\\tcount = count + 1\\n\\n\\t\\tself.outfile.write('</term>\\\\n')\\n\\n\\t\\tif self.tokenizer.get_token() in self.tokenizer._operands:\\n\\t\\t\\tif self.tokenizer.get_token() in ['<', '>', '\\\"', '&']:\\n\\t\\t\\t\\txml = '<symbol> ' + CompilationEngine._operands.get(self.tokenizer.get_token()) + ' </symbol>\\\\n'\\n\\t\\t\\t\\tself.tokenizer.advance()\\n\\t\\t\\telse:\\n\\t\\t\\t\\txml = self.tokenizer.symbol()\\n\\n\\t\\t\\tself.outfile.write(xml)\\n\\t\\t\\tself.compile_term()\",\n \"def simplify(term):\\n simplified_term = term\\n\\n if isinstance(term,StatementTerm):\\n simplified_term = StatementTerm(subject_term=simplify(term.get_subject_term()),\\n predicate_term=simplify(term.get_predicate_term()),\\n copula=term.get_copula(),\\n interval=term.interval)\\n elif isinstance(term,CompoundTerm):\\n if term.connector == NALSyntax.TermConnector.Negation and \\\\\\n len(term.subterms) == 1 and \\\\\\n isinstance(term.subterms[0],CompoundTerm) and \\\\\\n term.subterms[0].connector == NALSyntax.TermConnector.Negation :\\n # (--,(--,(S --> P)) <====> (S --> P)\\n # Double negation theorem. 2 Negations cancel out\\n simplified_term = simplify(term.subterms[0].subterms[0]) # get the inner statement\\n # elif NALSyntax.TermConnector.is_conjunction(term.connector):\\n # #(&&,A,B..C)\\n # new_subterms = []\\n # new_intervals = []\\n # for i in range(len(term.subterms)):\\n # subterm = simplify(term.subterms[i])\\n # if i < len(term.intervals): new_intervals.append(term.intervals[i])\\n # if isinstance(subterm, CompoundTerm) and subterm.connector == term.connector:\\n # # inner conjunction\\n # new_subterms.extend(subterm.subterms)\\n # new_intervals.extend(subterm.intervals)\\n # else:\\n # new_subterms.append(subterm)\\n #\\n # simplified_term = CompoundTerm(subterms=new_subterms,\\n # term_connector=term.connector,\\n # intervals=new_intervals)\\n elif term.connector is NALSyntax.TermConnector.ExtensionalDifference:\\n pass\\n elif term.connector is NALSyntax.TermConnector.IntensionalDifference:\\n pass\\n elif term.connector is NALSyntax.TermConnector.ExtensionalImage:\\n pass\\n elif term.connector is NALSyntax.TermConnector.IntensionalImage:\\n pass\\n\\n\\n return simplified_term\",\n \"def from_string(representation):\\r\\n gramm = Grammar()\\r\\n\\r\\n for rule in representation.strip().split('\\\\n'):\\r\\n gramm._add_rule(rule)\\r\\n\\r\\n return gramm\",\n \"def parse_datalog_atom(atom_str: str) -> Atom:\\n if '(' not in atom_str:\\n return Atom(atom_str, [])\\n name, body = atom_str.split(\\\"(\\\")\\n body = body[:-1]\\n values = [parse_atom_value(atom_value) for atom_value in body.split(\\\",\\\")]\\n return Atom(name, values)\",\n \"def parse_relation(self, term):\\n pass\",\n \"def parse(text):\\n parts = text.split(' ')\\n noun = Noun(parts[0], int(parts[1]))\\n\\n parts = parts[2:]\\n while len(parts) > 0:\\n noun.add_adjectives(Word(parts[0], int(parts[1])))\\n parts = parts[2:]\\n return noun\",\n \"def parse(operators, *term_strs):\\n scope = Scope()\\n rvs = []\\n for ts in term_strs:\\n p = Parser(operators, ts, scope)\\n try:\\n term = p.parse()\\n except SyntaxError:\\n print 'While parsing: %s' % ts\\n raise\\n rvs.append(term)\\n rvs.append(scope)\\n return tuple(rvs)\",\n \"def compile_word(word):\\r\\n\\r\\n if word.isupper():\\r\\n terms = [('%s*%s' % (10**i, d)) for (i,d) in enumerate(word[::-1])]\\r\\n return '(' + '+'.join(terms) + ')'\\r\\n else:\\r\\n return word\",\n \"def parse_atom(dlstr):\\n\\n try:\\n tokens = dlstr.split()\\n atom = {\\\"id\\\": \\\"{} {}\\\".format(tokens[0], tokens[1])}\\n except IndexError:\\n raise ValueError(\\\"Unrecognised Atom: {!s}\\\".format(dlstr))\\n\\n return atom\",\n \"def fromTerm(cls, term, swipl):\\n\\n if isinstance(term, Term):\\n term = term.handle\\n elif not isinstance(term, (c_void_p, int)):\\n raise ArgumentTypeError((str(Term), str(int)), str(type(term)))\\n\\n f = functor_t()\\n if swipl.PL_get_functor(term, byref(f)):\\n # get args\\n args = []\\n arity = swipl.PL_functor_arity(f.value)\\n # let's have all args be consecutive\\n a0 = swipl.PL_new_term_refs(arity)\\n for i, a in enumerate(range(1, arity + 1)):\\n if swipl.PL_get_arg(a, term, a0 + i):\\n args.append(getTerm(a0 + i, swipl))\\n\\n return cls(f.value, swipl, args=args, a0=a0)\",\n \"def tag_terms(text, terms, nlp=None):\\n from spacy.lang.en.stop_words import STOP_WORDS\\n spacy.tokens.token.Token.set_extension('workaround', default='', force=True)\\n \\n HEURISTIC_TOKENS = [\\\"-\\\", \\\"plant\\\", \\\"substance\\\", \\\"atom\\\"]\\n \\n # default to Stanford NLP pipeline wrapped in Spacy\\n if nlp is None:\\n snlp = stanfordnlp.Pipeline(lang=\\\"en\\\")\\n nlp = StanfordNLPLanguage(snlp)\\n \\n # preprocess with spacy if needed\\n if type(terms[0]) != spacy.tokens.doc.Doc:\\n terms = [nlp(term) for term in terms]\\n if (type(text) != spacy.tokens.doc.Doc and type(text) != spacy.tokens.span.Span):\\n text = nlp(text)\\n \\n # set up a custom representation of the text where we can add term type annotations\\n for token in text:\\n token._.workaround = token.text_with_ws\\n\\n lemmatized_text = [token.lemma_ for token in text]\\n tokenized_text = [token.text for token in text]\\n tags = ['O'] * len(text)\\n found_terms = defaultdict(lambda: {\\\"text\\\": [], \\\"indices\\\": [], \\\"pos\\\": [], \\\"type\\\": []})\\n \\n # iterate through terms from longest to shortest\\n terms = sorted(terms, key=len)[::-1]\\n for spacy_term in terms:\\n term_length = len(spacy_term)\\n lemma_term_list = [token.lemma_ for token in spacy_term]\\n text_term_list = [token.text for token in spacy_term]\\n term_lemma = \\\" \\\".join(lemma_term_list)\\n \\n # skip short acronyms that can cause problems\\n if len(term_lemma) <= 2:\\n continue\\n \\n # additional check to check for simple plural of uncommon biology terms\\n match_uncommon_plural = lemma_term_list.copy()\\n match_uncommon_plural[-1] = match_uncommon_plural[-1] + \\\"s\\\"\\n\\n # additional check using heuristics on lemmatized version\\n match_heuristic = []\\n if lemma_term_list[0] not in HEURISTIC_TOKENS:\\n for token in lemma_term_list:\\n if token not in HEURISTIC_TOKENS:\\n match_heuristic += token.split(\\\"-\\\")\\n heuristic_length = len(match_heuristic)\\n else:\\n heuristic_term = lemma_term_list\\n heuristic_length = len(lemma_term_list)\\n \\n for ix in range(len(text) - term_length):\\n \\n heuristic_match = (lemmatized_text[ix:ix + heuristic_length] == match_heuristic)\\n plural_match = (lemmatized_text[ix:ix + term_length] == match_uncommon_plural)\\n lemma_match = (lemmatized_text[ix:ix + term_length] == lemma_term_list)\\n text_match = (tokenized_text[ix:ix + term_length] == text_term_list)\\n lower_match = ([t.lower() for t in tokenized_text[ix:ix + term_length]] ==\\n [t.lower() for t in text_term_list])\\n \\n # Only match on text if lemmatized version is a stop word (i.e. lower casing acronym)\\n if term_lemma in STOP_WORDS:\\n valid_match = text_match\\n else:\\n valid_match = heuristic_match or plural_match or text_match or lemma_match or lower_match\\n \\n if valid_match:\\n \\n if heuristic_match and not lemma_match:\\n match_length = heuristic_length\\n else:\\n match_length = term_length\\n \\n term_text = \\\" \\\".join([t.text for t in text[ix:ix + match_length]])\\n term_tag = \\\" \\\".join([t.tag_ for t in text[ix:ix + match_length]])\\n \\n # only tag term if not part of larger term\\n if tags[ix:ix + match_length] == [\\\"O\\\"] * match_length:\\n \\n # classify term type\\n term_type = determine_term_type(spacy_term)\\n \\n # collect term information\\n found_terms[term_lemma][\\\"text\\\"].append(term_text)\\n found_terms[term_lemma][\\\"indices\\\"].append((ix, ix + match_length))\\n found_terms[term_lemma][\\\"pos\\\"].append(term_tag)\\n found_terms[term_lemma][\\\"type\\\"].append(term_type)\\n \\n # update sentence tags\\n tags = tag_bioes(tags, ix, match_length)\\n \\n # annotate token representations with term type\\n text[ix]._.workaround = f\\\"<{term_type}>\\\" + text[ix]._.workaround\\n end_ix = ix + match_length - 1\\n if text[end_ix]._.workaround.endswith(\\\" \\\"):\\n text[end_ix]._.workaround = text[end_ix]._.workaround[:-1] + f\\\"</{term_type}> \\\"\\n else:\\n text[end_ix]._.workaround += f\\\"</{term_type}>\\\"\\n \\n # reconstruct fully annotated input text\\n annotated_text = \\\"\\\"\\n for token in text:\\n annotated_text += token._.workaround\\n \\n return {\\n \\\"tokenized_text\\\": tokenized_text, \\n \\\"tags\\\": tags, \\n \\\"annotated_text\\\": annotated_text,\\n \\\"found_terms\\\": dict(found_terms)\\n }\",\n \"def quantity_from_string(quantity_str):\\n\\n # Strip out (possible) surrounding quotes\\n quote_pattern = '[^\\\\'\\\"]+'\\n try:\\n quantity_str = re.search(quote_pattern, quantity_str).group()\\n except AttributeError as e:\\n raise AttributeError(\\\"Please pass a quantity in format of '#*unit'. e.g. '1*atmosphere'\\\")\\n # Parse String\\n operators = ['(', ')', '*', '/']\\n def find_operator(passed_str):\\n # Process the current string until the next operator\\n for i, char in enumerate(passed_str):\\n if char in operators:\\n break\\n return i\\n\\n\\n def nested_string(passed_str):\\n def exponent_unit(passed_str):\\n # Attempt to cast argument as an exponenet\\n future_operator_loc = find_operator(passed_str)\\n future_operator = passed_str[future_operator_loc]\\n if future_operator == '(': # This catches things like x**(3*2), rare, but it could happen\\n exponent, exponent_type, exp_count_indices = nested_string(passed_str[future_operator_loc+1:])\\n elif future_operator_loc == 0:\\n # No more operators\\n exponent = passed_str\\n future_operator_loc = len(passed_str)\\n exp_count_indices = future_operator_loc + 2 # +2 to skip the **\\n else:\\n exponent = passed_str[:future_operator_loc]\\n exp_count_indices = future_operator_loc + 2 # +2 to skip the **\\n exponent = float(exponent) # These should only ever be numbers, not quantities, let error occur if they aren't\\n if exponent.is_integer(): # Method of float\\n exponent = int(exponent)\\n return exponent, exp_count_indices\\n # Loop through a given string level, returns how many indicies of the string it got through\\n last_char_loop = 0\\n number_pass_string = len(passed_str)\\n last_operator = None\\n final_quantity = None\\n # Close Parenthisis flag\\n paren_closed = False\\n while last_char_loop < number_pass_string:\\n next_char_loop = find_operator(passed_str[last_char_loop:]) + last_char_loop\\n next_char = passed_str[next_char_loop]\\n # Figure out what the operator is\\n if (next_char_loop == number_pass_string - 1 and (next_char != ')')) or (next_char_loop == 0 and next_char != '(' and next_char != ')'):\\n # Case of no new operators found\\n argument = passed_str[last_char_loop:]\\n else:\\n argument = passed_str[last_char_loop:next_char_loop]\\n # Strip leading/trailing spaces\\n argument = argument.strip(' ')\\n # Determine if argument is a unit\\n try:\\n arg_unit = getattr(unit, argument)\\n arg_type = 'unit'\\n except Exception as e:\\n # Assume its float\\n try:\\n arg_unit = float(argument)\\n arg_type = 'float'\\n except: # Usually empty string\\n if argument == '':\\n arg_unit = None\\n arg_type = 'None'\\n else:\\n raise e # Raise the syntax error\\n # See if we are at the end\\n augment = None\\n count_indices = 1 # How much to offset by to move past operator\\n if next_char_loop != number_pass_string:\\n next_operator = passed_str[next_char_loop]\\n if next_operator == '*':\\n try: # Exponent\\n if passed_str[next_char_loop+1] == '*':\\n exponent, exponent_offset = exponent_unit(passed_str[next_char_loop+2:])\\n try:\\n next_char_loop += exponent_offset\\n # Set the actual next operator (Does not handle nested **)\\n next_operator = passed_str[next_char_loop]\\n except IndexError:\\n # End of string\\n next_operator = None\\n # Apply exponent\\n arg_unit **= exponent\\n except:\\n pass\\n # Check for parenthises\\n if next_operator == '(':\\n augment, augment_type, count_indices = nested_string(passed_str[next_char_loop+1:])\\n count_indices += 1 # add 1 more to offset the '(' itself\\n elif next_operator == ')':\\n paren_closed = True\\n else:\\n # Case of no found operators\\n next_operator = None\\n # Handle the conditions\\n if (last_operator is None):\\n if (final_quantity is None) and (arg_type is 'None') and (augment is None):\\n raise TypeError(\\\"Given Quantity could not be interpreted as presented\\\")\\n elif (final_quantity is None) and (augment is None):\\n final_quantity = arg_unit\\n final_type = arg_type\\n elif (final_quantity is None) and (arg_type is 'None'):\\n final_quantity = augment\\n final_type = augment_type\\n else:\\n if augment is None:\\n augment = arg_unit\\n augment_type = arg_type\\n if last_operator == '*':\\n final_quantity *= augment\\n elif last_operator == '/':\\n final_quantity /= augment\\n # Assign type\\n if augment_type == 'unit':\\n final_type = 'unit'\\n elif augment_type == 'float':\\n final_type = 'float'\\n last_operator = next_operator\\n last_char_loop = next_char_loop + count_indices # Set the new position here skipping over processed terms\\n if paren_closed:\\n # Determine if the next term is a ** to exponentiate augment\\n try:\\n if passed_str[last_char_loop:last_char_loop+2] == '**':\\n exponent, exponent_offset = exponent_unit(passed_str[last_char_loop+2:])\\n final_quantity **= exponent\\n last_char_loop += exponent_offset\\n except:\\n pass\\n break\\n return final_quantity, final_type, last_char_loop\\n\\n quantity, final_type, x = nested_string(quantity_str)\\n return quantity\",\n \"def parse(s):\\n return expr.parseString(s, parseAll=True)\",\n \"def stringToAxiom(string):\\n sentence = []\\n splitted = string.split(\\\" \\\")\\n for mod in splitted:\\n sentence.append(stringToMod(mod.strip()))\\n return(sentence)\",\n \"def visit_term(self, node, children):\\n if self.debug:\\n print(\\\"Term {}\\\".format(children))\\n term = children[0]\\n for i in range(2, len(children), 2):\\n if children[i-1] == \\\"*\\\":\\n term *= children[i]\\n else:\\n term /= children[i]\\n if self.debug:\\n print(\\\"Term = {}\\\".format(term))\\n return term\",\n \"def _make_product(terms):\\n if terms:\\n product = terms[0]\\n for term in terms[1:]:\\n product = Mul((product, term))\\n return product \\n else:\\n return Const(1)\",\n \"def parse(seq):\\n\\tdef eval_expr(z, list):\\n\\t\\treturn reduce(lambda s, (f, x): f(s, x), list, z)\\n\\tunarg = lambda f: lambda x: f(*x)\\n\\tconst = lambda x: lambda _: x # like ^^^ in Scala\\n\\n\\ttokval = lambda x: x.value # returns the value of a token\\n\\top = lambda s: a(Token('Op', s)) >> tokval # return the value if token is Op\\n\\top_ = lambda s: skip(op(s)) # checks if token is Op and ignores it\\n\\ttoktype = lambda t: some(lambda x: x.type == t) >> tokval # checks type of token\\n\\tdef lst(h,t):\\n\\t\\treturn [h,] + t\\n\\tcall = lambda x: Call(x[0], x[1])\\n\\n\\tmakeop = lambda s, f: op(s) >> const(f)\\n\\n\\tadd = makeop('+', Plus)\\n\\tsub = makeop('-', Minus)\\n\\tmul = makeop('*', Times)\\n\\tdiv = makeop('/', Div)\\n\\n\\tdef make_const(i):\\n\\t\\treturn const(int(i))\\n\\n\\tnumber = toktype('Number') >> Const\\n\\n\\tmul_op = mul | div\\n\\tadd_op = add | sub\\n\\n\\tfactor = with_forward_decls(lambda:\\n\\t\\tnumber | op_('(') + exp + op_(')') | call)\\n\\tterm = factor + many(mul_op + factor) >> unarg(eval_expr)\\n\\texp = term + many(add_op + term) >> unarg(eval_expr)\\n\\texp_lst = with_forward_decls(lambda:\\n\\t\\texp + many(op_(',') + exp) >> unarg(lst))\\n\\tcall = toktype('Name') + op_('(') + exp_lst + op_(')') >> call\\n\\n\\treturn exp.parse(seq)\",\n \"def decurify(n3_str, nsm=None):\\n assert isinstance(n3_str, six.text_type) and \\\\\\n not isinstance(n3_str, rdflib.term.Identifier)\\n if nsm is None:\\n nsm = _nsm\\n if n3_str.startswith('?'):\\n return Variable(n3_str)\\n return rdflib.util.from_n3(n3_str, nsm=nsm)\",\n \"def term( ):\\n\\n\\ttok = tokens.peek( )\\n\\tif debug: print (\\\"Term: \\\", tok)\\n\\tleft = factor( )\\n\\ttok = tokens.peek( )\\n\\twhile tok == \\\"*\\\" or tok == \\\"/\\\":\\n\\t\\ttokens.next()\\n\\t\\tright = factor( )\\n\\t\\tleft = BinaryExpr( tok, left, right )\\n\\t\\ttok = tokens.peek( )\\n\\treturn left\",\n \"def _transform_compound(self, compound):\\n assert isinstance(compound, str), \\\"Input is not a string!\\\"\\n cmpd_features = np.array(compound_short_descriptors(compound),\\n dtype=np.float)\\n cmpd_features = np.pad(cmpd_features, (0, 80-cmpd_features.shape[0]),\\n mode='constant')\\n cmpd_features = np.nan_to_num(cmpd_features)\\n\\n return cmpd_features\",\n \"def grammarpred(cls, predstr):\\n return cls.abstract(predstr)\",\n \"def ontology_term(self, term=None, parent_ID=None, specified=None, vtype=None,\\n desc=None, units=None, **kwargs):\\n if specified:\\n specified=str2bool(specified)\\n\\n payload={\\\"name\\\":term,\\\"description\\\":desc,\\\"type\\\":vtype,\\\"specified\\\":specified,\\\"units\\\":units}\\n r=self.post(self.ONTOLOGY_TERM_RT,None,parent_ID,payload,**kwargs)\\n return r\",\n \"def terms(self) -> Tuple[Term, ...]:\\n ...\",\n \"def cnf_from_str(prop):\\n splitted = prop.split('and')\\n clauses = []\\n\\n for clause in splitted:\\n clause = clause.replace('(', '').replace(')', '')\\n str_clause = clause.split('or')\\n\\n int_litterals = [int(el) for el in str_clause]\\n\\n clauses.append(int_litterals)\\n \\n return clauses\",\n \"def eval_word(word):\\n\\tbasis = Generators.standard_basis((2,1))\\n\\tproduct = Automorphism(basis, basis)\\n\\tassert product.is_identity()\\n\\twhile len(word) >= 2:\\n\\t\\tletter, sub, word = word[0], int(word[1]), word[2:]\\n\\t\\taut = genrs[sub]\\n\\t\\tif letter == 'y':\\n\\t\\t\\taut = ~aut\\n\\t\\tproduct *= aut\\n\\treturn product\",\n \"def parse(s, tagVocabulary, pre=False):\\n n=RootNode(globalTagDict=tagVocabulary)\\n n.parse(lex(s, pre))\\n return n\",\n \"def __init__(self, ty, base_ty):\\n\\t\\t\\tassert isinstance(ty, Term)\\n\\t\\t\\tassert isinstance(base_ty, Term)\\n\\t\\t\\tself.ty = ty\\n\\t\\t\\tself.base_ty = ty\",\n \"def add_compound(neograph, uid, props):\\n compounds = neograph.get_or_create_index(neo4j.Node, \\\"uid\\\") \\n # TODO add try\\n # http://blog.safaribooksonline.com/2013/08/07/managing-uniqueness-with-py2neo/\\n comp = compounds.get_or_create(\\\"uid\\\", uid, props)\\n comp.add_labels(\\\"compound\\\")\\n comp.set_properties(props)\\n return comp\",\n \"def _marshal_term(term):\\n if isinstance(term, int):\\n term = str(term)\\n return term\",\n \"def create_from_string(root_str):\\n\\n root_dict = root_str.replace(' ', '').replace(',next:None', '').replace(\\n 'val:', '\\\"val\\\":').replace('next:', '\\\"next\\\":')\\n\\n data = json.loads(root_dict)\\n\\n return create_from_dict(data)\",\n \"def generate_term(self, **kwargs):\\n term_map = kwargs.pop('term_map')\\n if hasattr(term_map, \\\"termType\\\") and\\\\\\n term_map.termType == NS_MGR.rr.BlankNode.rdflib:\\n return rdflib.BNode()\\n if not hasattr(term_map, 'datatype'):\\n term_map.datatype = NS_MGR.xsd.anyURI.rdflib\\n if hasattr(term_map, \\\"template\\\") and term_map.template is not None:\\n template_vars = kwargs\\n template_vars.update(self.constants)\\n # Call any functions to generate values\\n for key, value in template_vars.items():\\n if hasattr(value, \\\"__call__\\\"):\\n template_vars[key] = value()\\n raw_value = term_map.template.format(**template_vars)\\n if term_map.datatype == NS_MGR.xsd.anyURI.rdflib:\\n return rdflib.URIRef(raw_value)\\n return rdflib.Literal(raw_value,\\n datatype=term_map.datatype)\\n if term_map.reference is not None:\\n # Each child will have different mechanisms for referencing the\\n # source based\\n return self.__generate_reference__(term_map, **kwargs)\",\n \"def fromTerm(cls, term, swipl):\\n\\n if isinstance(term, Term):\\n term = term.handle\\n elif not isinstance(term, (c_void_p, int)):\\n raise ArgumentTypeError((str(Term), str(c_void_p)), str(type(term)))\\n\\n a = atom_t()\\n if swipl.PL_get_atom(term, byref(a)):\\n return cls(a.value, swipl)\",\n \"def act_on_literal(self, *, value):\\n assert not isinstance(value, PolarsTerm)\\n if isinstance(value, (Dict, List, Set)):\\n return PolarsTerm(polars_term=None, is_literal=True, lit_value=value)\\n else:\\n return PolarsTerm(polars_term=_build_lit(value), is_literal=True, lit_value=value)\",\n \"def assign_terms(atoms, term_dict):\\n for atom in atoms:\\n atom_type = atom.type.upper()\\n if atom_type == \\\"O.3\\\":\\n atom_type = \\\"O.OH\\\"\\n try:\\n atom.poly_terms = term_dict[atom_type]\\n except KeyError:\\n raise KeyError(\\n f\\\"Unable to find polynomial terms for atom type {atom_type}\\\"\\n )\\n return atoms\",\n \"def __add__(self, other):\\n\\n other = formula(other, namespace=self.namespace)\\n terms = self.terms + other.terms\\n pieces = [(term.name, term) for term in terms]\\n pieces.sort()\\n terms = [piece[1] for piece in pieces]\\n return formula(terms, namespace=self.namespace)\",\n \"def tag_crf(self, untagged_string: str):\\n untagged_tokens = wordpunct_tokenize(untagged_string)\\n tagger = self._load_model(\\\"crf\\\")\\n tagged_text = tagger.tag(untagged_tokens)\\n return tagged_text\",\n \"def __init__(self, coeff, compound, phase, name=None):\\n self.compound = compound\\n self.coeff = coeff\\n self.phase = phase\\n self._name = name\",\n \"def test2():\\r\\n xmlstr = u\\\"\\\"\\\"\\r\\n<math xmlns=\\\"http://www.w3.org/1998/Math/MathML\\\">\\r\\n <apply>\\r\\n <plus/>\\r\\n <cn>1</cn>\\r\\n <apply>\\r\\n <times/>\\r\\n <cn>2</cn>\\r\\n <ci>α</ci>\\r\\n </apply>\\r\\n </apply>\\r\\n</math>\\r\\n \\\"\\\"\\\"\\r\\n return formula(xmlstr)\",\n \"def testTermInstantiation(self):\\n \\n action = Parser.parse_as(normalized_drive.split(\\\"\\\\n\\\"), Action, self.domain)\\n term = Builder(action)(\\\"location-of\\\", \\\"?t\\\")\\n action.instantiate({\\\"?from\\\" : term})\\n pre2 = action.precondition.copy(copy_instance=True)\\n self.assertEqual(pre2.pddl_str(), \\\"(and (= (location-of ?t) (location-of ?t)) (= (city-of (location-of ?t)) ?c) (= (city-of ?to) ?c))\\\")\\n action.uninstantiate()\",\n \"def parseTerms(fp):\\n\\n try:\\n # match \\\"Terminais\\\", with or without a comment etc., using RegEx\\n # to know more, search for 'python regular expressions'\\n ln = fp.readline()\\n p = re.compile(r'^Terminais\\\\s*(?:#.*)?$')\\n m = p.match(ln)\\n if m == None:\\n raise ParseError(ParseError.termsMsg)\\n\\n # match and capture \\\"{ a, b }\\\" etc.\\n ln = fp.readline()\\n p = re.compile(r'^\\\\{\\\\s*(.*)\\\\s*\\\\}\\\\s*(?:#.*)?$')\\n m = p.match(ln)\\n if m == None:\\n raise ParseError(ParseError.termsMsg)\\n\\n # split the string by ',', trim spaces and return as a set\\n a = m.group(1).split(',') # group(1) contains each captured group\\n a[:] = map(str.strip, a) # trim spaces in each element of a\\n return set(a) # remove duplicates\\n\\n except:\\n raise\",\n \"def from_word(cls, word):\\n return cls(word=word.word, definition=word.definition)\",\n \"def phon_constructor(loader, node): \\n value = loader.construct_scalar(node)\\n stem, affix = [normalize(s) for s in value.split('+')]\\n return Phon(stem, affix)\",\n \"def test_build_from_info():\\n terms = [Intercept(),\\n LinearTerm(0),\\n SplineTerm(0),\\n FactorTerm(0),\\n TensorTerm(0,1)]\\n\\n for term in terms:\\n assert Term.build_from_info(term.info) == term\\n\\n assert te(0, 1) == TensorTerm(SplineTerm(0, n_splines=10), SplineTerm(1, n_splines=10))\",\n \"def from_string(orb_str):\\n for orb in Orbital.all_orbitals:\\n if str(orb) == orb_str:\\n return orb\\n raise ValueError(\\\"Illegal orbital definition!\\\")\",\n \"def from_str ( cls, vstr ):\\n return cls ( cls.OV_KEYWORDS[vstr] )\",\n \"def from_definition_string(string):\\n tokens = Lexer(string).tokenize()\\n parser = DirectiveParser(tokens)\\n\\n (identifier, args) = parser.macro_definition()\\n\\n # Any remaining tokens after an \\\"=\\\" are the macro expansion\\n if not parser.eol():\\n parser.match_value(Operator, \\\"=\\\")\\n expansion = parser.tokens[parser.pos:]\\n parser.pos = len(parser.tokens)\\n else:\\n expansion = []\\n\\n return Macro(identifier, args, expansion)\",\n \"def Tokens(string):\\n return _predicate_sum_from_string(string, Token)\",\n \"def from_normalised_string(string):\\n if string[0] == '_':\\n raise PydmrsValueError(\\\"GPred strings must not begin with an underscore\\\")\\n else:\\n return GPred(string)\",\n \"def generate_operand(uri):\\n pass\",\n \"def test3():\\r\\n xmlstr = \\\"\\\"\\\"\\r\\n<math xmlns=\\\"http://www.w3.org/1998/Math/MathML\\\">\\r\\n <apply>\\r\\n <divide/>\\r\\n <cn>1</cn>\\r\\n <apply>\\r\\n <plus/>\\r\\n <cn>2</cn>\\r\\n <ci>γ</ci>\\r\\n </apply>\\r\\n </apply>\\r\\n</math>\\r\\n \\\"\\\"\\\"\\r\\n return formula(xmlstr)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7619937","0.6340459","0.62865704","0.622182","0.6211368","0.6205652","0.6153318","0.60456955","0.58313286","0.57834095","0.5756795","0.5701587","0.56921804","0.55409914","0.5532965","0.5528887","0.5520905","0.54063135","0.54001784","0.53797454","0.53685623","0.53649944","0.5342913","0.5304133","0.5264045","0.52315277","0.5207128","0.51720583","0.515804","0.513623","0.51207024","0.5111043","0.51015174","0.50948113","0.50922316","0.50902516","0.5079465","0.50692683","0.50664467","0.5065209","0.5052145","0.5022158","0.50124454","0.49987414","0.49955538","0.49910083","0.4978936","0.49776366","0.49544764","0.4953994","0.4952784","0.49318042","0.49134263","0.4910445","0.4903698","0.4900786","0.48911652","0.48910832","0.488289","0.4879561","0.48788568","0.4871589","0.48662168","0.486615","0.48619682","0.48607782","0.48591766","0.48578024","0.4855546","0.48529768","0.48461914","0.48351857","0.4829816","0.48236212","0.4819323","0.48122966","0.48110154","0.48085082","0.48034218","0.47981513","0.47874734","0.47873867","0.47852245","0.47849345","0.4778904","0.4768713","0.4751764","0.47512585","0.4748752","0.47409827","0.47343034","0.47273296","0.4725814","0.47251743","0.47184688","0.47182682","0.47170892","0.47134843","0.471058","0.4710245"],"string":"[\n \"0.7619937\",\n \"0.6340459\",\n \"0.62865704\",\n \"0.622182\",\n \"0.6211368\",\n \"0.6205652\",\n \"0.6153318\",\n \"0.60456955\",\n \"0.58313286\",\n \"0.57834095\",\n \"0.5756795\",\n \"0.5701587\",\n \"0.56921804\",\n \"0.55409914\",\n \"0.5532965\",\n \"0.5528887\",\n \"0.5520905\",\n \"0.54063135\",\n \"0.54001784\",\n \"0.53797454\",\n \"0.53685623\",\n \"0.53649944\",\n \"0.5342913\",\n \"0.5304133\",\n \"0.5264045\",\n \"0.52315277\",\n \"0.5207128\",\n \"0.51720583\",\n \"0.515804\",\n \"0.513623\",\n \"0.51207024\",\n \"0.5111043\",\n \"0.51015174\",\n \"0.50948113\",\n \"0.50922316\",\n \"0.50902516\",\n \"0.5079465\",\n \"0.50692683\",\n \"0.50664467\",\n \"0.5065209\",\n \"0.5052145\",\n \"0.5022158\",\n \"0.50124454\",\n \"0.49987414\",\n \"0.49955538\",\n \"0.49910083\",\n \"0.4978936\",\n \"0.49776366\",\n \"0.49544764\",\n \"0.4953994\",\n \"0.4952784\",\n \"0.49318042\",\n \"0.49134263\",\n \"0.4910445\",\n \"0.4903698\",\n \"0.4900786\",\n \"0.48911652\",\n \"0.48910832\",\n \"0.488289\",\n \"0.4879561\",\n \"0.48788568\",\n \"0.4871589\",\n \"0.48662168\",\n \"0.486615\",\n \"0.48619682\",\n \"0.48607782\",\n \"0.48591766\",\n \"0.48578024\",\n \"0.4855546\",\n \"0.48529768\",\n \"0.48461914\",\n \"0.48351857\",\n \"0.4829816\",\n \"0.48236212\",\n \"0.4819323\",\n \"0.48122966\",\n \"0.48110154\",\n \"0.48085082\",\n \"0.48034218\",\n \"0.47981513\",\n \"0.47874734\",\n \"0.47873867\",\n \"0.47852245\",\n \"0.47849345\",\n \"0.4778904\",\n \"0.4768713\",\n \"0.4751764\",\n \"0.47512585\",\n \"0.4748752\",\n \"0.47409827\",\n \"0.47343034\",\n \"0.47273296\",\n \"0.4725814\",\n \"0.47251743\",\n \"0.47184688\",\n \"0.47182682\",\n \"0.47170892\",\n \"0.47134843\",\n \"0.471058\",\n \"0.4710245\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75882727"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":79091,"cells":{"query":{"kind":"string","value":"Parse out all toplevel subterms from a string representing a compound term compound_term_string a string representing a compound term"},"document":{"kind":"string","value":"def parse_toplevel_subterms_and_connector(cls, compound_term_string):\n compound_term_string = compound_term_string.replace(\" \",\"\")\n subterms = []\n intervals = []\n internal_string = compound_term_string[1:-1] # string with no outer parentheses () or set brackets [], {}\n\n # check for intensional/extensional set [a,b], {a,b}\n connector = NALSyntax.TermConnector.get_term_connector_from_string(compound_term_string[0])\n if connector is None:\n # otherwise check for regular Term/Statement connectors\n if internal_string[1] == NALSyntax.StatementSyntax.TermDivider.value:\n connector_string = internal_string[0] # Term connector\n else:\n connector_string = internal_string[0:2] # Statement connector\n connector = NALSyntax.TermConnector.get_term_connector_from_string(connector_string)\n\n assert (internal_string[\n len(\n connector.value)] == NALSyntax.StatementSyntax.TermDivider.value), \"Connector not followed by comma in CompoundTerm string \" + compound_term_string\n internal_string = internal_string[len(connector.value) + 1:]\n\n assert (connector is not None), \"Connector could not be parsed from CompoundTerm string.\"\n\n depth = 0\n subterm_string = \"\"\n for i, c in enumerate(internal_string):\n if c == NALSyntax.StatementSyntax.Start.value or NALSyntax.TermConnector.is_set_bracket_start(c):\n depth += 1\n elif c == NALSyntax.StatementSyntax.End.value or NALSyntax.TermConnector.is_set_bracket_end(c):\n depth -= 1\n\n if c == NALSyntax.StatementSyntax.TermDivider.value and depth == 0:\n if subterm_string.isdigit():\n intervals.append(int(subterm_string))\n else:\n subterm = Term.from_string(subterm_string)\n subterms.append(subterm)\n subterm_string = \"\"\n else:\n subterm_string += c\n\n subterm = Term.from_string(subterm_string)\n subterms.append(subterm)\n\n return subterms, connector, intervals"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def from_string(cls, compound_term_string):\n compound_term_string = compound_term_string.replace(\" \", \"\")\n subterms, connector, intervals = cls.parse_toplevel_subterms_and_connector(compound_term_string)\n return cls(subterms, connector,intervals=intervals)","def parse(self, string, root=None):\n\n\t\tphrases = []\n\n\t\tmeta = self.meta.search(string)\n\n\t\twhile meta:\n\n\t\t\t# Save some function calls\n\t\t\tpos = meta.start()\n\n\t\t\tif meta.group() == \"<\":\n\t\t\t\tstring, child, meta = self.open_phrase(string, pos)\n\n\t\t\t\tif child and root:\n\t\t\t\t\troot.nested.append(child)\n\t\t\t\telif child:\n\t\t\t\t\tphrases.append(child)\n\n\t\t\t\t# else it was escaped (+ new meta)\n\t\t\t\tcontinue\n\n\t\t\telif root:\n\n\t\t\t\tif meta.group() == \"(\":\n\t\t\t\t\tmeta = self.meta.search(string, pos + 1)\n\t\t\t\t\tif meta.group() == \")\":\n\t\t\t\t\t\tstring, root, meta = self.handle_arguments(string,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t root,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t pos,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t meta.start())\n\t\t\t\t\t\tcontinue\n\n\t\t\t\telif meta.group() == \">\":\n\t\t\t\t\tstring, phrase, meta = self.close_phrase(string,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t root,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t pos)\n\t\t\t\t\tif phrase:\n\t\t\t\t\t\treturn string, phrase\n\n\t\t\t\t\t# else was escaped (+ new meta)\n\t\t\t\t\tcontinue\n\n\t\t\tstring, meta = self.escape_meta(string, pos)\n\n\t\tif not root:\n\t\t\treturn string, phrases\n\n\t\t# If this is not the first stack-depth the function should\n\t\t# have returned upon finding a closing tag,\n\t\t# i.e. we should never have gotten here.\n\t\tword = re.search(r\"([\\w\\s]+)(?![\\d]*>[\\w\\s]+>)\", string)\n\n\t\twhat = \"No closing tag found for opening tag\"\n\n\t\tif word:\n\t\t\twhat += \" after expression '{0}'\".format(word.group())\n\n\t\traise errors.ParseError(what + \"!\")","def parse_prefix(s):\n\n Term.str = replace_string(s) # replace operators with more than one letter to be one letter\n second = None\n\n # if there is a left parentheses it means that we are having an operator that is enclosed by parenthesis\n if is_left_parenthese(Term.str[0]):\n Term.eat() # eat left parentheses\n first, Term.str = Formula.parse_prefix(Term.str) # take first formula of the operator\n root = switch_root_to_str(Term.str[0]) # take the root\n Term.eat() # eat the root\n second, Term.str = Formula.parse_prefix(Term.str) # take second formula of the operator\n Term.eat() # eat right parentheses\n\n # if first letter is a quantifier ('A' or 'E')\n elif is_quantifier(Term.str[0]):\n root = Term.str[0] # take the quantifier as root\n Term.eat() # eat the root ( quantifier)\n first = Term.get_whole_name() # take the name of the variable\n Term.eat() # eat the left bracket\n second, Term.str = Formula.parse_prefix(Term.str) # take the formula\n Term.eat() # eat the right bracket\n\n # if first letter is a relation (starts with capital letter)\n elif is_relation(Term.str[0]):\n root = Term.get_whole_name() # take the name of the relation\n first = []\n Term.eat() # eat left parentheses\n\n # if we didn't find closing parenthesis - than there must be at least one Term inside the parenthesis.\n # take it.\n if not is_right_parenthese(Term.str[0]):\n term_obj, Term.str = Term.parse_prefix(Term.str)\n first.append(term_obj)\n\n # while there is a comma, take the next term\n while is_comma(Term.str[0]):\n Term.eat() # eat left parentheses\n term_obj, Term.str = Term.parse_prefix(Term.str)\n first.append(term_obj)\n Term.eat() # eat right parentheses\n\n # else , it is an operator\n else:\n\n # if it's an unary operator\n if is_unary(Term.str[0]):\n root = Term.str[0]\n Term.eat()\n first, Term.str = Formula.parse_prefix(Term.str)\n\n # else , the operator is binary or equaluty\n else:\n first, Term.str = Term.parse_prefix(Term.str)\n # if it's a binary operator\n if is_binary(Term.str[0]):\n root = Term.str[0:2]\n Term.eat()\n\n # if it's an equal operator\n else:\n root = Term.str[0]\n Term.eat()\n second, Term.str = Term.parse_prefix(Term.str)\n returned_formula = Formula(root, first, second)\n return returned_formula, Term.str","def extract_compounds(text):\n comp_idx = 0\n compound = []\n compound_nps = []\n tok_idx = 0\n for idx, tok in enumerate(nlp(text)):\n if tok.dep_ == \"compound\":\n\n # capture hyphenated compounds\n children = \"\".join([c.text for c in tok.children])\n if \"-\" in children:\n compound.append(\"\".join([children, tok.text]))\n else:\n compound.append(tok.text)\n\n # remember starting index of first child in compound or word\n try:\n tok_idx = [c for c in tok.children][0].idx\n except IndexError:\n if len(compound) == 1:\n tok_idx = tok.idx\n comp_idx = tok.i\n\n # append the last word in a compound phrase\n if tok.i - comp_idx == 1:\n compound.append(tok.text)\n if len(compound) > 1:\n compound = \" \".join(compound)\n compound_nps.append(\n (compound, tok_idx, tok_idx + len(compound), \"COMPOUND\")\n )\n\n # reset parameters\n tok_idx = 0\n compound = []\n\n if len(compound_nps) != 0:\n return compound_nps[0][0]\n else:\n return \"\"","def parse (self, phrase):\r\n\r\n if isinstance(phrase,str):\r\n #If the phrase is a string\r\n if self.is_simple(phrase):\r\n #EXITS the recursion\r\n if phrase[0:2] == '~~':\r\n return phrase[2:]\r\n #Eliminates negations that cancel each other\r\n return phrase\r\n elif self.bracketed(phrase):\r\n #Eliminate top-level parantheses\r\n return self.parse(phrase[1:-1])\r\n elif phrase[0] == '~':\r\n #If the phrase begins with a negating prefix...\r\n negations,phrase = self.heading_count(phrase)\r\n \r\n if self.bracketed(phrase):\r\n #If the negated phrase is bracketed\r\n if negations % 2 == 1:\r\n subphrase = self.split_into_phrases(phrase[1:-1])\r\n if subphrase[0] != '@': \r\n #De Morgan's Law \r\n return self.parse(['@']+['~'+x for x in subphrase])\r\n else:\r\n #De Morgan's Law\r\n return self.parse(['~'+x for x in subphrase[1:]])\r\n else:\r\n return self.parse(phrase[1:-1])\r\n return self.parse(self.split_into_phrases((negations%2)*'~'+phrase))\r\n \r\n else:\r\n return self.parse(self.split_into_phrases(phrase))\r\n # IF the phrase is a list\r\n if self.all_is_P(phrase,predicate_function=self.is_simple):\r\n #If every terms of the phrase list is simple...\r\n #This prepares for EXIT from recursion\r\n return [self.parse(x) for x in phrase]\r\n return self.parse([self.parse(x) for x in phrase])","def parse(s: str):\n Term.str = s\n new_Formula = None\n while Term.str != '':\n new_Formula, Term.str = Formula.parse_prefix(Term.str)\n return new_Formula\n # Task 7.4.2","def parse(s):\n Term.str = s\n new_term = None\n while Term.str != '':\n new_term, Term.str = Term.parse_prefix(Term.str)\n return new_term","def from_string(cls, term_string):\n term_string = term_string.replace(\" \", \"\")\n\n if term_string in cls.term_dict:\n return cls.term_dict[term_string]\n\n if term_string[0] == NALSyntax.StatementSyntax.Start.value:\n \"\"\"\n Compound or Statement Term\n \"\"\"\n assert (term_string[-1] == NALSyntax.StatementSyntax.End.value), \"Compound/Statement term must have ending parenthesis: \" + term_string\n\n copula, copula_idx = NALSyntax.Copula.get_top_level_copula(term_string)\n if copula is None:\n # compound term\n term = CompoundTerm.from_string(term_string)\n else:\n term = StatementTerm.from_string(term_string)\n elif NALSyntax.TermConnector.is_set_bracket_start(term_string[0]):\n # set term\n term = CompoundTerm.from_string(term_string)\n elif term_string[0] == NALSyntax.TermConnector.Array.value:\n if NALSyntax.StatementSyntax.ArrayElementIndexStart.value in term_string:\n term = ArrayTermElementTerm.from_string(term_string)\n else:\n term = ArrayTerm.from_string(term_string)\n elif term_string[0] == VariableTerm.VARIABLE_SYM or term_string[0] == VariableTerm.QUERY_SYM:\n # variable term\n dependency_list_start_idx = term_string.find(\"(\")\n if dependency_list_start_idx == -1:\n variable_name = term_string[1:]\n dependency_list_string = \"\"\n else:\n variable_name = term_string[1:dependency_list_start_idx]\n dependency_list_string = term_string[term_string.find(\"(\") + 1:term_string.find(\")\")]\n\n term = VariableTerm.from_string(variable_name=variable_name,\n variable_type_symbol=term_string[0],\n dependency_list_string=dependency_list_string)\n else:\n term_string = re.sub(\",\\d+\", \"\", term_string)\n term = AtomicTerm(term_string)\n\n cls.term_dict[term_string] = term\n\n return term","def make_terms_from_string(s):\n u = s\n return u.split()","def get_subterms(expr):\n av_expr = []\n expr_types = []\n if isinstance(expr, Term):\n if expr.subterms:\n for s in expr.subterms:\n new_av, new_type = get_subterms(s)\n av_expr += new_av\n expr_types += new_type\n new_type = expr.type\n expr_types.append(new_type)\n av_expr.append(expr)\n else:\n av_expr.append(expr)\n expr_types.append(expr.type)\n elif type(expr) != str:\n if expr.term:\n new_av, new_type = get_subterms(expr.term)\n av_expr += new_av\n expr_types += new_type\n return av_expr, expr_types","def parse_term(s, ctx, mctx, ops):\n s = strip_parens(s.strip())\n if re.search(\"^\\w*$\",s): # If a single word, either a variable or a constant\n if s in ops:\n return Con(ops[s], [], ctx, mctx)\n elif s in ctx:\n return Var(s, ctx, mctx)\n elif s in mctx:\n return MVar(s, [], ctx, mctx)\n elif s.startswith(\"O\") and s[1:] in mctx:\n return MVar(s, [], ctx, mctx, is_hole=True)\n else:\n raise Exception(\"Unbound variable: \" + \"'\" + s + \"'\")\n\n elif re.search(\"^\\w*\\[.*\\]$\", s): # If a metavariable\n m = re.search(\"^(\\w)*\\[(.*)\\]$\", s)\n mvar = m.group(1)\n env = m.group(2)\n if not env:\n return MVar(mvar, [], ctx, mctx, is_hole=mvar.startswith(\"O\"))\n else:\n return MVar(mvar, [Term.parse_term(t, ctx, mctx, ops) for t in split_tuple(env)], ctx, mctx)\n\n elif re.search(\"^([\\w ]*)\\.(.*)$\", s): # If a variable under binders\n m = re.search(\"^([\\w ]*)\\.(.*)$\", s)\n bound = m.group(1).split()\n tm = m.group(2)\n return Term.parse_term(tm, bound + ctx, mctx, ops)\n\n elif re.search(\"^(\\w*) *\\((.*)\\)$\", s): # If an expression\n m = re.search(\"^(\\w*) *\\((.*)\\)$\", s)\n op = m.group(1)\n args = m.group(2)\n return Con(ops[op], [Term.parse_term(t, ctx, mctx, ops) for t in split_tuple(args)], ctx, mctx)\n else:\n raise Exception(\"Can't parse: \" + s)","def _parse_sub(self, parsetree, text, fpos=0):\r\n curr = 0\r\n for match in self._reSubstitution.finditer(text):\r\n start = match.start()\r\n if start > curr:\r\n parsetree.append((\"str\", self._reComment.sub('', text[curr:start])))\r\n\r\n if match.group(\"sub\") is not None:\r\n if not match.group(\"end\"):\r\n raise TemplateSyntaxError(\"Missing closing tag '%s' for '%s'.\" \r\n % (self._sub_end, match.group()), self._errpos(fpos+start))\r\n if len(match.group(\"sub\")) > 0:\r\n self._testexpr(match.group(\"sub\"), fpos+start)\r\n parsetree.append((\"sub\", match.group(\"sub\")))\r\n else:\r\n assert(match.group(\"escsub\") is not None)\r\n if not match.group(\"escend\"):\r\n raise TemplateSyntaxError(\"Missing closing tag '%s' for '%s'.\"\r\n % (self._subesc_end, match.group()), self._errpos(fpos+start))\r\n if len(match.group(\"escsub\")) > 0:\r\n self._testexpr(match.group(\"escsub\"), fpos+start)\r\n parsetree.append((\"esc\", self.escape, match.group(\"escsub\")))\r\n\r\n curr = match.end()\r\n\r\n if len(text) > curr:\r\n parsetree.append((\"str\", self._reComment.sub('', text[curr:])))","def parse(s):\n # Use _PARSE_RE to check that it's valid.\n if not CFGProduction._PARSE_RE.match(s):\n raise ValueError, 'Bad production string'\n # Use _SPLIT_RE to process it.\n pieces = CFGProduction._SPLIT_RE.split(s)\n pieces = [p for i,p in enumerate(pieces) if i%2==1]\n lhside = Nonterminal(pieces[0])\n rhsides = [[]]\n for piece in pieces[2:]:\n if piece == '|':\n rhsides.append([]) # Vertical bar\n elif piece[0] in ('\"', \"'\"):\n rhsides[-1].append(piece[1:-1]) # Terminal\n else:\n rhsides[-1].append(Nonterminal(piece)) # Nonterminal\n return [CFGProduction(lhside, rhside) for rhside in rhsides]","def read_tree(cls, string):\n \n # first, remove the brackets ()\n string = string.strip()\n if len(string) == 0:\n raise ValueError(\"empty string cannot be a Synstactic Tree\")\n if string[0] == \"(\" and string[-1] == \")\":\n string = string[1:-1]\n \n # split the string with blank character\n # if the string has exactly or fewer than one element, it cannot be a \n # tree\n # if it has two elements, it must be a tree with a terminal node as the\n # root\n # if it has more than two elements, take the first element as the root\n # and other elements as the branches \n elements = string.split()\n if len(elements) <= 1 or elements[1] == \"\":\n raise ValueError(\"%s cannot be a tree or subtree\" %string)\n else:\n if len(elements) == 2:\n # TODO: if the label comes from CCG parser, turn [] into ()\n root = cls._read_terminal_node(elements)\n else:\n branch_string = \" \".join(elements[1:])\n root = SyntacticNode(elements[0])\n branches = cls._read_branches(branch_string)\n for branch in branches:\n root.add_child(branch._root)\n \n return SyntacticTree(root)","def parse(operators, *term_strs):\n scope = Scope()\n rvs = []\n for ts in term_strs:\n p = Parser(operators, ts, scope)\n try:\n term = p.parse()\n except SyntaxError:\n print 'While parsing: %s' % ts\n raise\n rvs.append(term)\n rvs.append(scope)\n return tuple(rvs)","def parse(string):\n doc = nlp(string)\n return [str(n) for n in doc.noun_chunks]","def parseTerms(fp):\n\n try:\n # match \"Terminais\", with or without a comment etc., using RegEx\n # to know more, search for 'python regular expressions'\n ln = fp.readline()\n p = re.compile(r'^Terminais\\s*(?:#.*)?$')\n m = p.match(ln)\n if m == None:\n raise ParseError(ParseError.termsMsg)\n\n # match and capture \"{ a, b }\" etc.\n ln = fp.readline()\n p = re.compile(r'^\\{\\s*(.*)\\s*\\}\\s*(?:#.*)?$')\n m = p.match(ln)\n if m == None:\n raise ParseError(ParseError.termsMsg)\n\n # split the string by ',', trim spaces and return as a set\n a = m.group(1).split(',') # group(1) contains each captured group\n a[:] = map(str.strip, a) # trim spaces in each element of a\n return set(a) # remove duplicates\n\n except:\n raise","def parse(raw_query, EXPAND_SET = False):\r\n\t\r\n\t# tokenize and tag the query using nltk tools, use .lower() to standardize the input\r\n\ttokenized_query = nltk.word_tokenize(raw_query.lower())\r\n\ttagged_query = nltk.pos_tag(tokenized_query)\r\n\t\r\n\t#master_chunk = r\"Chunk: {(<VB\\w?>|<JJ>*|<RB\\w?>)<DT>?(<NN\\w?>+)}\" \r\n\t\r\n\t\r\n\t# master_chunk now captures prepositional phrase, as they are typically part of one thought.\r\n\t\r\n\tmaster_chunk = r\"Chunk: {((<JJ\\w?>*|<RB\\w?>*)<DT>?(<NN\\w?>+))(<IN>((<JJ>*|<RB\\w?>*)<DT>?(<NN\\w?>+)))*}\" # Regex to identify chunks that may be useful \r\n\t#\t\t\t\t\tmaster_chunk breakdown\r\n\t#\r\n\t#\tFirst half : ((<JJ>*|<RB\\w?>*)<DT>?(<NN\\w?>+))\r\n\t#\t<JJ\\w?>* | <RB\\w>?>* allows an arbitrary number of adjectives to precede the noun\r\n\t# \t\"\\w\" is \"any character\" and allows the capture of all JJ and RB tags, which include JJ, JJR, JJS, RB, RBR, and RBS\r\n\t#\t<DT>? allows for exactly one (1) or zero (0) determiner, often this will capture things like \"no\" and then a noun\r\n\t# \t(<NN\\w>+) captures one (1) or arbitrarily more nouns\r\n\t#\t\r\n\t#\tSecond half: (<IN>((<JJ>*|<RB\\w?>*)<DT>?(<NN\\w?>+)))*\r\n\t#\t<IN> captures prepostions \"of\", \"with\", and so on.\r\n\t# \tThe rest of the expression is the same as the first half \r\n\t# \tThe final * (kleene star) allows zero (0) or more prepositional phrases to be captured\r\n\t\r\n\t\r\n\tmaster_parser = nltk.RegexpParser(master_chunk) # Create the parser from the Regex\r\n\tmaster = master_parser.parse(tagged_query) # Parse the query previously tagged\r\n\t\r\n\tchunk_list = []\r\n\tkeywords = []\r\n\tfor phrase in master:\r\n\t\tif (not isinstance(phrase, tuple)): # all non-chunks are tuples, a chunk is a nltk.tree type\r\n\t\t\tchunk_list.append(phrase)\r\n\t\t\ttmp = \"\"\r\n\t\t\tfor word in phrase: # generate keyword phrases from the chunks\r\n\t\t\t\ttmp += word[0] + \" \"\r\n\t\t\t\r\n\t\t\ttmp = tmp[:-1] # Remove final space\r\n\t\t\tkeywords.append(tmp)\r\n\t\t\t\r\n\tif EXPAND_SET: # defualt is not to expand\r\n\t\t# combine the two lists, using set() to remove any repeated phrases\r\n\t\treturn list(set(generate_keywords(chunk_list) + keywords))\r\n\telse:\r\n\t\treturn keywords","def parse_tree(s):\n return parser.parse(lexer=lexer, input=s)","def parse_formula(formula):\r\n\r\n # Convert the formula string into a list of symbols (parentheses, operators, numbers, cells)\r\n symbols = get_symbols(formula)\r\n\r\n # If formula contains only one symbol, then it must be a cell / number\r\n if len(symbols) == 1:\r\n return parseTree(node=symbols[0])\r\n\r\n # Otherwise Formula contains at least two cells / numbers\r\n # tree is an intially 'empty' parseTree that will be the constructed into the final tree\r\n # tree comes in the form\r\n # None\r\n # / \\\r\n # None None\r\n # / \\\r\n # None None\r\n tree = parseTree(left=parseTree())\r\n\r\n # stack is the stack of nodes (parseTrees) that is currently being traversed,\r\n # starting from the root of tree, but excluding the current node\r\n stack = [tree]\r\n\r\n # current_tree stores the current node that is being dealt with\r\n current_tree = tree.left\r\n\r\n # iterates through each symbol (parenthesis, operator, cell, or number) and constructs tree\r\n for symbol in symbols:\r\n\r\n # If the symbol is an opening parenthesis, then make the left child\r\n # into a parseTree (new independent expression) and traverse into it\r\n if symbol == '(':\r\n # Push the current tree to stack\r\n stack.append(current_tree)\r\n # Make the left child into a parseTree\r\n current_tree.left = parseTree()\r\n # Traverse into the left child\r\n current_tree = current_tree.left\r\n\r\n # If the symbol is a closing parenthesis, then backtrack out of the\r\n # current tree (expression) and into to the previous tree in stack\r\n elif symbol == ')':\r\n # Pop the topmost tree from stack and set current_tree equal to it\r\n current_tree = stack.pop()\r\n\r\n # If the symbol is an operator, then check if this tree's node already\r\n # has an operator\r\n elif symbol in operators:\r\n # If current_tree's node has not been changed yet (None), then set it\r\n # equal to symbol, and then make the right child into a parseTree\r\n # and traverse into it\r\n if current_tree.node == None:\r\n # Set node of current_tree equal to the operator\r\n current_tree.node = symbol\r\n # Push the current tree to stack\r\n stack.append(current_tree)\r\n # Make the right child into a parseTree\r\n current_tree.right = parseTree()\r\n # Traverse into the right child\r\n current_tree = current_tree.right\r\n\r\n # If there is already an operator, then we must check whether or not it has\r\n # a higher precedence than symbol in order to deal with order of operations\r\n else:\r\n # If the existing operator has higher or equal precedence, then \"squeeze\"\r\n # symbol right above current_tree, making symbol its parent\r\n if operators[current_tree.node] >= operators[symbol]:\r\n # Copy current_tree down into its own left child and set its node\r\n # equal to symbol\r\n current_tree.left = copy.deepcopy(current_tree)\r\n current_tree.node = symbol\r\n # Push the current tree to stack\r\n stack.append(current_tree)\r\n # Make the right child into a parseTree\r\n current_tree.right = parseTree()\r\n # Traverse into the right child\r\n current_tree = current_tree.right\r\n\r\n # If symbol has higher precedence, then replace the right child with symbol\r\n # and push the original right child down into the left child of symbol\r\n else:\r\n # Make the right child of current_tree into a new parseTree by moving it down\r\n # into the left child of the new tree and symbol as the node\r\n current_tree.right = parseTree(node=symbol, left=current_tree.right)\r\n # Push the current tree to stack\r\n stack.append(current_tree)\r\n # Traverse into the right child\r\n current_tree = current_tree.right\r\n # Push the new current tree to stack\r\n stack.append(current_tree)\r\n # Make the right child into a parseTree\r\n current_tree.right = parseTree()\r\n # Traverse into the right child once again\r\n current_tree = current_tree.right\r\n\r\n # Otherwise, the symbol must be a cell or a number\r\n else:\r\n # Set node of current_tree equal to the cell/number\r\n current_tree.node = symbol\r\n # Pop the topmost tree from stack and set current_tree equal to it\r\n current_tree = stack.pop()\r\n\r\n # ******************************************************************************\r\n # UNCOMMENT THE FOLLOWING BLOCK OF CODE TO SEE THE TREE BEING BUILT AT EACH STEP\r\n # ******************************************************************************\r\n # tree.display()\r\n # print(\"-----------------------\")\r\n\r\n # Return tree as the final result\r\n return tree","def tree_string_parser(tree_string):\n tree_hash = create_hash(tree_string)\n tree_string = tree_string.replace(\"(\", \"{\")\n tree_string = tree_string.replace(\")\", \"}\")\n tree_string = \"{\" + tree_string + \"}\"\n tree_string = tree_string.replace(\"'\", \"\")\n\n data = re.sub(r'([\\w\\.\\-]+)', r'\"\\1\"', tree_string) # {\"val1\" {\"val2\" {\"d1\" \"d2\" \"d3\"}}}\n data = re.sub(r'\"\\s*{', r'\": {', data) # {\"val1\": {\"val2\": {\"d1\" \"d2\" \"d3\"}}}\n data = re.sub(r'\" \"', r'\", \"', data) # {\"val1\": {\"val2\": {\"d1\", \"d2\", \"d3\"}}}\n data = re.sub(r'{([^{}]*)}', r'[\\1]', data) # {\"val1\": {\"val2\": [\"d1\", \"d2\", \"d3\"]}}\n data = re.sub(r'\\[([\\\"\\:\\, \\w\\.\\-]+:+[\\\"\\:\\, \\w\\.\\-]+)\\]', r'\\1', data)\n data = re.sub(r'({[\\\"\\w\\.\\-]+),', r'\\1: [],', data)\n data = re.sub(r', (\\\"[\\\"\\w\\.\\-]+\\\")}', r', \\1: []}', data)\n data = re.sub(r', (\\\"[\\\"\\w\\.\\-]+\\\"),(?![^\\[]*\\])', r', \\1: [],', data)\n data = re.sub(r', (\\\"[\\\"\\w\\.\\-]+\\\"),(?![^\\[]*\\])', r', \\1: [],', data)\n data = re.sub(r', \\[(.*?)\\]', r', \"ARGS\": [[\\1]]', data)\n try:\n tree_dict = json.loads(data)\n except:\n print(\"Error from json.loads: \" + data)\n try:\n fix_up_tree(tree_dict)\n except:\n print(\"Error from fix_up_tree: \" + data)\n try:\n plot_tree(tree_dict, tree_hash)\n except:\n print(\"Error from plot tree: \" + data)","def get_maths_list(string:str, parent_name:str):\n parse = MathList()\n param_word = True\n prev_char = ''\n \n n = len(string)\n\n has_char = False\n word_added = False\n \n #print()\n #print(\"Decompose:\", string)\n\n i = 0\n word_start = i\n word_end = i\n \n while i < n:\n c = string[i]\n #print(\":\",c, string[word_start:word_end])\n \n if maths_syntax(c):\n if c == ')':\n raise SyntaxError(\"\\nStack Trace: {0}\\nClose bracket has no opening bracket in '{1}'\"\\\n .format(parent_name, string))\n elif c == '(':\n if word_start != word_end:\n if param_word:\n raise SyntaxError(\"\\nStack Trace: {0}\\nUndefined function between two numbers: '{1}'\"\\\n .format(parent_name, string))\n else:\n # add function\n #print(\"Adding operand:\",string[word_start:word_end])\n new_str = string[word_start:word_end]\n parse.add_elem(new_str)\n \n params = False\n #next element cannot be params!\n \n # Read opening bracket sub-syntax\n open_brac_num = 1\n j = i+1\n while open_brac_num > 0 and j < n:\n c = string[j]\n if c == ')':\n open_brac_num -= 1\n else:\n if c == '(':\n open_brac_num += 1\n if open_brac_num != 0:\n j += 1\n \n if j == n:\n raise SyntaxError(\"\\nStack Trace: {0}\\nNo closing bracket for '{1}'\"\\\n .format(parent_name, string))\n else:\n new_string = string[i+1:j]\n sub_list = MathList.get_maths_list(new_string, parent_name)\n parse.add_elem(sub_list)\n i = j\n \n word_start = i+1\n word_end = word_start\n word_added = True\n\n has_char = True\n param_word = False\n \n else:\n has_char = True # allows for -() syntax\n \n if prev_char == exponent and (c =='+' or c == '-'):\n word_end += 1\n else:\n if (c == '-' or c =='+')\\\n and (prev_char == '*' or prev_char == '/' or prev_char == '^'):\n # allows for x*-y syntax\n param_word = True\n \n if param_word:\n #print(\"Adding parametre:\",string[word_start:word_end])\n if word_start == word_end:\n pass # don't add empty/non-parameter\n else:\n new_str = string[word_start:word_end]\n parse.add_elem(new_str)\n \n param_word = False\n word_start = i\n word_end = word_start + 1\n else:\n word_end = i + 1\n\n else:\n \"\"\"\n if is_white_space(c) and word_start == i:\n # if word is set to start at i, but i is a white space, they move to next character\n word_start += 1\n print(\"here\")\n else:\n print(\"there\")\n if not param_word:\n new_str = string[word_start:i]\n parse.add_elem(new_str)\n \n param_word = True\n word_start = i\n \n if not is_white_space(c):\n has_char = True\n \"\"\"\n if is_white_space(c):\n # if is white space add previous word\n if word_start != word_end:\n #print(\"string:\",string[word_start:word_end])\n \"\"\"\n # add previous word\n new_str = string[word_start:word_end]\n parse.add_elem(new_str)\n word_start = i+1\n word_end = word_start\n word_added = True\n \"\"\"\n pass\n else:\n # move to next character, since white space\n word_start += 1\n word_end = word_start\n #print(\"here\")\n else:\n has_char = True\n \n if not param_word:\n #print(\"Adding operand:\",string[word_start:word_end])\n if word_start == word_end:\n pass\n else:\n new_str = string[word_start:word_end]\n parse.add_elem(new_str)\n \n param_word = True\n word_start = i\n word_end = word_start + 1\n word_added = False\n else:\n word_end = i + 1\n \n \n\n i += 1\n prev_char = c\n \n if word_start != word_end:\n new_str = string[word_start:word_end]\n #print(\"new_str:\",new_str)\n parse.add_elem(new_str)\n \n #print(\"P\",parse, \":\",string)\n return parse","def BNF():\n\n sect_begin = Literal(\"{\").suppress()\n sect_end = Literal(\"}\").suppress()\n array_begin = Literal(\"[\").suppress()\n array_end = Literal(\"]\").suppress()\n tag_begin = Literal(\"<\").suppress()\n tag_end = Literal(\">\").suppress()\n eql = Literal(\"=\").suppress()\n dmark = Literal('$').suppress()\n end_data = Literal('$end').suppress()\n prtable = alphanums + r'!$%&*+-./<>?@^_|~'\n int_t = Regex('[-]?\\d+')\n float_t = Regex('-?\\d+\\.\\d*([eE]?[+-]?\\d+)?')\n bool_t = Regex('([Yy]es|[Nn]o|[Tt]rue|[Ff]alse|[Oo]n|[Oo]ff)')\n\n # Helper definitions\n kstr = quotedString.setParseAction(\n removeQuotes) ^ float_t ^ int_t ^ bool_t ^ Word(prtable)\n name = Word(alphas + \"_\", alphanums + \"_\")\n vec = array_begin + delimitedList(\n float_t ^ int_t ^ bool_t ^ Word(prtable) ^ Literal(\"\\n\").suppress() ^\n quotedString.setParseAction(removeQuotes)) + array_end\n sect = name + sect_begin\n tag_sect = name + Group(tag_begin + name + tag_end) + sect_begin\n\n # Grammar\n keyword = name + eql + kstr\n vector = name + eql + vec\n data = Combine(dmark + name) + SkipTo(end_data) + end_data\n #section = Forward()\n sect_def = (sect | tag_sect)\n #input = section | data | vector | keyword\n input = sect_def | data | vector | keyword | sect_end\n #section << sect_def + ZeroOrMore(input) + sect_end\n\n # Parsing actions\n int_t.setParseAction(token_actions.to_int)\n float_t.setParseAction(token_actions.to_float)\n bool_t.setParseAction(token_actions.to_bool)\n keyword.setParseAction(token_actions.to_scalar)\n vector.setParseAction(token_actions.to_array)\n data.setParseAction(token_actions.to_data)\n sect.setParseAction(token_actions.to_section)\n tag_sect.setParseAction(token_actions.to_section)\n sect_end.setParseAction(token_actions.end_of_section)\n\n bnf = ZeroOrMore(input) + StringEnd().setFailAction(\n token_actions.parse_error)\n bnf.ignore(pythonStyleComment)\n\n return Dict(bnf)","def parse(s, tagVocabulary, pre=False):\n n=RootNode(globalTagDict=tagVocabulary)\n n.parse(lex(s, pre))\n return n","def _get_sub_types_of_compositional_types(compositional_type: str) -> Tuple[str, ...]:\n sub_types_list = []\n for valid_compositional_type in (\n SPECIFICATION_COMPOSITIONAL_TYPES + PYTHON_COMPOSITIONAL_TYPES\n ):\n if compositional_type.startswith(valid_compositional_type):\n inside_string = compositional_type[\n compositional_type.index(\"[\") + 1 : compositional_type.rindex(\"]\")\n ].strip()\n while inside_string != \"\":\n do_not_add = False\n if inside_string.find(\",\") == -1: # No comma; this is the last sub-type\n provisional_sub_type = inside_string.strip()\n if (\n provisional_sub_type == \"...\"\n ): # The sub-string is ... used for Tuple, e.g. Tuple[int, ...]\n do_not_add = True\n else:\n sub_type = provisional_sub_type\n inside_string = \"\"\n else: # There is a comma; this MAY not be the last sub-type\n sub_string_until_comma = inside_string[\n : inside_string.index(\",\")\n ].strip()\n if (\n sub_string_until_comma.find(\"[\") == -1\n ): # No open brackets; this is a primitive type and NOT the last sub-type\n sub_type = sub_string_until_comma\n inside_string = inside_string[\n inside_string.index(\",\") + 1 :\n ].strip()\n else: # There is an open bracket'['; this is a compositional type\n try:\n closing_bracket_index = _match_brackets(\n inside_string, inside_string.index(\"[\")\n )\n except SyntaxError:\n raise SyntaxError(\n \"Bad formatting. No matching close bracket ']' for the open bracket at {}\".format(\n inside_string[\n : inside_string.index(\"[\") + 1\n ].strip()\n )\n )\n sub_type = inside_string[: closing_bracket_index + 1].strip()\n the_rest_of_inside_string = inside_string[\n closing_bracket_index + 1 :\n ].strip()\n if (\n the_rest_of_inside_string.find(\",\") == -1\n ): # No comma; this is the last sub-type\n inside_string = the_rest_of_inside_string.strip()\n else: # There is a comma; this is not the last sub-type\n inside_string = the_rest_of_inside_string[\n the_rest_of_inside_string.index(\",\") + 1 :\n ].strip()\n if not do_not_add:\n sub_types_list.append(sub_type)\n return tuple(sub_types_list)\n raise SyntaxError(\n \"{} is not a valid compositional type.\".format(compositional_type)\n )","def parse(start_symbol, text, grammar):\n tokenizer = grammar[' '] + '(%s)'\n\n def parse_sequence(sequence, text):\n result = []\n for atom in sequence:\n tree, text = parse_atom(atom, text)\n if text is None: return Fail\n result.append(tree)\n return result, text\n\n # see 'Speedy Parsing' in lesson 3 for why memo is useful here\n # also, parse_atom is made to be an internal function so that it\n # doesn't have to take grammar, a dictionary (read: mutable object),\n # and hence just has to take two strings, which are mutable types\n # hence, parse_atom can be memoized\n @memo\n def parse_atom(atom, text):\n if atom in grammar: # Non-Terminal: tuple of alternatives\n for alternative in grammar[atom]:\n tree, rem = parse_sequence(alternative, text)\n if rem is not None: return [atom]+tree, rem\n return Fail\n else: # Terminal: match characters against start of text\n m = re.match(tokenizer % atom, text)\n return Fail if not m else (m.group(1), text[m.end():]) # where the text advances in the code\n\n return parse_atom(start_symbol, text)","def tree_build(sv, piece):\r\n if piece==None: return None \r\n # process various string expressions (or triplets without args for conditions and values)\r\n piece=piece[0].strip(Space) if type(piece)==tuple else piece.strip(Space) # convert to string \r\n alphabetic=Alphakwords+sv.Object_list\r\n \r\n # empty expression\r\n if not piece: return None\r\n\r\n # a string between quotes\r\n if piece[0]==Quote and piece[-1]==Quote: return (piece, None, None) # return string as a leaf\r\n \r\n # a protected string: restore without further parsing \r\n key=piece.strip(Special) \r\n if key in sv.Strings: return (Quote+sv.Strings[key]+Quote, None, None) # return string as a leaf\r\n\r\n # a bracketed expression: parse from outer ones on, RECURSIVE\r\n if key in sv.Blocks: return (Obr, tree_build(sv, sv.Blocks[key]), None)\r\n\r\n piece=save_bracketed(sv, piece) # protect outer bracketed expressions from parsing\r\n piece=Space+piece+Space # add Spaces to help detect alphabetic keys \r\n \r\n # PARSE by operator priority and descending order of position \r\n for op_group in Priority_groups+[sv.Object_list]: # ops by priority groups\r\n op_list=find_op(sv, piece, op_group, alphabetic) # detect operators of this group\r\n\r\n for o, op in op_list: # found ops from this group in reverse order of occurrence\r\n\r\n # process comma operator \r\n if o==Comma and o in piece: return make_list(sv, piece) # list will be linear (not a tree). Build RECURSIVE \r\n\r\n # process unary functions and defined objects (all unary operators are alphabetic)\r\n if o in Unary or o in sv.Object: # unary operators (non space-delimited)\r\n if piece.startswith(op): # operator must be at the start (space-delimited)\r\n res=make_unary(sv, piece, o, op)\r\n if res and (not res[1] or o in [Begin, End]):\r\n return special_unary(sv, res) # process special case \r\n return res\r\n \r\n # process binary operators (always lower priority than unary). Build RECURSIVE\r\n elif op in piece:\r\n res=make_binary(sv, piece, o, op) # binary operators (space-delimited)\r\n if res and (not res[1] or o==Isnot):\r\n return special_binary(sv, res) # process special case \r\n return res\r\n\r\n # process other (args and doubly) subscripted objects. Build RECURSIVE\r\n piece=piece.strip(Space)\r\n if Special+Bloc in piece: return make_subscripted(sv, piece) # the object is subscripted / has args\r\n\r\n # when all operators have been processed, only leaves remain\r\n return make_leaf(sv, piece)","def split_tokens(s):\n parts = []\n parens = 0\n for opar, cpar, unquoted, quoted, residue in TOKENS_FINDALL(s):\n if unquoted:\n parts.append(unquoted)\n elif quoted:\n parts.append(quoted[1:-1])\n elif opar:\n parens += 1\n parts.append(opar)\n elif cpar:\n parens -= 1\n parts.append(cpar)\n elif residue == '$':\n if not parens:\n raise ValueError(\"'$' outside parenthesis in %r\" % (s))\n else:\n raise ValueError(residue, s)\n if parens:\n raise ValueError(\"Unbalanced parenthesis in %r\" % (s))\n return parts","def parse(s: str) -> StateFormula:\n tree = PCTL_PARSER.parse(s.replace(\" \", \"\"))\n return PCTLTransformer.transform(tree)","def parse(s):\n return expr.parseString(s, parseAll=True)","def parse_tree_for_sub_component(self, index_1_beg, index_1_end,\n index_2_beg, index_2_end, flag_string):\n \n tempo_2_beg = index_2_beg\n tempo_2_end = index_2_end\n if index_1_beg >= index_2_end:\n index_2_beg = index_1_beg\n index_2_end = index_1_end\n index_1_beg = tempo_2_beg\n index_1_end = tempo_2_end\n\n ## Path-enclosed Tree (PT)\n if flag_string == SUBTREE_PT:\n if index_2_end - index_1_beg > 1:\n subtree_pos = self.tree.treeposition_spanning_leaves( index_1_beg, index_2_end )\n lca = self.tree[subtree_pos]\n no_of_leaves = self.number_of_leaves_before(subtree_pos)\n return Tree.prune_tree(lca, index_1_beg - no_of_leaves, index_2_end - 1 - no_of_leaves)\n else:\n return self.tree[self.tree.treeposition_spanning_leaves( index_1_beg, index_2_end )[:-1]]\n \n ## Minimum Complete Tree (MCT)\n if flag_string == SUBTREE_MCT:\n if index_2_end - index_1_beg > 1:\n lca = self.tree[self.tree.treeposition_spanning_leaves( index_1_beg, index_2_end )]\n else:\n lca = self.tree[self.tree.treeposition_spanning_leaves( index_1_beg, index_2_end )[:-1]]\n return lca\n\n ## Context-Sensitive Path Tree (CSPT)\n if flag_string == SUBTREE_CSPT:\n if index_1_beg > 0:\n index_1_beg -= 1\n if index_2_end < len(self.tree.leaves()) - 1:\n index_2_end += 1\n subtree_pos = self.tree.treeposition_spanning_leaves( index_1_beg, index_2_end )\n lca = self.tree[subtree_pos]\n no_of_leaves = self.number_of_leaves_before(subtree_pos)\n return Tree.prune_tree(lca, index_1_beg - no_of_leaves, index_2_end - 1 - no_of_leaves)\n \n ## Highly-pruned Path Tree (HPPT)\n if flag_string == SUBTREE_HPPT:\n # Get a single path tree that connect \n # the two entities \n return self.get_pruned_tree_path(index_1_beg, index_1_end,\n index_2_beg, index_2_end, True)","def split_citation_part(string: str):\n\n # Tokenization\n\n # fmt: off\n string = regex.sub(\n r\"(\"\n r\"\\d+(?>\\.\\d+)?[a-z]?|\"\n r\"\\b[ivx]+|\"\n r\"\\b[a-z]\\)?\"\n r\")\"\n r\"(\\sff?\\.|\\sff\\b)\",\n r\"\\1ff.\",\n string,\n flags=regex.IGNORECASE,\n )\n # fmt: on\n tokens = split_unit_number_pattern.split(\n string,\n )\n\n # Building pairs of units with their resp. values\n\n while len(tokens) > 0:\n token = tokens.pop(0)\n if StatutesParser.is_unit(token):\n if len(tokens) > 0:\n unit = StatutesParser.stem_unit(token)\n token = tokens.pop(0)\n numb = token\n assert StatutesParser.is_numb(numb), numb\n else: # when citation ends with unit\n print(\n f\"Citation {string} ends with unit {token}. Ignoring last unit.\"\n )\n break\n\n elif StatutesParser.is_pre_numb(token):\n numb = token\n token = tokens.pop(0)\n if not StatutesParser.is_unit(token):\n print(token, \"is not a unit in\", string)\n continue\n # to fix citation \"§ 30 DRITTER ABSCHNITT\"\n # Last part in now ignored,\n # but reference areas can still be improved.\n unit = StatutesParser.stem_unit(token)\n\n elif StatutesParser.is_numb(token):\n unit = None\n numb = token\n else:\n raise StringCaseException(token, \"in\", string)\n numb = regex.sub(r\"(ff?\\.|ff|\\))$\", \"\", numb)\n yield [unit, numb]","def parse(self):\n self.parse_lexical_symbols()\n self.parse_cst()\n self.promote_productions()\n self.parse_color()\n self.check_color_scoping()\n for sym in self.GlobalSymbolDict.values():\n sym.GlobalSymbolDict = self.GlobalSymbolDict\n self.create_root_symbols()\n self.check_for_multiple_roots()","def genCompleteTypes(compoundSig):\n i = 0\n end = len(compoundSig)\n\n def find_end(idx, b, e):\n depth = 1\n while idx < end:\n subc = compoundSig[idx]\n if subc == b:\n depth += 1\n elif subc == e:\n depth -= 1\n if depth == 0:\n return idx\n idx += 1\n\n while i < end:\n c = compoundSig[i]\n\n if c == '(':\n x = find_end(i + 1, '(', ')')\n yield compoundSig[i:x + 1]\n i = x\n\n elif c == '{':\n x = find_end(i + 1, '{', '}')\n yield compoundSig[i:x + 1]\n i = x\n\n elif c == 'a':\n g = genCompleteTypes(compoundSig[i + 1:])\n ct = next(g)\n i += len(ct)\n yield 'a' + ct\n\n else:\n yield c\n i += 1","def _parse_unground_propositions(self, array):\n prop_list = []\n if array[0:3] == ['(', 'and', '(']:\n array = array[2:-1]\n #Split array into blocks\n opencounter = 0\n prop = []\n for word in array:\n if word == '(':\n opencounter += 1\n if word == ')':\n opencounter -= 1\n prop.append(word)\n if opencounter == 0:\n prop_list.append(self._parse_unground_proposition(prop))\n prop = []\n #print array[:array.index(')') + 1]\n return prop_list","def tokens_from_treestring(s):\n return re.sub(r\"\\([0-9] |\\)\", \"\", s).split()","def parse_nested_lists(s_in, init=True):\n s_in = s_in.strip() \n if init and ('[' != s_in[0] or ']' != s_in[-1]): \n raise TypeError(\"%s is not a nested list\" % s_in) \n elif init: s_in = s_in[1:-1] \n\n if '[' not in s_in: return [type_check.eval_type(i) for i in s_in.split(\",\")]\n s_in = s_in + \",\" \n lists = [] \n count=0 \n start, end=s_in.find('['), 0 \n for i, c in enumerate(s_in): \n if c == '[': count += 1 \n elif c == ']': count -= 1 \n \n if count == 0 and c == ',': \n new_l = s_in[start:i].strip() \n if new_l[0] == '[': new_l = new_l[1:] \n if new_l[-1] == ']': new_l = new_l[:-1] \n lists.append(parse_nested_lists(new_l, False)) \n start = s_in[i:].find(\",\") + i + 1 \n \n return lists","def parser(ICDfile):\n terms = defaultdict(set)\n relationships = set()\n definitions = defaultdict()\n ICDfile = ICDfile[0]\n #version = ICDfile.split('/')[1].split('_')[1]\n first = True\n with open(ICDfile, 'r') as fh:\n for line in fh:\n if first:\n first = False\n continue\n data = line.rstrip(\"\\r\\n\").split(\"\\t\")\n icdCode = data[0]\n icdTerm = data[1]\n chapter = data[2]\n chapId = data[3]\n block = data[4]\n blockId = data[5]\n\n terms[icdCode].add(icdTerm)\n definitions[icdCode] = \"term\"\n terms[chapId].add(chapter)\n definitions[chapId] = \"chapter\"\n terms[blockId].add(block)\n definitions[blockId] = \"block\"\n\n if len(icdCode) > 3:\n order = len(icdCode) - 1\n i = 3\n while i <= order:\n if icdCode[0:i] in terms:\n relationships.add((icdCode, icdCode[0:i], \"HAS_PARENT\"))\n i += 1\n\n relationships.add((icdCode, chapId, \"HAS_PARENT\"))\n relationships.add((icdCode, blockId, \"HAS_PARENT\"))\n relationships.add((blockId, chapId, \"HAS_PARENT\"))\n\n return terms, relationships, definitions","def parse(self, string, top_rule=None):\n inputter = Inputter(string)\n rule = self.top_rule if top_rule == None else self.rule_dict[top_rule]\n return rule.parse(inputter)","def substrings(s):\n if s:\n yield from prefixes(s) # 获得当前s的所有prefix\n yield from substrings(s[1:])","def subparse(block):\n\n verses = []\n context = None\n for char in block:\n\n if char == \"[\":\n if verses: verses[-1][\"quran\"] = verses[-1][\"quran\"].strip()\n verses.append({\"surah\": \"\", \"verse\": \"\", \"quran\": \"\"})\n context = \"surah\"\n elif char == \":\" and context == \"surah\":\n verses[-1][\"surah\"] = int(verses[-1][\"surah\"])\n context = \"verse\"\n elif char == \"]\":\n verses[-1][\"verse\"] = int(verses[-1][\"verse\"])\n context = \"quran\"\n else: verses[-1][context] += char\n\n verses[-1][\"quran\"] = verses[-1][\"quran\"].strip()\n return verses","def parse_sexprs(ppddl_txt):\n tokens = _ppddl_tokenize(ppddl_txt)\n parse_root = parse_ptr = HList(None)\n # we parse begin -> end\n # just reverse so that pop() is efficient\n tokens_reverse = tokens[::-1]\n while tokens_reverse:\n token = tokens_reverse.pop()\n if token == '(':\n # push\n new_ptr = HList(parse_ptr)\n parse_ptr.append(new_ptr)\n parse_ptr = new_ptr\n elif token == ')':\n # pop\n parse_ptr = parse_ptr.parent\n else:\n # add\n parse_ptr.append(token)\n return parse_root","def get_compound_noun( ngram ):\n try:\n pattern = re.compile( '((?: ?\\\\b[^\\\\s]+(?:/NN.?/[a-z]+/[\\\\d]+)){2,})' )\n match = re.search( pattern, ngram )\n if match:\n compound = ''\n contains_root = False\n tokens = match.group().strip().split(' ')\n for t in tokens:\n # embed()\n items = t.split('/')\n compound += ( items[0] + ' ' )\n if items[3] == 0:\n contains_root = True\n if contains_root:\n return compound\n else:\n return None\n else:\n return None\n \n except ValueError:\n return None","def _parseString(self, instring):\n\n if self._compiled is None:\n self.compile()\n\n match = self._compiled.match(instring)\n if match is None:\n return None\n\n Count.reset()\n struct = deepcopy(self.structure)\n\n mymatch, substructs, preprocess_func = self._parse_preprocess(match)\n struct.map(preprocess_func)\n struct.map(self._func_parse_leaf(mymatch, substructs))\n struct.parse_end = match.end()\n return struct","def parse_formula(formula, periodic_table_dict):\n assert isinstance(formula, str), \\\n \"wrong data type for parameter formula; \" \\\n f\"formula is a {type(formula)} but must be a string\"\n assert isinstance(periodic_table_dict, dict), \\\n \"wrong data type for parameter periodic_table_dict; \" \\\n f\"periodic_table_dict is a {type(periodic_table_dict)} \" \\\n \"but must be a dictionary\"\n\n def parse_quant(formula, index):\n quant = 1\n if index < len(formula) and formula[index].isdecimal():\n if formula[index] == \"0\":\n raise FormulaError(\"invalid formula, \"\n \"quantity begins with zero (0), perhaps \"\n \"you meant to type capital O for Oxygen \"\n \"instead of zero\", formula, index)\n start = index\n index += 1\n while index<len(formula) and formula[index].isdecimal():\n index += 1\n quant = int(formula[start:index])\n return quant, index\n\n def get_quant(elem_dict, symbol):\n return 0 if symbol not in elem_dict else elem_dict[symbol]\n\n def parse_r(formula, index, level):\n start_index = index\n start_level = level\n elem_dict = {}\n while index < len(formula):\n ch = formula[index]\n if ch == \"(\":\n group_dict, index = parse_r(formula,index+1,level+1)\n quant, index = parse_quant(formula, index)\n for symbol in group_dict:\n prev = get_quant(elem_dict, symbol)\n curr = prev + group_dict[symbol] * quant\n elem_dict[symbol] = curr\n elif ch.isalpha():\n symbol = formula[index:index+2]\n if symbol in periodic_table_dict:\n index += 2\n else:\n symbol = formula[index:index+1]\n if symbol in periodic_table_dict:\n index += 1\n else:\n raise FormulaError(\"invalid formula; \"\n f\"unknown element symbol: {symbol}\",\n formula, index)\n quant, index = parse_quant(formula, index)\n prev = get_quant(elem_dict, symbol)\n elem_dict[symbol] = prev + quant\n elif ch == \")\":\n if level == 0:\n raise FormulaError(\"invalid formula; \"\n \"unmatched close parenthesis\",\n formula, index)\n level -= 1\n index += 1\n break\n else:\n if ch.isdecimal():\n # Decimal digit not preceded by an\n # element symbol or close parenthesis\n message = \"invalid formula\"\n else:\n # Illegal character: [^()0-9a-zA-Z]\n message = \"invalid formula; \" + \\\n f\"illegal character: {ch}\"\n raise FormulaError(message, formula, index)\n if level > 0 and level >= start_level:\n raise FormulaError(\"invalid formula; \"\n \"unmatched open parenthesis\",\n formula, start_index - 1)\n return elem_dict, index\n\n # Return the compound list of element symbols and\n # quantities. Each element in the compound list\n # will be a list in this form: [\"symbol\", quantity]\n elem_dict, _ = parse_r(formula, 0, 0)\n return list(elem_dict.items())","def parse_tags(source):\n unmatched_count = 0\n start_pos = 0\n opened = False\n open_pos = 0\n cur_pos = 0\n\n finished = []\n segments = []\n\n for character in source:\n #scan for mismatched parenthesis:\n if character == '(':\n unmatched_count += 1\n if not opened:\n open_pos = cur_pos\n opened = True\n\n if character == ')':\n unmatched_count -= 1\n\n if opened and unmatched_count == 0:\n clean = source[start_pos:open_pos]\n clean = clean.strip()\n if clean:\n finished.extend(clean.split())\n\n segment = source[open_pos:cur_pos+1]\n #segments.append(segment)\n \n #get rid of bounding parentheses:\n pruned = segment[1:-1]\n group = pruned.split()\n finished.append(group)\n\n opened = False\n start_pos = cur_pos+1\n \n cur_pos += 1\n\n assert unmatched_count == 0\n\n if start_pos != cur_pos:\n #get anything that was left over here\n remainder = source[start_pos:cur_pos].strip()\n finished.extend(remainder.split())\n \n ## #now check on recursion:\n ## for item in segments:\n ## #get rid of bounding parentheses:\n ## pruned = item[1:-1]\n ## if recurse:\n ## results = parse_tags(pruned, recurse)\n ## finished.expand(results)\n ## else:\n ## finished.append(pruned.strip())\n \n return finished","def expand_to_valid_structure(string, beg, end, fst, snd):\n assert 0 <= beg <= end <= len(string)\n\n beg_level, end_level = find_nesting_levels(string, beg, end, fst, snd)\n\n # First find nbeg\n i = beg - 1\n if beg_level == 0:\n nbeg = beg\n else:\n nbeg = None\n while i >= 0:\n if string[i] == fst:\n if beg_level > 0:\n beg_level -= 1\n else:\n nbeg = i\n break\n elif string[i] == snd:\n beg_level += 1\n i -= 1\n\n # Then find nend\n i = end\n if end_level == 0:\n nend = end\n else:\n nend = None\n while i < len(string):\n if string[i] == snd:\n if end_level > 0:\n end_level -= 1\n else:\n nend = i + 1\n break\n elif string[i] == fst:\n end_level += 1\n i += 1\n\n if nbeg != None and nend != None:\n return Interval(nbeg, nend)","def parse_maths_string(string:str, parent_name:str, variables:dict):\n if string == \"\":\n return None\n maths_tree = MathTree.construct_tree(string, parent_name, variables)\n \n val = maths_tree.get_tree_value(parent_name)\n #print(\"String:\",string)\n #print(\"Maths Tree:\", maths_tree)\n #print(\"result:\",val)\n #print()\n \n return val","def parse(string):\n \n global local_vars\n print \"parse(\"+string+\")\"\n\n # variables\n if string in local_vars: # e.g. 'y'\n return string\n elif string == 'it':\n # print 'it: ',references[0]\n return g.it\n\n # operators\n elif string.find('\\gamma') == 0:\n return gamma(string[7],string[9:-1])\n elif string.find('\\iota') == 0:\n # treating iota as gamma for now\n return iota(string[6],string[8:-1])\n\n # function application\n else:\n fun = string.split( '(' , 1)[0]\n arg = parse(string.split( '(' , 1)[1][:-1])\n exec(fun+'(arg)')","def parse(string):\r\n \r\n global local_vars\r\n # print \"parse(\"+string+\")\"\r\n\r\n # variables\r\n if string in local_vars: # e.g. 'y'\r\n return string\r\n elif string == 'it':\r\n # print 'it: ',references[0]\r\n return g.it\r\n\r\n # operators\r\n elif string.find('\\gamma') == 0:\r\n return gamma(string[7],string[9:-1])\r\n elif string.find('\\iota') == 0:\r\n # treating iota as gamma for now\r\n return iota(string[6],string[8:-1])\r\n\r\n # function application\r\n else:\r\n fun = string.split( '(' , 1)[0]\r\n arg = parse(string.split( '(' , 1)[1][:-1])\r\n exec(fun+'(arg)')","def getNodeTreeFromStr(string):\n document = publish_doctree(string)\n\n return list([node for node in document.traverse()[1:] if node.parent == document]) # we've to return the chidren of the document, as returning the document itself, seems to duplicate the content of the current file being processed.","def _parse_query(queryStr):\n mainNode = LogicNode.LogicNode()\n queryStr = queryStr.replace(' ','')\n \n logicList, myOPList = _break_query(queryStr)\n\n #converts operator strings to actual operators\n convertOp = {\n '&':operator.and_,\n '|':operator.or_,\n '^':operator.xor\n }\n\n for item in myOPList:\n mainNode.operators.append(convertOp[item])\n \n #adds the simple comparisons to the LogicNode\n mainNode.add_children(logicList)\n return mainNode","def parse_logic(logic):\n\n ###print \"parse_logic(logic): logic:\",logic\n\n tokens = logic.split()\n\n # begin recursive logic parse\n return grammar_0(tokens)","def getleaf(tre_str):\n leaves = []\n tmp = tre_str.split(\",\")\n for i in tmp:\n i = i.replace(\"(\", \"\").replace(\")\", \"\").replace(\":\", \"\")\n if \"_\" in i:\n if \" \" in i:\n leaves.append(i.strip().split()[0])\n else:\n leaves.append(i)\n return leaves","def parse_tags(tagstring):\n if not tagstring:\n return []\n\n tagstring = force_str(tagstring)\n\n words = []\n buffer = []\n # Defer splitting of non-quoted sections until we know if there are\n # any unquoted commas.\n to_be_split = []\n i = iter(tagstring)\n try:\n while True:\n c = six.next(i)\n if c == '\"':\n if buffer:\n to_be_split.append(''.join(buffer))\n buffer = []\n c = six.next(i)\n while c != '\"':\n buffer.append(c)\n c = six.next(i)\n if buffer:\n word = ''.join(buffer).strip()\n if word:\n words.append(word)\n buffer = []\n else:\n buffer.append(c)\n except StopIteration:\n # If we were parsing an open quote which was never closed treat\n # the buffer as unquoted.\n if buffer:\n to_be_split.append(''.join(buffer))\n if to_be_split:\n for chunk in to_be_split:\n words.extend(split_strip(chunk, settings.TAGGIT_SELECTIZE['DELIMITER']))\n words = list(set(words))\n words.sort()\n return words","def parseComposite(s):\n\n answerlist = []\n try:\n RespDict = json.loads(s)\n except:\n return None\n for records in RespDict[\"Response\"]:\n if('Type' in records):\n for record in records[\"Response\"]:\n if(record is None):\n continue\n if(records['Type'] == 'T'):\n if (record[\"Selected\"] is True):\n if (record['val'].find(\"<math\") != -1):\n value = MathMLExtraction(record[\"val\"])\n else:\n value=record['val']\n answerlist.append(\"{}-{}\".format(records[\"PartId\"], value))\n elif(records['Type'] == 'MATCHMS'):#MatchMS\n value=\"{}-{}\".format(record['source'], record['target'])\n answerlist.append(\"{}-{}\".format(records[\"PartId\"], value))\n elif(records['Type']=='MCSS' or records['Type'] == 'MCMS' or records['Type'] == 'MAPMS' or\n records['Type'] == 'MAPSS' or records['Type'] == 'InlineChoices'):\n #MAPMS and MAPSS look the same as MCMS and MCSS\n if (record[\"Selected\"] is True):\n if (record[\"val\"] == \"\"):\n value='X'\n else:\n value=record[\"val\"]\n answerlist.append(\"{}-{}\".format(records[\"PartId\"], value))\n else:\n warnings.warn(\"Type is missing for Part ID\", records['PartId'])\n continue\n return answerlist","def deserialize(st: str, words: Optional[List] = None, convert_underscores: bool = True) -> Tuple[TreeNode, List]:\n tree_stack = []\n current_depth = 0\n last_token = ''\n root = TreeNode()\n tree_stack.append((root, current_depth))\n next_is_distance = False\n\n combo = []\n my_stack = []\n my_stack.append((combo, current_depth))\n\n for token in _tokenize_newick(st, convert_underscores=convert_underscores):\n # Check for a label\n if last_token not in '(,):':\n val = Sequence(words[int(last_token)]) if words else int(last_token)\n if not next_is_distance:\n tree_stack[-1][0].name = val if last_token else None\n else:\n next_is_distance = False\n if last_token:\n my_stack[-1][0].append(val)\n else:\n my_stack[-1][0].append(None)\n\n # Check for a distance\n if token == ':':\n next_is_distance = True\n elif last_token == ':':\n try:\n tree_stack[-1][0].length = float(token)\n except ValueError:\n raise NewickFormatError(\"Could not read length as numeric type\"\n \": %s.\" % token)\n elif token == '(':\n current_depth += 1\n tree_stack.append((TreeNode(), current_depth))\n my_stack.append((list(), current_depth))\n elif token == ',':\n tree_stack.append((TreeNode(), current_depth))\n my_stack.append((list(), current_depth))\n elif token == ')':\n if len(tree_stack) < 2:\n raise NewickFormatError(\"Could not parse file as newick.\"\n \" Parenthesis are unbalanced.\")\n children = []\n my_children = []\n # Pop all nodes at this depth as they belong to the remaining\n # node on the top of the stack as children.\n while current_depth == tree_stack[-1][1]:\n node, _ = tree_stack.pop()\n children.insert(0, node)\n nc, _ = my_stack.pop()\n [my_children.insert(0, c) for c in nc]\n parent = tree_stack[-1][0]\n my_parent = my_stack[-1][0]\n\n if parent.children:\n raise NewickFormatError(\"Could not parse file as newick.\"\n \" Contains unnested children.\")\n # This is much faster than TreeNode.extend\n for child in children:\n child.parent = parent\n parent.children = children\n\n my_parent.append(my_children)\n\n current_depth -= 1\n elif token == ';':\n if len(tree_stack) == 1:\n return root, my_stack\n break\n\n last_token = token\n\n raise NewickFormatError(\"Could not parse file as newick.\"\n \" `(Parenthesis)`, `'single-quotes'`,\"\n \" `[comments]` may be unbalanced, or tree may be\"\n \" missing its root.\")","def search_productions(citem, chart):\n if len(chart[citem]) == 0:\n return [] \n if citem == \"START\":\n return [{\"START\":child[0]} for child in chart[citem]]\n \n prodlist = list(chart[citem])\n lefts = set(x[0] for x in prodlist)\n lengths = set(len(x) for x in prodlist)\n assert len(lengths) == 1\n split_len = lengths.pop()\n \n # figure out all items that could have been used to complete this nonterminal \n result = [] \n if prodlist[0][0].target == Item.NONTERMINAL:\n assert split_len == 2\n symbol = prodlist[0][0].outside_symbol, prodlist[0][0].outside_index\n for child in prodlist: \n assert child[1].target == Item.ROOT\n other_nts = search_productions(child[0], chart) \n if other_nts:\n for option in other_nts:\n d = dict(option)\n d[symbol] = child[1]\n result.append(d)\n else:\n result.append(dict([(symbol, child[1])]))\n return result\n \n elif prodlist[0][0].target == Item.BINARY:\n assert split_len == 2\n for child in prodlist: \n assert len(child) == 2\n r1 = search_productions(child[0], chart)\n r2 = search_productions(child[1], chart)\n if r1 and r2: #possibilities: all combinations of assignments to NTs in the subtree\n other_iterator = itertools.product(r1,r2)\n for p1, p2 in other_iterator:\n nts = dict(p1)\n nts.update(p2)\n result.append(nts)\n else: # Only one of the subtrees has nonterminals. \n result.extend(r1)\n result.extend(r2)\n return result \n\n elif prodlist[0][0].target == Item.TERMINAL:\n for child in prodlist: \n assert len(child) == 1\n other_nts = search_productions(child[0], chart)\n if other_nts:\n result.extend(other_nts)\n return result","def build_subtoken_index(self):\n terms = []\n with open(self.path_token_terms, 'r', encoding='utf8') as f:\n for line in f:\n term = line.strip('\\n')\n terms.append(term)\n terms = set(terms)\n for term in terms:\n term_list = term.split('_')\n subterms = get_sublists(term_list)\n self.subtoken_index[term] = [t for t in subterms\n if '_'.join(t) in terms]","def parse_lisp_helper(lisp_code, start_index):\n assert lisp_code[start_index] == \"(\"\n first_closing_paren = lisp_code.find(\")\", start_index)\n next_opening_paren = lisp_code.find(\"(\", start_index+1)\n\n # base case, no more opening paren\n if next_opening_paren < 0 or next_opening_paren > first_closing_paren:\n return split_and_cast(lisp_code[start_index+1:first_closing_paren], \" \"), \\\n first_closing_paren\n\n # inductive case\n ast = split_and_cast(lisp_code[start_index+1: next_opening_paren], \" \")\n while next_opening_paren > 0 and lisp_code[first_closing_paren:]: \n sub_ast, first_closing_paren = parse_lisp_helper(lisp_code,\n next_opening_paren)\n ast.append(sub_ast)\n next_opening_paren = lisp_code.find(\"(\", first_closing_paren+1)\n\n # add all the scalar values between the closing bracket, and next\n # opening bracket\n if next_opening_paren > 0 and next_opening_paren > first_closing_paren:\n values = split_and_cast(lisp_code[first_closing_paren+1:next_opening_paren], \" \")\n ast.extend(values)\n\n\n # now finish parsing everything else after the last set of parens\n if first_closing_paren > -1:\n next_closing_paren = lisp_code.find(\")\", first_closing_paren+1)\n ast.extend(split_and_cast(lisp_code[first_closing_paren+1:next_closing_paren], \\\n \" \"))\n else:\n next_closing_paren = len(lisp_code)\n\n return ast, next_closing_paren","def parse_expression(\n root: typing.Optional[Sequence],\n text: str,\n end: typing.List[str] = None,\n is_literal=True,\n) -> typing.Optional[int]:\n end = end or []\n found: bool = False\n next_index: int = 0\n literal: str = \"\"\n last_taggable: typing.Optional[Taggable] = None\n last_group: typing.Optional[Sequence] = root\n\n # Process text character-by-character\n for current_index, c in enumerate(text):\n if current_index < next_index:\n # Skip ahread\n current_index += 1\n continue\n\n # Get previous character\n if current_index > 0:\n last_c = text[current_index - 1]\n else:\n last_c = \"\"\n\n next_index = current_index + 1\n\n if c in end:\n # Found end character of expression (e.g., ])\n next_index += 1\n found = True\n break\n\n if (c == \":\") and (last_c in [\")\", \"]\"]):\n # Handle sequence substitution\n assert isinstance(last_taggable, Substitutable)\n next_index = parse_expression(\n None, text[current_index + 1 :], end=[\" \"] + end, is_literal=False\n )\n\n if next_index is None:\n # End of text\n next_index = len(text) + 1\n else:\n next_index += current_index - 1\n\n last_taggable.substitution = text[current_index + 1 : next_index].strip()\n\n elif c in [\"<\", \"(\", \"[\", \"{\", \"|\"]:\n # Begin group/tag/alt/etc.\n\n # Break literal here\n literal = literal.strip()\n if literal:\n assert last_group is not None\n words = list(split_words(literal))\n last_group.items.extend(words)\n\n last_taggable = words[-1]\n literal = \"\"\n\n if c == \"<\":\n # Rule reference\n assert last_group is not None\n rule = RuleReference()\n next_index = current_index + parse_expression(\n None, text[current_index + 1 :], end=[\">\"], is_literal=False\n )\n\n rule_name = text[current_index + 1 : next_index - 1]\n if \".\" in rule_name:\n # Split by last dot\n last_dot = rule_name.rindex(\".\")\n rule.grammar_name = rule_name[:last_dot]\n rule.rule_name = rule_name[last_dot + 1 :]\n else:\n # Use entire name\n rule.rule_name = rule_name\n\n rule.text = text[current_index:next_index]\n last_group.items.append(rule)\n last_taggable = rule\n elif c == \"(\":\n # Group (expression)\n assert last_group is not None\n group = Sequence(type=SequenceType.GROUP)\n next_index = current_index + parse_expression(\n group, text[current_index + 1 :], end=[\")\"]\n )\n\n group = unwrap_sequence(group)\n group.text = text[current_index + 1 : next_index - 1]\n last_group.items.append(group)\n last_taggable = group\n elif c == \"[\":\n # Optional\n # Recurse with group sequence to capture multi-word children.\n optional_seq = Sequence(type=SequenceType.GROUP)\n next_index = current_index + parse_expression(\n optional_seq, text[current_index + 1 :], end=[\"]\"]\n )\n\n optional_seq = unwrap_sequence(optional_seq)\n optional = Sequence(type=SequenceType.ALTERNATIVE)\n if optional_seq.items:\n if (\n (len(optional_seq.items) == 1)\n and (not optional_seq.tag)\n and (not optional_seq.substitution)\n ):\n # Unpack inner item\n inner_item = optional_seq.items[0]\n optional.items.append(inner_item)\n elif optional_seq.type == SequenceType.ALTERNATIVE:\n # Unwrap inner alternative\n optional.items.extend(optional_seq.items)\n else:\n # Keep inner group\n optional_seq.text = text[current_index + 1 : next_index - 1]\n optional.items.append(optional_seq)\n\n # Empty alternative\n optional.items.append(Word(text=\"\"))\n optional.text = text[current_index + 1 : next_index - 1]\n last_group.items.append(optional)\n last_taggable = optional\n elif c == \"{\":\n assert last_taggable is not None\n tag = Tag()\n\n # Tag\n next_index = current_index + parse_expression(\n None, text[current_index + 1 :], end=[\"}\"], is_literal=False\n )\n\n # Exclude {}\n tag.tag_text = text[current_index + 1 : next_index - 1]\n\n if \":\" in tag.tag_text:\n lhs, rhs = tag.tag_text.split(\":\", maxsplit=1)\n tag.tag_text = lhs\n tag.substitution = rhs\n\n last_taggable.tag = tag\n elif c == \"|\":\n assert root is not None\n if root.type != SequenceType.ALTERNATIVE:\n # Create alternative\n alternative = Sequence(type=SequenceType.ALTERNATIVE)\n if len(root.items) == 1:\n # Add directly\n alternative.items.append(root.items[0])\n else:\n # Wrap in group\n last_group = Sequence(type=SequenceType.GROUP, items=root.items)\n alternative.items.append(last_group)\n\n # Modify original sequence\n root.items = [alternative]\n\n # Overwrite root\n root = alternative\n\n if not last_group.text:\n # Fix text\n last_group.text = \" \".join(item.text for item in last_group.items)\n\n # Create new group for any follow-on expressions\n last_group = Sequence(type=SequenceType.GROUP)\n alternative.items.append(last_group)\n else:\n # Accumulate into current literal\n literal += c\n\n # End of expression; Break literal.\n literal = literal.strip()\n if is_literal and literal:\n assert root is not None\n words = list(split_words(literal))\n last_group.items.extend(words)\n\n if last_group:\n if len(last_group.items) == 1:\n # Simplify final group\n root.items[-1] = last_group.items[0]\n elif not last_group.text:\n # Fix text\n last_group.text = \" \".join(item.text for item in last_group.items)\n\n if end and (not found):\n # Signal end not found\n return None\n\n return next_index","def parse_string(self, in_str):\n match = MAIN_REGEX.search(in_str)\n if not match:\n err_str = \"Unable to parse string: %s\" % in_str\n raise ValueError(err_str)\n self.parse_completed(match.group(1))\n self.parse_priority(match.group(2))\n if match.group(3) and match.group(4):\n self.parse_completion_date(match.group(3))\n self.parse_creation_date(match.group(4))\n else:\n self.parse_creation_date(match.group(3))\n self.parse_description(match.group(5))","def parse_string(str_value):\n comps = str_value.split(\"/\")\n assert len(comps) <= 2, \"Cannot parse {0} as Rational\".format(str_value) \n \n num_string = comps[0].strip()\n if (len(comps) == 1):\n return Rational(int(num_string))\n else:\n den_string = comps[1].strip()\n return Rational(int(num_string), int(den_string))","def parse_expression(str_expression):\n expression = convert_to_postfix(str_expression)\n var_count = count_arguments(str_expression)\n table = init_table(var_count)\n parsed_table = [[] for i in range(len(table))]\n\n for token in expression:\n for i, row in enumerate(table):\n if token in string.ascii_uppercase:\n parsed_table[i].append(row[ord(token) - 65])\n else:\n parsed_table[i].append(token)\n\n for i, row in enumerate(parsed_table):\n table[i].append(solve(row))\n\n return table","def opsplit(expstr):\n\n #ops are the one char operators (sorted on precidence)\n ops = expr.getOps()\n #Remove outer parentesis if we have them\n if expstr[0] == '(' and expstr[-1] == ')' and balanced(expstr[1:-1]):\n expstr = expstr[1:-1]\n #Add a '0' to the beginning of the string if we start with an operator\n if expstr[0] in ops:\n expstr = '0'+expstr\n for op in ops:\n pc = 0\n cc = len(expstr)-1\n revexpstr = list(expstr)\n revexpstr.reverse()\n #Search for the operator backwards (to preserve operator presidence)\n for c in revexpstr:\n if c == '(':\n pc += 1\n elif c == ')':\n pc -= 1\n if c == op and pc == 0:\n #Build the tree recursively\n return [op,opsplit(expstr[:cc]),opsplit(expstr[cc+1:])]\n cc -=1\n #if we find something that looks like a function, parse it separately \n if funcpattern(expstr):\n fnamestr = funcname(expstr)\n fargs = funcargs(expstr)\n farglist = [opsplit(arg) for arg in fargs]\n return [fnamestr]+farglist\n return expstr","def search_in_tree(self, tree, substring):\n s_options_for_match = set()\n node = tree\n idx = 0\n substring_length = len(substring)\n while idx < substring_length and len(node[substring[idx]]) != 0:\n node = node[substring[idx]]\n s_options_for_match.update(node['end'])\n idx += 1\n if idx == substring_length:\n s_options_for_match.update(node['part'])\n\n return s_options_for_match","def _parse_ins_string(string):\n istart_markers = set([\"[\", \"(\", \"!\"])\n marker_dict = {\"[\": \"]\", \"(\": \")\", \"!\": \"!\"}\n # iend_markers = set([\"]\",\")\",\"!\"])\n setdum = {\"dum\", \"DUM\"}\n obs_names = []\n slen = len(string)\n idx = 0\n while True:\n if idx >= slen - 1:\n break\n char = string[idx]\n if char in istart_markers:\n # em = iend_markers[istart_markers.index(char)]\n em = marker_dict[char]\n # print(\"\\n\",idx)\n # print(string)\n # print(string[idx+1:])\n # print(string[idx+1:].index(em))\n # print(string[idx+1:].index(em)+idx+1)\n eidx = min(slen, string.find(em, idx + 1))\n obs_name = string[idx + 1 : eidx]\n if obs_name not in setdum:\n obs_names.append(obs_name)\n idx = eidx + 1\n else:\n idx += 1\n return obs_names","def sub_tag(str):\n bracketed_tag = r\"(\\${\" + tag_start_char + tag_char + r\"*})\"\n m = re.search(bracketed_tag, str)\n if m:\n tag = m.group(1)\n tag = tag[2:len(tag)-1]\n if tag not in tag_xpath:\n raise ConversionError(\"Undefined tag in ${} substitution\", tag)\n single_replace = str[:m.start()] + tag_xpath[tag] + str[m.end():]\n return sub_tag(single_replace)\n else:\n return str","def find_bracket_group(input_string, start):\n return find_closure_group(input_string, start, group=[\"{\", \"}\"])","def lexer(string): # TODO: refactor\n parsedlist = []\n parsedstring = ''\n leftbcounter = 0\n rightbcounter = 0\n qcounter = 0\n for index, a in enumerate(string):\n if qcounter == 2:\n if a.isalpha():\n qcounter = 1\n else:\n qcounter = 0\n if a == '(':\n leftbcounter += 1\n if a == ')':\n rightbcounter += 1\n if a == \"'\" and leftbcounter == rightbcounter:\n qcounter += 1\n if a != ' ' and leftbcounter == rightbcounter \\\n and qcounter == 0:\n parsedstring += a\n if index+1 == len(string):\n parsedlist.append(parsedstring)\n parsedstring = ''\n elif leftbcounter != rightbcounter:\n parsedstring += a\n elif qcounter > 0:\n parsedstring += a\n if index+1 == len(string):\n parsedlist.append(parsedstring)\n parsedstring = ''\n else:\n parsedlist.append(parsedstring)\n parsedstring = ''\n if leftbcounter != rightbcounter:\n raise BadRequest()\n bl = []\n sl = []\n counter = 0\n for index, query in enumerate(parsedlist, 1):\n if query == \"and\" or query == \"or\" or query == \"not\":\n if sl:\n bl.append(sl)\n bl.append([query])\n counter = 0\n sl = []\n continue\n sl.append(query)\n counter += 1\n if index == len(parsedlist) and sl:\n bl.append(sl)\n # i later added a third nested list to seperate AND and OR\n query_list = []\n al = []\n counter = 0\n for index, grouped_query in enumerate(bl, 1):\n if grouped_query[0] == \"or\":\n query_list.append(al)\n query_list.append([grouped_query])\n counter = 0\n al = []\n continue\n al.append(grouped_query)\n counter += 1\n if index == len(bl):\n query_list.append(al)\n\n for x in query_list:\n for y in x:\n if y[0] == 'and' or y[0] == 'or' or y[0] == 'not':\n QueryObjects.B.append(y[0])\n continue\n if y[0][0] == '(' and y[0][-1] == ')':\n QueryObjects.B.append(y[0][0])\n lexer(y[0][1:-1])\n QueryObjects.B.append(y[0][-1])\n else:\n QueryObjects.IND += 1\n n = 'arg' + str(QueryObjects.IND)\n QueryObjects.D[n] = query_mapping(y, QueryObjects.IND)[\"query\"]\n QueryObjects.B.append(n)\n return QueryObjects.B","def _is_compound_of(entry: _LexiconEntry) -> str:\n return entry[\"is_compound\"].lower()","def find_nesting_levels(string, beg, end, fst, snd):\n beg_level = 0\n end_level = 0\n\n for i in range(beg, end):\n if string[i] == fst:\n end_level += 1\n if string[i] == snd:\n if end_level > 0:\n end_level -= 1\n else:\n beg_level += 1\n\n return beg_level, end_level","def parse(string):\n posslash = string.find('/')\n if posslash < 0:\n return Rational(int(string), 1)\n else:\n strs = string.split('/')\n return Rational(int(strs[0].strip()), int(strs[1].strip()))","def test_parse():\n first = parse_formula(\"PO4H2(CH2)12CH3\")\n assert first == {\"P\":1, \"O\":4, \"H\":29, \"C\":13}\n\n second = parse_formula(\"H2O\")\n assert second == {\"H\":2, \"O\":1}","def parse_cst(self):\n stack = []\n self.tokenizer.next().must_be('{')\n for token in self.tokenizer:\n stack += [ token ] # Build a stack to process\n if token.text == \".\":\n # We've got a rule to process. Start by determining correct syntax.\n stack[1].must_be(':')\n ## Name analysis\n stack[0].assert_symbol_name()\n production_elements = stack[2:-1]\n for element in production_elements:\n element.assert_symbol_name()\n if stack[0].text in self.GlobalSymbolDict: # Redefined lexical sym or add a new production?\n existingSymbol = self.GlobalSymbolDict[stack[0].text]\n if existingSymbol.is_gla:\n raise Exception(\"Lexical Symbol %s redefined at %d,%d. Originally at %d,%d\" % \\\n (stack[0].text, stack[0].line, stack[0].col, \\\n existingSymbol.defining_token.line, existingSymbol.defining_token.col))\n existingSymbol.productions += [Production(existingSymbol,production_elements)]\n else: # Brand new symbol occurrence\n s = Symbol(stack[0])\n s.is_gla = False\n s.productions = [Production(s,production_elements)]\n self.GlobalSymbolDict[stack[0].text] = s\n stack = []\n elif token.text == \"{\":\n raise Exception(\"Unexpected %s\" % token)\n elif token.text == \"}\":\n if len(stack) > 1: raise Exception(\"Unfinished lexical specification beginning with %s\" % stack[0])\n #pp = pprint.PrettyPrinter()\n #pp.pprint(self.GlobalSymbolDict)\n return\n else: pass","def _extract_terms(self, obj):\r\n terms = set()\r\n if 'paths' in obj:\r\n for path in obj['paths']:\r\n segs = re.split('[/{}]', path)\r\n for seg in segs:\r\n terms.add(seg.lower())\r\n self.terms = terms","def construct_top_level_depends(terms):\n assert len(terms) == 2\n # Strip the end_of_input\n deps = terms[0]\n\n if len(deps) == 1:\n return deps[0]\n elif not deps:\n return None\n else:\n return Conjunction(deps)","def parse_NFelt(K, s):\n return K([QQ(c) for c in s.split(\",\")])","def substrings(s):\r\n if s:\r\n yield from prefixes(s) # Get all the substrings that contains the first letter.\r\n yield from substrings(s[1:]) # Slice the first letter of s, then get substrings of s[1:]\r","def parse_str( s: str ) -> list:\n\n tree = ET.fromstring( s )\n if tree is None: return None\n return parse_tree( tree )","def parse_search_terms(self, search_terms):\n # v. kludgish.. TODO: do this a little more gracefully\n self.search_terms, b = [], []\n for index, st in enumerate(search_terms):\n if st == \"OR\":\n self.search_terms.append(b)\n b = []\n else:\n b.append(st)\n\n if index+1 == len(search_terms):\n self.search_terms.append(b)","def make_tree(self, strings):\n # start from tree root\n root = self.tree()\n # mark if letter is the end of string or just its part\n root['end'] = set()\n root['part'] = set(self.s_options_total)\n for idx, string in enumerate(strings):\n node = root\n for letter in string:\n new_node = node[letter]\n new_node.setdefault('end', set())\n new_node.setdefault('part', set()).add(idx)\n node = new_node\n node['end'].add(idx)\n node['part'].remove(idx)\n\n return root","def _break_query(queryStr):\n logicStatements = []\n opList = []\n\n #TODO: Add check for balanced parenthesis\n\n\n if('(' in queryStr and ')' in queryStr):\n\n currentPairLevel = 0 #indicates the current nest level of parens\n pairSearchLevel = 0 #level of open paren that match is being found for\n openPairIndex = 0 #the index of the open parenthesis in queryStr\n closePairIndex = 0 #index of close parenthesis in queryStr\n outerOpenFound = False\n indexPairs = []\n for index, char in enumerate(queryStr):\n\n if(char=='('):\n currentPairLevel += 1\n #if first open parenthesis\n if(not outerOpenFound):\n openPairIndex = index\n pairSearchLevel = currentPairLevel\n outerOpenFound = True\n elif(char==')'):\n #if the parenthesis is at the same nest level as the open\n if(currentPairLevel == pairSearchLevel):\n closePairIndex = index\n indexPairs.append([openPairIndex,closePairIndex])\n outerOpenFound = False\n currentPairLevel -= 1\n\n #used the positions of the parenthesis to pull sliced from the query\n for index, pair in enumerate(indexPairs):\n logicStatements.append(queryStr[(pair[0]+1):pair[1]])\n\n #if not the last parenthesis pair then get operator after it\n if not(index == len(indexPairs)-1):\n opList.append(queryStr[pair[1]+1])\n \n return logicStatements, opList","def build(\n word_dict: AsrDictionary,\n subword_dict: AsrDictionary,\n subword_tokenizer: Callable[[str], List[str]] = None,\n ):\n\n root = lexical_prefix_tree(\n word_dict=word_dict,\n subword_dict=subword_dict,\n subword_tokenizer=subword_tokenizer,\n ) # build traditional tree data structure by reusing existing routines\n\n # Performs pre-order traversal of this tree to assign an index for each node\n max_num_children = 0\n nodes = [None] # nodes[0] is a dummy node for OOV\n node_to_id_dict = {}\n stack = [root]\n\n while len(stack) > 0:\n curr = stack.pop()\n node_id = len(nodes)\n nodes.append(curr)\n node_to_id_dict[curr] = node_id\n if len(curr.children) > max_num_children:\n max_num_children = len(curr.children)\n\n # Guarantee that the children are traversed ascendingly according to the subword index\n for _, next_node in sorted(\n curr.children.items(), key=lambda t: t[0], reverse=True\n ):\n stack.append(next_node)\n\n # Construct the tree\n num_nodes = len(nodes)\n children = np.full([num_nodes, max_num_children], 0, dtype=np.int64)\n prev_subword_idx = np.full([num_nodes], subword_dict.pad(), dtype=np.int64)\n word_idx = np.full([num_nodes], -1, dtype=np.int64)\n word_set_idx = np.full([num_nodes, 2], word_dict.pad(), dtype=np.int64)\n\n for node_id in range(1, len(nodes)): # skip 0, which is `None`\n node = nodes[node_id]\n # Guarantee that the children are traversed ascendingly according to the subword index\n for i, (subword_id, child) in enumerate(\n sorted(node.children.items(), key=lambda t: t[0])\n ):\n child_node_id = node_to_id_dict[child]\n children[node_id, i] = child_node_id\n prev_subword_idx[child_node_id] = subword_id\n\n word_idx[node_id] = node.word_idx\n if node.word_set is not None:\n word_set_idx[node_id] = node.word_set\n else:\n word_set_idx[node_id] = [0, len(word_dict) - 1]\n\n return TensorizedPrefixTree(\n children=torch.from_numpy(children),\n prev_subword_idx=torch.from_numpy(prev_subword_idx),\n word_idx=torch.from_numpy(word_idx),\n word_set_idx=torch.from_numpy(word_set_idx),\n )","def decompTwo(string):\r\n index = 0\r\n while True:\r\n index = string.find('->', index)\r\n if index > 0:\r\n if isFormula(string[:index]) and isFormula(string[index + 2:]):\r\n return [string[:index], string[index + 2:]]\r\n else:\r\n index += 2\r\n else:\r\n break\r\n return ['', string]","def build_sublemma_index(self):\n terms = []\n with open(self.path_lemma_terms, 'r', encoding='utf8') as f:\n for line in f:\n term = line.strip('\\n')\n terms.append(term)\n terms = set(terms)\n for term in terms:\n term_list = term.split('_')\n subterms = get_sublists(term_list)\n self.sublemma_index[term] = [t for t in subterms if t in terms]","def parseTerms(cmds):\n if len(cmds) != 0:\n print(\"Term\")\n delimit = \"[*|/|%]+\"\n factors = re.split(delimit, cmds[0])\n parseFactors(cmds[0])\n parseTerms(cmds[1:])","def parse_polynomial(s):\n\n def parse_n(s):\n '''Parse the number part of a polynomial string term'''\n if not s:\n return 1\n elif s == '-':\n return -1\n elif s == '+':\n return 1\n return float(eval(s))\n\n def parse_p(s, powerPattern):\n '''Parse the power part of a polynomial string term'''\n if not s:\n return 0\n multipliers = powerPattern.findall(s)[0]\n if not multipliers:\n return 1\n return int(multipliers)\n s = str(s).replace(' ', '') # remove all whitespace from string\n m = re.search('[a-zA-Z]+', s)\n try:\n varLetter = m.group(0)\n except AttributeError:\n varLetter = 'P'\n termPattern = re.compile(\n '([+-]?\\d*\\.?\\d*)\\**({var}?\\^?\\d?)'.format(var=varLetter))\n powerPattern = re.compile('{var}\\^?(\\d)?'.format(var=varLetter))\n order_multipliers = {}\n\n for n, p in termPattern.findall(s):\n n, p = n.strip(), p.strip()\n if not n and not p:\n continue\n n, p = parse_n(n), parse_p(p, powerPattern)\n if p in order_multipliers:\n order_multipliers[p] += n\n else:\n order_multipliers[p] = n\n highest_order = max(\n max(order_multipliers.keys()), 1) # order must be at least linear\n multipliers = [0] * (highest_order + 1)\n for key, val in order_multipliers.items():\n multipliers[key] = val\n\n return multipliers","def tokenize(book_string):\n begin = re.sub(r'^(\\n *)*', '\\x02', book_string) # Begin of file\n final = re.sub(r'(\\n *)+$', '\\x03', begin) # End of file\n middle = re.sub(r'(\\n *){2,}', '\\x03\\x02 ', final) # Middle start/stop of parag\n no_line = re.sub(r'\\n', ' ', middle) # Other new lines with space\n\n slist = re.split(pattern=r'(?=\\x02|\\x03)|(?<=\\x02|\\x03)|\\b', string=no_line)\n slist = list(map(str.strip, filter(str.strip, slist))) # Filter empty, strip space\n return slist","def split_word_in_all_comps(self, term: str) -> List[str]:\n all_stems = []\n\n words = term.split()\n for word in words:\n stems = self.decompound(word)\n all_stems.extend(stems)\n\n for stem in stems:\n more_stems = self.split_word_in_all_comps(stem)\n all_stems.extend(more_stems)\n\n return all_stems","def parse_raw(parent, text):\n path, fname = os.path.split(os.path.abspath(parent.filename))\n path = path.split(os.sep)\n parent_tags = []\n parent_stack = [parent]\n # Parent tags for raw/{graphics, objects} are handled later\n if path[-1] == 'init':\n parent_tags = init_filename_parents.get(fname, [])\n for kind, token in tokenize_raw(text):\n if kind == 'Tag':\n contents = token[1:-1]\n if ':' in contents:\n name, value = contents.split(':', 1)\n else:\n name, value = contents, token[0] == '['\n is_parent = False\n for g in parent_tags:\n if fnmatch(name, g):\n is_parent = True\n while (parent_stack[-1].name in final_level_tags or\n any([fnmatch(p.name, g) for p in parent_stack])):\n parent_stack.pop()\n node = DFRawTag(parent_stack[-1], name, value)\n if is_parent:\n parent_stack.append(node)\n if path[-2] == 'raw' and name == 'OBJECT':\n parent_tags = object_parents[value]\n elif kind == 'Comment':\n DFRawComment(parent_stack[-1], token)\n else:\n log.e('Unknown raw token while parsing: '+kind)\n raise Exception('Unknown raw token kind: '+kind)","def reassemble_parens(cls, propstr, errstr, context, splitstr=','):\n vars = list()\n proplist = propstr.split(splitstr)\n while len(proplist) > 0:\n var = proplist.pop(0)\n while var.count('(') != var.count(')'):\n if len(proplist) == 0:\n raise ParseSyntaxError(errstr, token=propstr, context=context)\n # End if\n var = var + ',' + proplist.pop(0)\n # End while\n var = var.strip()\n if len(var) > 0:\n vars.append(var)\n # End if\n # End while\n return vars","def all_phrases(grammar, root):\n #\n # if root not in grammar:\n # return [[root]]\n #\n # phrases = []\n # for structure in grammar[root]:\n # for fragment in structure:\n # phrases = phrases + all_phrases(grammar,fragment)\n # print(phrases)\n # return phrases\n\n if root not in grammar:\n return [[root]]\n phrases = []\n for structure in grammar[root]:\n phrase_template = []\n for speech_part in structure:\n if speech_part not in grammar:\n if len(phrase_template)>0:\n new_phrase_template = []\n for phrase in phrase_template:\n if type(phrase)==str:\n phrase = [phrase]\n new_phrase_template.append(phrase+[speech_part])\n phrase_template = new_phrase_template\n else:\n phrase_template.append([speech_part])\n else:\n if len(phrase_template)>0:\n new_phrase_template = []\n for phrase in phrase_template:\n if type(phrase)==str:\n phrase = [phrase]\n for fragment in grammar[speech_part]:\n fragmented_bool = False\n for fragmented in fragment:\n if fragmented in grammar:\n fragmented_bool = True\n for subfragment in grammar[fragmented]:\n new_phrase_template.append(phrase+subfragment)\n if not fragmented_bool:\n new_phrase_template.append(phrase+fragment)\n phrase_template = new_phrase_template\n else:\n for fragment in grammar[speech_part]:\n if fragment[0] in grammar:\n for subfragment in grammar[fragment[0]]:\n phrase_template.append(subfragment)\n else:\n phrase_template.append(fragment)\n phrases = phrases + phrase_template\n return phrases","def readTree(text, ind, verbose=False):\n if verbose:\n print(\"Reading new subtree\", text[ind:][:10])\n\n # consume any spaces before the tree\n while text[ind].isspace():\n ind += 1\n\n if text[ind] == \"(\":\n if verbose:\n print(\"Found open paren\")\n tree = []\n ind += 1\n\n # record the label after the paren\n label = \"\"\n while not text[ind].isspace() and text != \"(\":\n label += text[ind]\n ind += 1\n\n tree.append(label)\n if verbose:\n print(\"Read in label:\", label)\n\n # read in all subtrees until right paren\n subtree = True\n while subtree:\n # if this call finds only the right paren it'll return False\n subtree, ind = readTree(text, ind, verbose=verbose)\n if subtree:\n tree.append(subtree)\n\n # consume the right paren itself\n ind += 1\n assert(text[ind] == \")\")\n ind += 1\n\n if verbose:\n print(\"End of tree\", tree)\n\n return tree, ind\n\n elif text[ind] == \")\":\n # there is no subtree here; this is the end paren of the parent tree\n # which we should not consume\n ind -= 1\n return False, ind\n\n else:\n # the subtree is just a terminal (a word)\n word = \"\"\n while not text[ind].isspace() and text[ind] != \")\":\n word += text[ind]\n ind += 1\n\n if verbose:\n print(\"Read in word:\", word)\n\n return word, ind","def test_parse_taxonomy(self):\r\n example_tax = \\\r\n \"\"\"412 PC.635_647\tRoot;Bacteria;Firmicutes; \"Clostridia\";Clostridiales\t0.930\r\n319 PC.355_281\tRoot;Bacteria;Bacteroidetes \t0.970\r\n353 PC.634_154\tRoot; Bacteria ; Bacteroidetes\t0.830\r\n17 PC.607_302\tRoot;Bacteria;Bacteroidetes\t0.960\r\n13 PC.481_1214\tRoot;Bacteria;Firmicutes;\"Clostridia\";Clostridiales\t0.870\r\n338 PC.593_1314\tRoot; Bacteria \t0.990\t42556\tAdditional fields ignored\"\"\"\r\n res = parse_taxonomy(example_tax.split('\\n'))\r\n self.assertEqual(res['412'],\r\n [\"Root\", \"Bacteria\", \"Firmicutes\", \"\\\"Clostridia\\\"\", \"Clostridiales\"])\r\n self.assertEqual(res['338'],\r\n [\"Root\", \"Bacteria\"])","def parseGOOBO(filename):\n with open(filename, \"r\") as infile:\n currentGOTerm = None\n for line in infile:\n line = line.strip()\n if not line: continue #Skip empty\n if line == \"[Term]\":\n if currentGOTerm: yield processGOTerm(currentGOTerm)\n currentGOTerm = defaultdict(list)\n elif line == \"[Typedef]\":\n #Skip [Typedef sections]\n currentGOTerm = None\n else: #Not [Term]\n #Only process if we're inside a [Term] environment\n if currentGOTerm is None: continue\n key, sep, val = line.partition(\":\")\n currentGOTerm[key].append(val.strip())\n #Add last term\n if currentGOTerm is not None:\n yield processGOTerm(currentGOTerm)","def trees_from_string(this_class, text):\n # Note: the native method below gives us memory ownership of\n # the InputTree objects in the vector. We acquire their pointers\n # and store them in a Python list (the vector won't stick\n # around). InputTree objects typically contain other InputTree\n # objects and the outer tree will free the inner trees when it is\n # deleted. So, we only need (and want) to acquire the pointer of\n # the outermost InputTree tree.\n trees = list(parser.inputTreesFromString(text))\n for tree in trees:\n tree.this.acquire()\n return list(map(this_class, trees))","def parse_from_regex(string,pattern,fields):\n\n string = string.replace('\\\\','/') # USE POSIX PLEASE\n num_groups = flat_paren_counter(pattern)\n if isinstance(fields,str):\n fields = [fields]\n num_fields = len(fields)\n if not num_fields == num_groups:\n return {}\n match = re.search(pattern,string)\n if not num_groups == len(match.groups()):\n return {}\n \n l = []\n \n for field,value in zip(fields,list(match.groups())):\n d = nested_notation_to_tree(field,value)\n l.append(d)\n return deep_merge_N(l)","def parse_rule(text: str) -> Tuple[str, Dict[str, int]]:\n kind, contents_text = text.split(\" bags contain \")\n contents: Dict[str, int] = defaultdict(int)\n if contents_text != \"no other bags.\":\n for subbag_text in contents_text[:-1].split(\", \"):\n count, subkind = parse_bagexpr(subbag_text)\n contents[subkind] += count\n return kind, contents","def __init__(self,treeString):\n\t\tself.treeString=treeString\n\t\tif self.checkString(self.treeString) == True:\n\t\t\tself.root=node.node(None)\n\t\t\tself.currNode=self.root\n\t\t\tself.buildTree(self.treeString)\n\t\t\t\"\"\"once information from buildTree is assigned to individual nodes, \n\t\t\tthe nodes then parse that information into names, branch lengths, etc\n\t\t\trecursive function allows the call to be made only to the root\"\"\"\n\t\t\t#use this step to do likelihood calculation\n\t\t\tself.root.processInfo()\n\t\telse:\n\t\t\t#change to an error in long run\n\t\t\tprint \"improperly formatted newick string\""],"string":"[\n \"def from_string(cls, compound_term_string):\\n compound_term_string = compound_term_string.replace(\\\" \\\", \\\"\\\")\\n subterms, connector, intervals = cls.parse_toplevel_subterms_and_connector(compound_term_string)\\n return cls(subterms, connector,intervals=intervals)\",\n \"def parse(self, string, root=None):\\n\\n\\t\\tphrases = []\\n\\n\\t\\tmeta = self.meta.search(string)\\n\\n\\t\\twhile meta:\\n\\n\\t\\t\\t# Save some function calls\\n\\t\\t\\tpos = meta.start()\\n\\n\\t\\t\\tif meta.group() == \\\"<\\\":\\n\\t\\t\\t\\tstring, child, meta = self.open_phrase(string, pos)\\n\\n\\t\\t\\t\\tif child and root:\\n\\t\\t\\t\\t\\troot.nested.append(child)\\n\\t\\t\\t\\telif child:\\n\\t\\t\\t\\t\\tphrases.append(child)\\n\\n\\t\\t\\t\\t# else it was escaped (+ new meta)\\n\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\telif root:\\n\\n\\t\\t\\t\\tif meta.group() == \\\"(\\\":\\n\\t\\t\\t\\t\\tmeta = self.meta.search(string, pos + 1)\\n\\t\\t\\t\\t\\tif meta.group() == \\\")\\\":\\n\\t\\t\\t\\t\\t\\tstring, root, meta = self.handle_arguments(string,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t root,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t pos,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t meta.start())\\n\\t\\t\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\t\\telif meta.group() == \\\">\\\":\\n\\t\\t\\t\\t\\tstring, phrase, meta = self.close_phrase(string,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t root,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t pos)\\n\\t\\t\\t\\t\\tif phrase:\\n\\t\\t\\t\\t\\t\\treturn string, phrase\\n\\n\\t\\t\\t\\t\\t# else was escaped (+ new meta)\\n\\t\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\tstring, meta = self.escape_meta(string, pos)\\n\\n\\t\\tif not root:\\n\\t\\t\\treturn string, phrases\\n\\n\\t\\t# If this is not the first stack-depth the function should\\n\\t\\t# have returned upon finding a closing tag,\\n\\t\\t# i.e. we should never have gotten here.\\n\\t\\tword = re.search(r\\\"([\\\\w\\\\s]+)(?![\\\\d]*>[\\\\w\\\\s]+>)\\\", string)\\n\\n\\t\\twhat = \\\"No closing tag found for opening tag\\\"\\n\\n\\t\\tif word:\\n\\t\\t\\twhat += \\\" after expression '{0}'\\\".format(word.group())\\n\\n\\t\\traise errors.ParseError(what + \\\"!\\\")\",\n \"def parse_prefix(s):\\n\\n Term.str = replace_string(s) # replace operators with more than one letter to be one letter\\n second = None\\n\\n # if there is a left parentheses it means that we are having an operator that is enclosed by parenthesis\\n if is_left_parenthese(Term.str[0]):\\n Term.eat() # eat left parentheses\\n first, Term.str = Formula.parse_prefix(Term.str) # take first formula of the operator\\n root = switch_root_to_str(Term.str[0]) # take the root\\n Term.eat() # eat the root\\n second, Term.str = Formula.parse_prefix(Term.str) # take second formula of the operator\\n Term.eat() # eat right parentheses\\n\\n # if first letter is a quantifier ('A' or 'E')\\n elif is_quantifier(Term.str[0]):\\n root = Term.str[0] # take the quantifier as root\\n Term.eat() # eat the root ( quantifier)\\n first = Term.get_whole_name() # take the name of the variable\\n Term.eat() # eat the left bracket\\n second, Term.str = Formula.parse_prefix(Term.str) # take the formula\\n Term.eat() # eat the right bracket\\n\\n # if first letter is a relation (starts with capital letter)\\n elif is_relation(Term.str[0]):\\n root = Term.get_whole_name() # take the name of the relation\\n first = []\\n Term.eat() # eat left parentheses\\n\\n # if we didn't find closing parenthesis - than there must be at least one Term inside the parenthesis.\\n # take it.\\n if not is_right_parenthese(Term.str[0]):\\n term_obj, Term.str = Term.parse_prefix(Term.str)\\n first.append(term_obj)\\n\\n # while there is a comma, take the next term\\n while is_comma(Term.str[0]):\\n Term.eat() # eat left parentheses\\n term_obj, Term.str = Term.parse_prefix(Term.str)\\n first.append(term_obj)\\n Term.eat() # eat right parentheses\\n\\n # else , it is an operator\\n else:\\n\\n # if it's an unary operator\\n if is_unary(Term.str[0]):\\n root = Term.str[0]\\n Term.eat()\\n first, Term.str = Formula.parse_prefix(Term.str)\\n\\n # else , the operator is binary or equaluty\\n else:\\n first, Term.str = Term.parse_prefix(Term.str)\\n # if it's a binary operator\\n if is_binary(Term.str[0]):\\n root = Term.str[0:2]\\n Term.eat()\\n\\n # if it's an equal operator\\n else:\\n root = Term.str[0]\\n Term.eat()\\n second, Term.str = Term.parse_prefix(Term.str)\\n returned_formula = Formula(root, first, second)\\n return returned_formula, Term.str\",\n \"def extract_compounds(text):\\n comp_idx = 0\\n compound = []\\n compound_nps = []\\n tok_idx = 0\\n for idx, tok in enumerate(nlp(text)):\\n if tok.dep_ == \\\"compound\\\":\\n\\n # capture hyphenated compounds\\n children = \\\"\\\".join([c.text for c in tok.children])\\n if \\\"-\\\" in children:\\n compound.append(\\\"\\\".join([children, tok.text]))\\n else:\\n compound.append(tok.text)\\n\\n # remember starting index of first child in compound or word\\n try:\\n tok_idx = [c for c in tok.children][0].idx\\n except IndexError:\\n if len(compound) == 1:\\n tok_idx = tok.idx\\n comp_idx = tok.i\\n\\n # append the last word in a compound phrase\\n if tok.i - comp_idx == 1:\\n compound.append(tok.text)\\n if len(compound) > 1:\\n compound = \\\" \\\".join(compound)\\n compound_nps.append(\\n (compound, tok_idx, tok_idx + len(compound), \\\"COMPOUND\\\")\\n )\\n\\n # reset parameters\\n tok_idx = 0\\n compound = []\\n\\n if len(compound_nps) != 0:\\n return compound_nps[0][0]\\n else:\\n return \\\"\\\"\",\n \"def parse (self, phrase):\\r\\n\\r\\n if isinstance(phrase,str):\\r\\n #If the phrase is a string\\r\\n if self.is_simple(phrase):\\r\\n #EXITS the recursion\\r\\n if phrase[0:2] == '~~':\\r\\n return phrase[2:]\\r\\n #Eliminates negations that cancel each other\\r\\n return phrase\\r\\n elif self.bracketed(phrase):\\r\\n #Eliminate top-level parantheses\\r\\n return self.parse(phrase[1:-1])\\r\\n elif phrase[0] == '~':\\r\\n #If the phrase begins with a negating prefix...\\r\\n negations,phrase = self.heading_count(phrase)\\r\\n \\r\\n if self.bracketed(phrase):\\r\\n #If the negated phrase is bracketed\\r\\n if negations % 2 == 1:\\r\\n subphrase = self.split_into_phrases(phrase[1:-1])\\r\\n if subphrase[0] != '@': \\r\\n #De Morgan's Law \\r\\n return self.parse(['@']+['~'+x for x in subphrase])\\r\\n else:\\r\\n #De Morgan's Law\\r\\n return self.parse(['~'+x for x in subphrase[1:]])\\r\\n else:\\r\\n return self.parse(phrase[1:-1])\\r\\n return self.parse(self.split_into_phrases((negations%2)*'~'+phrase))\\r\\n \\r\\n else:\\r\\n return self.parse(self.split_into_phrases(phrase))\\r\\n # IF the phrase is a list\\r\\n if self.all_is_P(phrase,predicate_function=self.is_simple):\\r\\n #If every terms of the phrase list is simple...\\r\\n #This prepares for EXIT from recursion\\r\\n return [self.parse(x) for x in phrase]\\r\\n return self.parse([self.parse(x) for x in phrase])\",\n \"def parse(s: str):\\n Term.str = s\\n new_Formula = None\\n while Term.str != '':\\n new_Formula, Term.str = Formula.parse_prefix(Term.str)\\n return new_Formula\\n # Task 7.4.2\",\n \"def parse(s):\\n Term.str = s\\n new_term = None\\n while Term.str != '':\\n new_term, Term.str = Term.parse_prefix(Term.str)\\n return new_term\",\n \"def from_string(cls, term_string):\\n term_string = term_string.replace(\\\" \\\", \\\"\\\")\\n\\n if term_string in cls.term_dict:\\n return cls.term_dict[term_string]\\n\\n if term_string[0] == NALSyntax.StatementSyntax.Start.value:\\n \\\"\\\"\\\"\\n Compound or Statement Term\\n \\\"\\\"\\\"\\n assert (term_string[-1] == NALSyntax.StatementSyntax.End.value), \\\"Compound/Statement term must have ending parenthesis: \\\" + term_string\\n\\n copula, copula_idx = NALSyntax.Copula.get_top_level_copula(term_string)\\n if copula is None:\\n # compound term\\n term = CompoundTerm.from_string(term_string)\\n else:\\n term = StatementTerm.from_string(term_string)\\n elif NALSyntax.TermConnector.is_set_bracket_start(term_string[0]):\\n # set term\\n term = CompoundTerm.from_string(term_string)\\n elif term_string[0] == NALSyntax.TermConnector.Array.value:\\n if NALSyntax.StatementSyntax.ArrayElementIndexStart.value in term_string:\\n term = ArrayTermElementTerm.from_string(term_string)\\n else:\\n term = ArrayTerm.from_string(term_string)\\n elif term_string[0] == VariableTerm.VARIABLE_SYM or term_string[0] == VariableTerm.QUERY_SYM:\\n # variable term\\n dependency_list_start_idx = term_string.find(\\\"(\\\")\\n if dependency_list_start_idx == -1:\\n variable_name = term_string[1:]\\n dependency_list_string = \\\"\\\"\\n else:\\n variable_name = term_string[1:dependency_list_start_idx]\\n dependency_list_string = term_string[term_string.find(\\\"(\\\") + 1:term_string.find(\\\")\\\")]\\n\\n term = VariableTerm.from_string(variable_name=variable_name,\\n variable_type_symbol=term_string[0],\\n dependency_list_string=dependency_list_string)\\n else:\\n term_string = re.sub(\\\",\\\\d+\\\", \\\"\\\", term_string)\\n term = AtomicTerm(term_string)\\n\\n cls.term_dict[term_string] = term\\n\\n return term\",\n \"def make_terms_from_string(s):\\n u = s\\n return u.split()\",\n \"def get_subterms(expr):\\n av_expr = []\\n expr_types = []\\n if isinstance(expr, Term):\\n if expr.subterms:\\n for s in expr.subterms:\\n new_av, new_type = get_subterms(s)\\n av_expr += new_av\\n expr_types += new_type\\n new_type = expr.type\\n expr_types.append(new_type)\\n av_expr.append(expr)\\n else:\\n av_expr.append(expr)\\n expr_types.append(expr.type)\\n elif type(expr) != str:\\n if expr.term:\\n new_av, new_type = get_subterms(expr.term)\\n av_expr += new_av\\n expr_types += new_type\\n return av_expr, expr_types\",\n \"def parse_term(s, ctx, mctx, ops):\\n s = strip_parens(s.strip())\\n if re.search(\\\"^\\\\w*$\\\",s): # If a single word, either a variable or a constant\\n if s in ops:\\n return Con(ops[s], [], ctx, mctx)\\n elif s in ctx:\\n return Var(s, ctx, mctx)\\n elif s in mctx:\\n return MVar(s, [], ctx, mctx)\\n elif s.startswith(\\\"O\\\") and s[1:] in mctx:\\n return MVar(s, [], ctx, mctx, is_hole=True)\\n else:\\n raise Exception(\\\"Unbound variable: \\\" + \\\"'\\\" + s + \\\"'\\\")\\n\\n elif re.search(\\\"^\\\\w*\\\\[.*\\\\]$\\\", s): # If a metavariable\\n m = re.search(\\\"^(\\\\w)*\\\\[(.*)\\\\]$\\\", s)\\n mvar = m.group(1)\\n env = m.group(2)\\n if not env:\\n return MVar(mvar, [], ctx, mctx, is_hole=mvar.startswith(\\\"O\\\"))\\n else:\\n return MVar(mvar, [Term.parse_term(t, ctx, mctx, ops) for t in split_tuple(env)], ctx, mctx)\\n\\n elif re.search(\\\"^([\\\\w ]*)\\\\.(.*)$\\\", s): # If a variable under binders\\n m = re.search(\\\"^([\\\\w ]*)\\\\.(.*)$\\\", s)\\n bound = m.group(1).split()\\n tm = m.group(2)\\n return Term.parse_term(tm, bound + ctx, mctx, ops)\\n\\n elif re.search(\\\"^(\\\\w*) *\\\\((.*)\\\\)$\\\", s): # If an expression\\n m = re.search(\\\"^(\\\\w*) *\\\\((.*)\\\\)$\\\", s)\\n op = m.group(1)\\n args = m.group(2)\\n return Con(ops[op], [Term.parse_term(t, ctx, mctx, ops) for t in split_tuple(args)], ctx, mctx)\\n else:\\n raise Exception(\\\"Can't parse: \\\" + s)\",\n \"def _parse_sub(self, parsetree, text, fpos=0):\\r\\n curr = 0\\r\\n for match in self._reSubstitution.finditer(text):\\r\\n start = match.start()\\r\\n if start > curr:\\r\\n parsetree.append((\\\"str\\\", self._reComment.sub('', text[curr:start])))\\r\\n\\r\\n if match.group(\\\"sub\\\") is not None:\\r\\n if not match.group(\\\"end\\\"):\\r\\n raise TemplateSyntaxError(\\\"Missing closing tag '%s' for '%s'.\\\" \\r\\n % (self._sub_end, match.group()), self._errpos(fpos+start))\\r\\n if len(match.group(\\\"sub\\\")) > 0:\\r\\n self._testexpr(match.group(\\\"sub\\\"), fpos+start)\\r\\n parsetree.append((\\\"sub\\\", match.group(\\\"sub\\\")))\\r\\n else:\\r\\n assert(match.group(\\\"escsub\\\") is not None)\\r\\n if not match.group(\\\"escend\\\"):\\r\\n raise TemplateSyntaxError(\\\"Missing closing tag '%s' for '%s'.\\\"\\r\\n % (self._subesc_end, match.group()), self._errpos(fpos+start))\\r\\n if len(match.group(\\\"escsub\\\")) > 0:\\r\\n self._testexpr(match.group(\\\"escsub\\\"), fpos+start)\\r\\n parsetree.append((\\\"esc\\\", self.escape, match.group(\\\"escsub\\\")))\\r\\n\\r\\n curr = match.end()\\r\\n\\r\\n if len(text) > curr:\\r\\n parsetree.append((\\\"str\\\", self._reComment.sub('', text[curr:])))\",\n \"def parse(s):\\n # Use _PARSE_RE to check that it's valid.\\n if not CFGProduction._PARSE_RE.match(s):\\n raise ValueError, 'Bad production string'\\n # Use _SPLIT_RE to process it.\\n pieces = CFGProduction._SPLIT_RE.split(s)\\n pieces = [p for i,p in enumerate(pieces) if i%2==1]\\n lhside = Nonterminal(pieces[0])\\n rhsides = [[]]\\n for piece in pieces[2:]:\\n if piece == '|':\\n rhsides.append([]) # Vertical bar\\n elif piece[0] in ('\\\"', \\\"'\\\"):\\n rhsides[-1].append(piece[1:-1]) # Terminal\\n else:\\n rhsides[-1].append(Nonterminal(piece)) # Nonterminal\\n return [CFGProduction(lhside, rhside) for rhside in rhsides]\",\n \"def read_tree(cls, string):\\n \\n # first, remove the brackets ()\\n string = string.strip()\\n if len(string) == 0:\\n raise ValueError(\\\"empty string cannot be a Synstactic Tree\\\")\\n if string[0] == \\\"(\\\" and string[-1] == \\\")\\\":\\n string = string[1:-1]\\n \\n # split the string with blank character\\n # if the string has exactly or fewer than one element, it cannot be a \\n # tree\\n # if it has two elements, it must be a tree with a terminal node as the\\n # root\\n # if it has more than two elements, take the first element as the root\\n # and other elements as the branches \\n elements = string.split()\\n if len(elements) <= 1 or elements[1] == \\\"\\\":\\n raise ValueError(\\\"%s cannot be a tree or subtree\\\" %string)\\n else:\\n if len(elements) == 2:\\n # TODO: if the label comes from CCG parser, turn [] into ()\\n root = cls._read_terminal_node(elements)\\n else:\\n branch_string = \\\" \\\".join(elements[1:])\\n root = SyntacticNode(elements[0])\\n branches = cls._read_branches(branch_string)\\n for branch in branches:\\n root.add_child(branch._root)\\n \\n return SyntacticTree(root)\",\n \"def parse(operators, *term_strs):\\n scope = Scope()\\n rvs = []\\n for ts in term_strs:\\n p = Parser(operators, ts, scope)\\n try:\\n term = p.parse()\\n except SyntaxError:\\n print 'While parsing: %s' % ts\\n raise\\n rvs.append(term)\\n rvs.append(scope)\\n return tuple(rvs)\",\n \"def parse(string):\\n doc = nlp(string)\\n return [str(n) for n in doc.noun_chunks]\",\n \"def parseTerms(fp):\\n\\n try:\\n # match \\\"Terminais\\\", with or without a comment etc., using RegEx\\n # to know more, search for 'python regular expressions'\\n ln = fp.readline()\\n p = re.compile(r'^Terminais\\\\s*(?:#.*)?$')\\n m = p.match(ln)\\n if m == None:\\n raise ParseError(ParseError.termsMsg)\\n\\n # match and capture \\\"{ a, b }\\\" etc.\\n ln = fp.readline()\\n p = re.compile(r'^\\\\{\\\\s*(.*)\\\\s*\\\\}\\\\s*(?:#.*)?$')\\n m = p.match(ln)\\n if m == None:\\n raise ParseError(ParseError.termsMsg)\\n\\n # split the string by ',', trim spaces and return as a set\\n a = m.group(1).split(',') # group(1) contains each captured group\\n a[:] = map(str.strip, a) # trim spaces in each element of a\\n return set(a) # remove duplicates\\n\\n except:\\n raise\",\n \"def parse(raw_query, EXPAND_SET = False):\\r\\n\\t\\r\\n\\t# tokenize and tag the query using nltk tools, use .lower() to standardize the input\\r\\n\\ttokenized_query = nltk.word_tokenize(raw_query.lower())\\r\\n\\ttagged_query = nltk.pos_tag(tokenized_query)\\r\\n\\t\\r\\n\\t#master_chunk = r\\\"Chunk: {(<VB\\\\w?>|<JJ>*|<RB\\\\w?>)<DT>?(<NN\\\\w?>+)}\\\" \\r\\n\\t\\r\\n\\t\\r\\n\\t# master_chunk now captures prepositional phrase, as they are typically part of one thought.\\r\\n\\t\\r\\n\\tmaster_chunk = r\\\"Chunk: {((<JJ\\\\w?>*|<RB\\\\w?>*)<DT>?(<NN\\\\w?>+))(<IN>((<JJ>*|<RB\\\\w?>*)<DT>?(<NN\\\\w?>+)))*}\\\" # Regex to identify chunks that may be useful \\r\\n\\t#\\t\\t\\t\\t\\tmaster_chunk breakdown\\r\\n\\t#\\r\\n\\t#\\tFirst half : ((<JJ>*|<RB\\\\w?>*)<DT>?(<NN\\\\w?>+))\\r\\n\\t#\\t<JJ\\\\w?>* | <RB\\\\w>?>* allows an arbitrary number of adjectives to precede the noun\\r\\n\\t# \\t\\\"\\\\w\\\" is \\\"any character\\\" and allows the capture of all JJ and RB tags, which include JJ, JJR, JJS, RB, RBR, and RBS\\r\\n\\t#\\t<DT>? allows for exactly one (1) or zero (0) determiner, often this will capture things like \\\"no\\\" and then a noun\\r\\n\\t# \\t(<NN\\\\w>+) captures one (1) or arbitrarily more nouns\\r\\n\\t#\\t\\r\\n\\t#\\tSecond half: (<IN>((<JJ>*|<RB\\\\w?>*)<DT>?(<NN\\\\w?>+)))*\\r\\n\\t#\\t<IN> captures prepostions \\\"of\\\", \\\"with\\\", and so on.\\r\\n\\t# \\tThe rest of the expression is the same as the first half \\r\\n\\t# \\tThe final * (kleene star) allows zero (0) or more prepositional phrases to be captured\\r\\n\\t\\r\\n\\t\\r\\n\\tmaster_parser = nltk.RegexpParser(master_chunk) # Create the parser from the Regex\\r\\n\\tmaster = master_parser.parse(tagged_query) # Parse the query previously tagged\\r\\n\\t\\r\\n\\tchunk_list = []\\r\\n\\tkeywords = []\\r\\n\\tfor phrase in master:\\r\\n\\t\\tif (not isinstance(phrase, tuple)): # all non-chunks are tuples, a chunk is a nltk.tree type\\r\\n\\t\\t\\tchunk_list.append(phrase)\\r\\n\\t\\t\\ttmp = \\\"\\\"\\r\\n\\t\\t\\tfor word in phrase: # generate keyword phrases from the chunks\\r\\n\\t\\t\\t\\ttmp += word[0] + \\\" \\\"\\r\\n\\t\\t\\t\\r\\n\\t\\t\\ttmp = tmp[:-1] # Remove final space\\r\\n\\t\\t\\tkeywords.append(tmp)\\r\\n\\t\\t\\t\\r\\n\\tif EXPAND_SET: # defualt is not to expand\\r\\n\\t\\t# combine the two lists, using set() to remove any repeated phrases\\r\\n\\t\\treturn list(set(generate_keywords(chunk_list) + keywords))\\r\\n\\telse:\\r\\n\\t\\treturn keywords\",\n \"def parse_tree(s):\\n return parser.parse(lexer=lexer, input=s)\",\n \"def parse_formula(formula):\\r\\n\\r\\n # Convert the formula string into a list of symbols (parentheses, operators, numbers, cells)\\r\\n symbols = get_symbols(formula)\\r\\n\\r\\n # If formula contains only one symbol, then it must be a cell / number\\r\\n if len(symbols) == 1:\\r\\n return parseTree(node=symbols[0])\\r\\n\\r\\n # Otherwise Formula contains at least two cells / numbers\\r\\n # tree is an intially 'empty' parseTree that will be the constructed into the final tree\\r\\n # tree comes in the form\\r\\n # None\\r\\n # / \\\\\\r\\n # None None\\r\\n # / \\\\\\r\\n # None None\\r\\n tree = parseTree(left=parseTree())\\r\\n\\r\\n # stack is the stack of nodes (parseTrees) that is currently being traversed,\\r\\n # starting from the root of tree, but excluding the current node\\r\\n stack = [tree]\\r\\n\\r\\n # current_tree stores the current node that is being dealt with\\r\\n current_tree = tree.left\\r\\n\\r\\n # iterates through each symbol (parenthesis, operator, cell, or number) and constructs tree\\r\\n for symbol in symbols:\\r\\n\\r\\n # If the symbol is an opening parenthesis, then make the left child\\r\\n # into a parseTree (new independent expression) and traverse into it\\r\\n if symbol == '(':\\r\\n # Push the current tree to stack\\r\\n stack.append(current_tree)\\r\\n # Make the left child into a parseTree\\r\\n current_tree.left = parseTree()\\r\\n # Traverse into the left child\\r\\n current_tree = current_tree.left\\r\\n\\r\\n # If the symbol is a closing parenthesis, then backtrack out of the\\r\\n # current tree (expression) and into to the previous tree in stack\\r\\n elif symbol == ')':\\r\\n # Pop the topmost tree from stack and set current_tree equal to it\\r\\n current_tree = stack.pop()\\r\\n\\r\\n # If the symbol is an operator, then check if this tree's node already\\r\\n # has an operator\\r\\n elif symbol in operators:\\r\\n # If current_tree's node has not been changed yet (None), then set it\\r\\n # equal to symbol, and then make the right child into a parseTree\\r\\n # and traverse into it\\r\\n if current_tree.node == None:\\r\\n # Set node of current_tree equal to the operator\\r\\n current_tree.node = symbol\\r\\n # Push the current tree to stack\\r\\n stack.append(current_tree)\\r\\n # Make the right child into a parseTree\\r\\n current_tree.right = parseTree()\\r\\n # Traverse into the right child\\r\\n current_tree = current_tree.right\\r\\n\\r\\n # If there is already an operator, then we must check whether or not it has\\r\\n # a higher precedence than symbol in order to deal with order of operations\\r\\n else:\\r\\n # If the existing operator has higher or equal precedence, then \\\"squeeze\\\"\\r\\n # symbol right above current_tree, making symbol its parent\\r\\n if operators[current_tree.node] >= operators[symbol]:\\r\\n # Copy current_tree down into its own left child and set its node\\r\\n # equal to symbol\\r\\n current_tree.left = copy.deepcopy(current_tree)\\r\\n current_tree.node = symbol\\r\\n # Push the current tree to stack\\r\\n stack.append(current_tree)\\r\\n # Make the right child into a parseTree\\r\\n current_tree.right = parseTree()\\r\\n # Traverse into the right child\\r\\n current_tree = current_tree.right\\r\\n\\r\\n # If symbol has higher precedence, then replace the right child with symbol\\r\\n # and push the original right child down into the left child of symbol\\r\\n else:\\r\\n # Make the right child of current_tree into a new parseTree by moving it down\\r\\n # into the left child of the new tree and symbol as the node\\r\\n current_tree.right = parseTree(node=symbol, left=current_tree.right)\\r\\n # Push the current tree to stack\\r\\n stack.append(current_tree)\\r\\n # Traverse into the right child\\r\\n current_tree = current_tree.right\\r\\n # Push the new current tree to stack\\r\\n stack.append(current_tree)\\r\\n # Make the right child into a parseTree\\r\\n current_tree.right = parseTree()\\r\\n # Traverse into the right child once again\\r\\n current_tree = current_tree.right\\r\\n\\r\\n # Otherwise, the symbol must be a cell or a number\\r\\n else:\\r\\n # Set node of current_tree equal to the cell/number\\r\\n current_tree.node = symbol\\r\\n # Pop the topmost tree from stack and set current_tree equal to it\\r\\n current_tree = stack.pop()\\r\\n\\r\\n # ******************************************************************************\\r\\n # UNCOMMENT THE FOLLOWING BLOCK OF CODE TO SEE THE TREE BEING BUILT AT EACH STEP\\r\\n # ******************************************************************************\\r\\n # tree.display()\\r\\n # print(\\\"-----------------------\\\")\\r\\n\\r\\n # Return tree as the final result\\r\\n return tree\",\n \"def tree_string_parser(tree_string):\\n tree_hash = create_hash(tree_string)\\n tree_string = tree_string.replace(\\\"(\\\", \\\"{\\\")\\n tree_string = tree_string.replace(\\\")\\\", \\\"}\\\")\\n tree_string = \\\"{\\\" + tree_string + \\\"}\\\"\\n tree_string = tree_string.replace(\\\"'\\\", \\\"\\\")\\n\\n data = re.sub(r'([\\\\w\\\\.\\\\-]+)', r'\\\"\\\\1\\\"', tree_string) # {\\\"val1\\\" {\\\"val2\\\" {\\\"d1\\\" \\\"d2\\\" \\\"d3\\\"}}}\\n data = re.sub(r'\\\"\\\\s*{', r'\\\": {', data) # {\\\"val1\\\": {\\\"val2\\\": {\\\"d1\\\" \\\"d2\\\" \\\"d3\\\"}}}\\n data = re.sub(r'\\\" \\\"', r'\\\", \\\"', data) # {\\\"val1\\\": {\\\"val2\\\": {\\\"d1\\\", \\\"d2\\\", \\\"d3\\\"}}}\\n data = re.sub(r'{([^{}]*)}', r'[\\\\1]', data) # {\\\"val1\\\": {\\\"val2\\\": [\\\"d1\\\", \\\"d2\\\", \\\"d3\\\"]}}\\n data = re.sub(r'\\\\[([\\\\\\\"\\\\:\\\\, \\\\w\\\\.\\\\-]+:+[\\\\\\\"\\\\:\\\\, \\\\w\\\\.\\\\-]+)\\\\]', r'\\\\1', data)\\n data = re.sub(r'({[\\\\\\\"\\\\w\\\\.\\\\-]+),', r'\\\\1: [],', data)\\n data = re.sub(r', (\\\\\\\"[\\\\\\\"\\\\w\\\\.\\\\-]+\\\\\\\")}', r', \\\\1: []}', data)\\n data = re.sub(r', (\\\\\\\"[\\\\\\\"\\\\w\\\\.\\\\-]+\\\\\\\"),(?![^\\\\[]*\\\\])', r', \\\\1: [],', data)\\n data = re.sub(r', (\\\\\\\"[\\\\\\\"\\\\w\\\\.\\\\-]+\\\\\\\"),(?![^\\\\[]*\\\\])', r', \\\\1: [],', data)\\n data = re.sub(r', \\\\[(.*?)\\\\]', r', \\\"ARGS\\\": [[\\\\1]]', data)\\n try:\\n tree_dict = json.loads(data)\\n except:\\n print(\\\"Error from json.loads: \\\" + data)\\n try:\\n fix_up_tree(tree_dict)\\n except:\\n print(\\\"Error from fix_up_tree: \\\" + data)\\n try:\\n plot_tree(tree_dict, tree_hash)\\n except:\\n print(\\\"Error from plot tree: \\\" + data)\",\n \"def get_maths_list(string:str, parent_name:str):\\n parse = MathList()\\n param_word = True\\n prev_char = ''\\n \\n n = len(string)\\n\\n has_char = False\\n word_added = False\\n \\n #print()\\n #print(\\\"Decompose:\\\", string)\\n\\n i = 0\\n word_start = i\\n word_end = i\\n \\n while i < n:\\n c = string[i]\\n #print(\\\":\\\",c, string[word_start:word_end])\\n \\n if maths_syntax(c):\\n if c == ')':\\n raise SyntaxError(\\\"\\\\nStack Trace: {0}\\\\nClose bracket has no opening bracket in '{1}'\\\"\\\\\\n .format(parent_name, string))\\n elif c == '(':\\n if word_start != word_end:\\n if param_word:\\n raise SyntaxError(\\\"\\\\nStack Trace: {0}\\\\nUndefined function between two numbers: '{1}'\\\"\\\\\\n .format(parent_name, string))\\n else:\\n # add function\\n #print(\\\"Adding operand:\\\",string[word_start:word_end])\\n new_str = string[word_start:word_end]\\n parse.add_elem(new_str)\\n \\n params = False\\n #next element cannot be params!\\n \\n # Read opening bracket sub-syntax\\n open_brac_num = 1\\n j = i+1\\n while open_brac_num > 0 and j < n:\\n c = string[j]\\n if c == ')':\\n open_brac_num -= 1\\n else:\\n if c == '(':\\n open_brac_num += 1\\n if open_brac_num != 0:\\n j += 1\\n \\n if j == n:\\n raise SyntaxError(\\\"\\\\nStack Trace: {0}\\\\nNo closing bracket for '{1}'\\\"\\\\\\n .format(parent_name, string))\\n else:\\n new_string = string[i+1:j]\\n sub_list = MathList.get_maths_list(new_string, parent_name)\\n parse.add_elem(sub_list)\\n i = j\\n \\n word_start = i+1\\n word_end = word_start\\n word_added = True\\n\\n has_char = True\\n param_word = False\\n \\n else:\\n has_char = True # allows for -() syntax\\n \\n if prev_char == exponent and (c =='+' or c == '-'):\\n word_end += 1\\n else:\\n if (c == '-' or c =='+')\\\\\\n and (prev_char == '*' or prev_char == '/' or prev_char == '^'):\\n # allows for x*-y syntax\\n param_word = True\\n \\n if param_word:\\n #print(\\\"Adding parametre:\\\",string[word_start:word_end])\\n if word_start == word_end:\\n pass # don't add empty/non-parameter\\n else:\\n new_str = string[word_start:word_end]\\n parse.add_elem(new_str)\\n \\n param_word = False\\n word_start = i\\n word_end = word_start + 1\\n else:\\n word_end = i + 1\\n\\n else:\\n \\\"\\\"\\\"\\n if is_white_space(c) and word_start == i:\\n # if word is set to start at i, but i is a white space, they move to next character\\n word_start += 1\\n print(\\\"here\\\")\\n else:\\n print(\\\"there\\\")\\n if not param_word:\\n new_str = string[word_start:i]\\n parse.add_elem(new_str)\\n \\n param_word = True\\n word_start = i\\n \\n if not is_white_space(c):\\n has_char = True\\n \\\"\\\"\\\"\\n if is_white_space(c):\\n # if is white space add previous word\\n if word_start != word_end:\\n #print(\\\"string:\\\",string[word_start:word_end])\\n \\\"\\\"\\\"\\n # add previous word\\n new_str = string[word_start:word_end]\\n parse.add_elem(new_str)\\n word_start = i+1\\n word_end = word_start\\n word_added = True\\n \\\"\\\"\\\"\\n pass\\n else:\\n # move to next character, since white space\\n word_start += 1\\n word_end = word_start\\n #print(\\\"here\\\")\\n else:\\n has_char = True\\n \\n if not param_word:\\n #print(\\\"Adding operand:\\\",string[word_start:word_end])\\n if word_start == word_end:\\n pass\\n else:\\n new_str = string[word_start:word_end]\\n parse.add_elem(new_str)\\n \\n param_word = True\\n word_start = i\\n word_end = word_start + 1\\n word_added = False\\n else:\\n word_end = i + 1\\n \\n \\n\\n i += 1\\n prev_char = c\\n \\n if word_start != word_end:\\n new_str = string[word_start:word_end]\\n #print(\\\"new_str:\\\",new_str)\\n parse.add_elem(new_str)\\n \\n #print(\\\"P\\\",parse, \\\":\\\",string)\\n return parse\",\n \"def BNF():\\n\\n sect_begin = Literal(\\\"{\\\").suppress()\\n sect_end = Literal(\\\"}\\\").suppress()\\n array_begin = Literal(\\\"[\\\").suppress()\\n array_end = Literal(\\\"]\\\").suppress()\\n tag_begin = Literal(\\\"<\\\").suppress()\\n tag_end = Literal(\\\">\\\").suppress()\\n eql = Literal(\\\"=\\\").suppress()\\n dmark = Literal('$').suppress()\\n end_data = Literal('$end').suppress()\\n prtable = alphanums + r'!$%&*+-./<>?@^_|~'\\n int_t = Regex('[-]?\\\\d+')\\n float_t = Regex('-?\\\\d+\\\\.\\\\d*([eE]?[+-]?\\\\d+)?')\\n bool_t = Regex('([Yy]es|[Nn]o|[Tt]rue|[Ff]alse|[Oo]n|[Oo]ff)')\\n\\n # Helper definitions\\n kstr = quotedString.setParseAction(\\n removeQuotes) ^ float_t ^ int_t ^ bool_t ^ Word(prtable)\\n name = Word(alphas + \\\"_\\\", alphanums + \\\"_\\\")\\n vec = array_begin + delimitedList(\\n float_t ^ int_t ^ bool_t ^ Word(prtable) ^ Literal(\\\"\\\\n\\\").suppress() ^\\n quotedString.setParseAction(removeQuotes)) + array_end\\n sect = name + sect_begin\\n tag_sect = name + Group(tag_begin + name + tag_end) + sect_begin\\n\\n # Grammar\\n keyword = name + eql + kstr\\n vector = name + eql + vec\\n data = Combine(dmark + name) + SkipTo(end_data) + end_data\\n #section = Forward()\\n sect_def = (sect | tag_sect)\\n #input = section | data | vector | keyword\\n input = sect_def | data | vector | keyword | sect_end\\n #section << sect_def + ZeroOrMore(input) + sect_end\\n\\n # Parsing actions\\n int_t.setParseAction(token_actions.to_int)\\n float_t.setParseAction(token_actions.to_float)\\n bool_t.setParseAction(token_actions.to_bool)\\n keyword.setParseAction(token_actions.to_scalar)\\n vector.setParseAction(token_actions.to_array)\\n data.setParseAction(token_actions.to_data)\\n sect.setParseAction(token_actions.to_section)\\n tag_sect.setParseAction(token_actions.to_section)\\n sect_end.setParseAction(token_actions.end_of_section)\\n\\n bnf = ZeroOrMore(input) + StringEnd().setFailAction(\\n token_actions.parse_error)\\n bnf.ignore(pythonStyleComment)\\n\\n return Dict(bnf)\",\n \"def parse(s, tagVocabulary, pre=False):\\n n=RootNode(globalTagDict=tagVocabulary)\\n n.parse(lex(s, pre))\\n return n\",\n \"def _get_sub_types_of_compositional_types(compositional_type: str) -> Tuple[str, ...]:\\n sub_types_list = []\\n for valid_compositional_type in (\\n SPECIFICATION_COMPOSITIONAL_TYPES + PYTHON_COMPOSITIONAL_TYPES\\n ):\\n if compositional_type.startswith(valid_compositional_type):\\n inside_string = compositional_type[\\n compositional_type.index(\\\"[\\\") + 1 : compositional_type.rindex(\\\"]\\\")\\n ].strip()\\n while inside_string != \\\"\\\":\\n do_not_add = False\\n if inside_string.find(\\\",\\\") == -1: # No comma; this is the last sub-type\\n provisional_sub_type = inside_string.strip()\\n if (\\n provisional_sub_type == \\\"...\\\"\\n ): # The sub-string is ... used for Tuple, e.g. Tuple[int, ...]\\n do_not_add = True\\n else:\\n sub_type = provisional_sub_type\\n inside_string = \\\"\\\"\\n else: # There is a comma; this MAY not be the last sub-type\\n sub_string_until_comma = inside_string[\\n : inside_string.index(\\\",\\\")\\n ].strip()\\n if (\\n sub_string_until_comma.find(\\\"[\\\") == -1\\n ): # No open brackets; this is a primitive type and NOT the last sub-type\\n sub_type = sub_string_until_comma\\n inside_string = inside_string[\\n inside_string.index(\\\",\\\") + 1 :\\n ].strip()\\n else: # There is an open bracket'['; this is a compositional type\\n try:\\n closing_bracket_index = _match_brackets(\\n inside_string, inside_string.index(\\\"[\\\")\\n )\\n except SyntaxError:\\n raise SyntaxError(\\n \\\"Bad formatting. No matching close bracket ']' for the open bracket at {}\\\".format(\\n inside_string[\\n : inside_string.index(\\\"[\\\") + 1\\n ].strip()\\n )\\n )\\n sub_type = inside_string[: closing_bracket_index + 1].strip()\\n the_rest_of_inside_string = inside_string[\\n closing_bracket_index + 1 :\\n ].strip()\\n if (\\n the_rest_of_inside_string.find(\\\",\\\") == -1\\n ): # No comma; this is the last sub-type\\n inside_string = the_rest_of_inside_string.strip()\\n else: # There is a comma; this is not the last sub-type\\n inside_string = the_rest_of_inside_string[\\n the_rest_of_inside_string.index(\\\",\\\") + 1 :\\n ].strip()\\n if not do_not_add:\\n sub_types_list.append(sub_type)\\n return tuple(sub_types_list)\\n raise SyntaxError(\\n \\\"{} is not a valid compositional type.\\\".format(compositional_type)\\n )\",\n \"def parse(start_symbol, text, grammar):\\n tokenizer = grammar[' '] + '(%s)'\\n\\n def parse_sequence(sequence, text):\\n result = []\\n for atom in sequence:\\n tree, text = parse_atom(atom, text)\\n if text is None: return Fail\\n result.append(tree)\\n return result, text\\n\\n # see 'Speedy Parsing' in lesson 3 for why memo is useful here\\n # also, parse_atom is made to be an internal function so that it\\n # doesn't have to take grammar, a dictionary (read: mutable object),\\n # and hence just has to take two strings, which are mutable types\\n # hence, parse_atom can be memoized\\n @memo\\n def parse_atom(atom, text):\\n if atom in grammar: # Non-Terminal: tuple of alternatives\\n for alternative in grammar[atom]:\\n tree, rem = parse_sequence(alternative, text)\\n if rem is not None: return [atom]+tree, rem\\n return Fail\\n else: # Terminal: match characters against start of text\\n m = re.match(tokenizer % atom, text)\\n return Fail if not m else (m.group(1), text[m.end():]) # where the text advances in the code\\n\\n return parse_atom(start_symbol, text)\",\n \"def tree_build(sv, piece):\\r\\n if piece==None: return None \\r\\n # process various string expressions (or triplets without args for conditions and values)\\r\\n piece=piece[0].strip(Space) if type(piece)==tuple else piece.strip(Space) # convert to string \\r\\n alphabetic=Alphakwords+sv.Object_list\\r\\n \\r\\n # empty expression\\r\\n if not piece: return None\\r\\n\\r\\n # a string between quotes\\r\\n if piece[0]==Quote and piece[-1]==Quote: return (piece, None, None) # return string as a leaf\\r\\n \\r\\n # a protected string: restore without further parsing \\r\\n key=piece.strip(Special) \\r\\n if key in sv.Strings: return (Quote+sv.Strings[key]+Quote, None, None) # return string as a leaf\\r\\n\\r\\n # a bracketed expression: parse from outer ones on, RECURSIVE\\r\\n if key in sv.Blocks: return (Obr, tree_build(sv, sv.Blocks[key]), None)\\r\\n\\r\\n piece=save_bracketed(sv, piece) # protect outer bracketed expressions from parsing\\r\\n piece=Space+piece+Space # add Spaces to help detect alphabetic keys \\r\\n \\r\\n # PARSE by operator priority and descending order of position \\r\\n for op_group in Priority_groups+[sv.Object_list]: # ops by priority groups\\r\\n op_list=find_op(sv, piece, op_group, alphabetic) # detect operators of this group\\r\\n\\r\\n for o, op in op_list: # found ops from this group in reverse order of occurrence\\r\\n\\r\\n # process comma operator \\r\\n if o==Comma and o in piece: return make_list(sv, piece) # list will be linear (not a tree). Build RECURSIVE \\r\\n\\r\\n # process unary functions and defined objects (all unary operators are alphabetic)\\r\\n if o in Unary or o in sv.Object: # unary operators (non space-delimited)\\r\\n if piece.startswith(op): # operator must be at the start (space-delimited)\\r\\n res=make_unary(sv, piece, o, op)\\r\\n if res and (not res[1] or o in [Begin, End]):\\r\\n return special_unary(sv, res) # process special case \\r\\n return res\\r\\n \\r\\n # process binary operators (always lower priority than unary). Build RECURSIVE\\r\\n elif op in piece:\\r\\n res=make_binary(sv, piece, o, op) # binary operators (space-delimited)\\r\\n if res and (not res[1] or o==Isnot):\\r\\n return special_binary(sv, res) # process special case \\r\\n return res\\r\\n\\r\\n # process other (args and doubly) subscripted objects. Build RECURSIVE\\r\\n piece=piece.strip(Space)\\r\\n if Special+Bloc in piece: return make_subscripted(sv, piece) # the object is subscripted / has args\\r\\n\\r\\n # when all operators have been processed, only leaves remain\\r\\n return make_leaf(sv, piece)\",\n \"def split_tokens(s):\\n parts = []\\n parens = 0\\n for opar, cpar, unquoted, quoted, residue in TOKENS_FINDALL(s):\\n if unquoted:\\n parts.append(unquoted)\\n elif quoted:\\n parts.append(quoted[1:-1])\\n elif opar:\\n parens += 1\\n parts.append(opar)\\n elif cpar:\\n parens -= 1\\n parts.append(cpar)\\n elif residue == '$':\\n if not parens:\\n raise ValueError(\\\"'$' outside parenthesis in %r\\\" % (s))\\n else:\\n raise ValueError(residue, s)\\n if parens:\\n raise ValueError(\\\"Unbalanced parenthesis in %r\\\" % (s))\\n return parts\",\n \"def parse(s: str) -> StateFormula:\\n tree = PCTL_PARSER.parse(s.replace(\\\" \\\", \\\"\\\"))\\n return PCTLTransformer.transform(tree)\",\n \"def parse(s):\\n return expr.parseString(s, parseAll=True)\",\n \"def parse_tree_for_sub_component(self, index_1_beg, index_1_end,\\n index_2_beg, index_2_end, flag_string):\\n \\n tempo_2_beg = index_2_beg\\n tempo_2_end = index_2_end\\n if index_1_beg >= index_2_end:\\n index_2_beg = index_1_beg\\n index_2_end = index_1_end\\n index_1_beg = tempo_2_beg\\n index_1_end = tempo_2_end\\n\\n ## Path-enclosed Tree (PT)\\n if flag_string == SUBTREE_PT:\\n if index_2_end - index_1_beg > 1:\\n subtree_pos = self.tree.treeposition_spanning_leaves( index_1_beg, index_2_end )\\n lca = self.tree[subtree_pos]\\n no_of_leaves = self.number_of_leaves_before(subtree_pos)\\n return Tree.prune_tree(lca, index_1_beg - no_of_leaves, index_2_end - 1 - no_of_leaves)\\n else:\\n return self.tree[self.tree.treeposition_spanning_leaves( index_1_beg, index_2_end )[:-1]]\\n \\n ## Minimum Complete Tree (MCT)\\n if flag_string == SUBTREE_MCT:\\n if index_2_end - index_1_beg > 1:\\n lca = self.tree[self.tree.treeposition_spanning_leaves( index_1_beg, index_2_end )]\\n else:\\n lca = self.tree[self.tree.treeposition_spanning_leaves( index_1_beg, index_2_end )[:-1]]\\n return lca\\n\\n ## Context-Sensitive Path Tree (CSPT)\\n if flag_string == SUBTREE_CSPT:\\n if index_1_beg > 0:\\n index_1_beg -= 1\\n if index_2_end < len(self.tree.leaves()) - 1:\\n index_2_end += 1\\n subtree_pos = self.tree.treeposition_spanning_leaves( index_1_beg, index_2_end )\\n lca = self.tree[subtree_pos]\\n no_of_leaves = self.number_of_leaves_before(subtree_pos)\\n return Tree.prune_tree(lca, index_1_beg - no_of_leaves, index_2_end - 1 - no_of_leaves)\\n \\n ## Highly-pruned Path Tree (HPPT)\\n if flag_string == SUBTREE_HPPT:\\n # Get a single path tree that connect \\n # the two entities \\n return self.get_pruned_tree_path(index_1_beg, index_1_end,\\n index_2_beg, index_2_end, True)\",\n \"def split_citation_part(string: str):\\n\\n # Tokenization\\n\\n # fmt: off\\n string = regex.sub(\\n r\\\"(\\\"\\n r\\\"\\\\d+(?>\\\\.\\\\d+)?[a-z]?|\\\"\\n r\\\"\\\\b[ivx]+|\\\"\\n r\\\"\\\\b[a-z]\\\\)?\\\"\\n r\\\")\\\"\\n r\\\"(\\\\sff?\\\\.|\\\\sff\\\\b)\\\",\\n r\\\"\\\\1ff.\\\",\\n string,\\n flags=regex.IGNORECASE,\\n )\\n # fmt: on\\n tokens = split_unit_number_pattern.split(\\n string,\\n )\\n\\n # Building pairs of units with their resp. values\\n\\n while len(tokens) > 0:\\n token = tokens.pop(0)\\n if StatutesParser.is_unit(token):\\n if len(tokens) > 0:\\n unit = StatutesParser.stem_unit(token)\\n token = tokens.pop(0)\\n numb = token\\n assert StatutesParser.is_numb(numb), numb\\n else: # when citation ends with unit\\n print(\\n f\\\"Citation {string} ends with unit {token}. Ignoring last unit.\\\"\\n )\\n break\\n\\n elif StatutesParser.is_pre_numb(token):\\n numb = token\\n token = tokens.pop(0)\\n if not StatutesParser.is_unit(token):\\n print(token, \\\"is not a unit in\\\", string)\\n continue\\n # to fix citation \\\"§ 30 DRITTER ABSCHNITT\\\"\\n # Last part in now ignored,\\n # but reference areas can still be improved.\\n unit = StatutesParser.stem_unit(token)\\n\\n elif StatutesParser.is_numb(token):\\n unit = None\\n numb = token\\n else:\\n raise StringCaseException(token, \\\"in\\\", string)\\n numb = regex.sub(r\\\"(ff?\\\\.|ff|\\\\))$\\\", \\\"\\\", numb)\\n yield [unit, numb]\",\n \"def parse(self):\\n self.parse_lexical_symbols()\\n self.parse_cst()\\n self.promote_productions()\\n self.parse_color()\\n self.check_color_scoping()\\n for sym in self.GlobalSymbolDict.values():\\n sym.GlobalSymbolDict = self.GlobalSymbolDict\\n self.create_root_symbols()\\n self.check_for_multiple_roots()\",\n \"def genCompleteTypes(compoundSig):\\n i = 0\\n end = len(compoundSig)\\n\\n def find_end(idx, b, e):\\n depth = 1\\n while idx < end:\\n subc = compoundSig[idx]\\n if subc == b:\\n depth += 1\\n elif subc == e:\\n depth -= 1\\n if depth == 0:\\n return idx\\n idx += 1\\n\\n while i < end:\\n c = compoundSig[i]\\n\\n if c == '(':\\n x = find_end(i + 1, '(', ')')\\n yield compoundSig[i:x + 1]\\n i = x\\n\\n elif c == '{':\\n x = find_end(i + 1, '{', '}')\\n yield compoundSig[i:x + 1]\\n i = x\\n\\n elif c == 'a':\\n g = genCompleteTypes(compoundSig[i + 1:])\\n ct = next(g)\\n i += len(ct)\\n yield 'a' + ct\\n\\n else:\\n yield c\\n i += 1\",\n \"def _parse_unground_propositions(self, array):\\n prop_list = []\\n if array[0:3] == ['(', 'and', '(']:\\n array = array[2:-1]\\n #Split array into blocks\\n opencounter = 0\\n prop = []\\n for word in array:\\n if word == '(':\\n opencounter += 1\\n if word == ')':\\n opencounter -= 1\\n prop.append(word)\\n if opencounter == 0:\\n prop_list.append(self._parse_unground_proposition(prop))\\n prop = []\\n #print array[:array.index(')') + 1]\\n return prop_list\",\n \"def tokens_from_treestring(s):\\n return re.sub(r\\\"\\\\([0-9] |\\\\)\\\", \\\"\\\", s).split()\",\n \"def parse_nested_lists(s_in, init=True):\\n s_in = s_in.strip() \\n if init and ('[' != s_in[0] or ']' != s_in[-1]): \\n raise TypeError(\\\"%s is not a nested list\\\" % s_in) \\n elif init: s_in = s_in[1:-1] \\n\\n if '[' not in s_in: return [type_check.eval_type(i) for i in s_in.split(\\\",\\\")]\\n s_in = s_in + \\\",\\\" \\n lists = [] \\n count=0 \\n start, end=s_in.find('['), 0 \\n for i, c in enumerate(s_in): \\n if c == '[': count += 1 \\n elif c == ']': count -= 1 \\n \\n if count == 0 and c == ',': \\n new_l = s_in[start:i].strip() \\n if new_l[0] == '[': new_l = new_l[1:] \\n if new_l[-1] == ']': new_l = new_l[:-1] \\n lists.append(parse_nested_lists(new_l, False)) \\n start = s_in[i:].find(\\\",\\\") + i + 1 \\n \\n return lists\",\n \"def parser(ICDfile):\\n terms = defaultdict(set)\\n relationships = set()\\n definitions = defaultdict()\\n ICDfile = ICDfile[0]\\n #version = ICDfile.split('/')[1].split('_')[1]\\n first = True\\n with open(ICDfile, 'r') as fh:\\n for line in fh:\\n if first:\\n first = False\\n continue\\n data = line.rstrip(\\\"\\\\r\\\\n\\\").split(\\\"\\\\t\\\")\\n icdCode = data[0]\\n icdTerm = data[1]\\n chapter = data[2]\\n chapId = data[3]\\n block = data[4]\\n blockId = data[5]\\n\\n terms[icdCode].add(icdTerm)\\n definitions[icdCode] = \\\"term\\\"\\n terms[chapId].add(chapter)\\n definitions[chapId] = \\\"chapter\\\"\\n terms[blockId].add(block)\\n definitions[blockId] = \\\"block\\\"\\n\\n if len(icdCode) > 3:\\n order = len(icdCode) - 1\\n i = 3\\n while i <= order:\\n if icdCode[0:i] in terms:\\n relationships.add((icdCode, icdCode[0:i], \\\"HAS_PARENT\\\"))\\n i += 1\\n\\n relationships.add((icdCode, chapId, \\\"HAS_PARENT\\\"))\\n relationships.add((icdCode, blockId, \\\"HAS_PARENT\\\"))\\n relationships.add((blockId, chapId, \\\"HAS_PARENT\\\"))\\n\\n return terms, relationships, definitions\",\n \"def parse(self, string, top_rule=None):\\n inputter = Inputter(string)\\n rule = self.top_rule if top_rule == None else self.rule_dict[top_rule]\\n return rule.parse(inputter)\",\n \"def substrings(s):\\n if s:\\n yield from prefixes(s) # 获得当前s的所有prefix\\n yield from substrings(s[1:])\",\n \"def subparse(block):\\n\\n verses = []\\n context = None\\n for char in block:\\n\\n if char == \\\"[\\\":\\n if verses: verses[-1][\\\"quran\\\"] = verses[-1][\\\"quran\\\"].strip()\\n verses.append({\\\"surah\\\": \\\"\\\", \\\"verse\\\": \\\"\\\", \\\"quran\\\": \\\"\\\"})\\n context = \\\"surah\\\"\\n elif char == \\\":\\\" and context == \\\"surah\\\":\\n verses[-1][\\\"surah\\\"] = int(verses[-1][\\\"surah\\\"])\\n context = \\\"verse\\\"\\n elif char == \\\"]\\\":\\n verses[-1][\\\"verse\\\"] = int(verses[-1][\\\"verse\\\"])\\n context = \\\"quran\\\"\\n else: verses[-1][context] += char\\n\\n verses[-1][\\\"quran\\\"] = verses[-1][\\\"quran\\\"].strip()\\n return verses\",\n \"def parse_sexprs(ppddl_txt):\\n tokens = _ppddl_tokenize(ppddl_txt)\\n parse_root = parse_ptr = HList(None)\\n # we parse begin -> end\\n # just reverse so that pop() is efficient\\n tokens_reverse = tokens[::-1]\\n while tokens_reverse:\\n token = tokens_reverse.pop()\\n if token == '(':\\n # push\\n new_ptr = HList(parse_ptr)\\n parse_ptr.append(new_ptr)\\n parse_ptr = new_ptr\\n elif token == ')':\\n # pop\\n parse_ptr = parse_ptr.parent\\n else:\\n # add\\n parse_ptr.append(token)\\n return parse_root\",\n \"def get_compound_noun( ngram ):\\n try:\\n pattern = re.compile( '((?: ?\\\\\\\\b[^\\\\\\\\s]+(?:/NN.?/[a-z]+/[\\\\\\\\d]+)){2,})' )\\n match = re.search( pattern, ngram )\\n if match:\\n compound = ''\\n contains_root = False\\n tokens = match.group().strip().split(' ')\\n for t in tokens:\\n # embed()\\n items = t.split('/')\\n compound += ( items[0] + ' ' )\\n if items[3] == 0:\\n contains_root = True\\n if contains_root:\\n return compound\\n else:\\n return None\\n else:\\n return None\\n \\n except ValueError:\\n return None\",\n \"def _parseString(self, instring):\\n\\n if self._compiled is None:\\n self.compile()\\n\\n match = self._compiled.match(instring)\\n if match is None:\\n return None\\n\\n Count.reset()\\n struct = deepcopy(self.structure)\\n\\n mymatch, substructs, preprocess_func = self._parse_preprocess(match)\\n struct.map(preprocess_func)\\n struct.map(self._func_parse_leaf(mymatch, substructs))\\n struct.parse_end = match.end()\\n return struct\",\n \"def parse_formula(formula, periodic_table_dict):\\n assert isinstance(formula, str), \\\\\\n \\\"wrong data type for parameter formula; \\\" \\\\\\n f\\\"formula is a {type(formula)} but must be a string\\\"\\n assert isinstance(periodic_table_dict, dict), \\\\\\n \\\"wrong data type for parameter periodic_table_dict; \\\" \\\\\\n f\\\"periodic_table_dict is a {type(periodic_table_dict)} \\\" \\\\\\n \\\"but must be a dictionary\\\"\\n\\n def parse_quant(formula, index):\\n quant = 1\\n if index < len(formula) and formula[index].isdecimal():\\n if formula[index] == \\\"0\\\":\\n raise FormulaError(\\\"invalid formula, \\\"\\n \\\"quantity begins with zero (0), perhaps \\\"\\n \\\"you meant to type capital O for Oxygen \\\"\\n \\\"instead of zero\\\", formula, index)\\n start = index\\n index += 1\\n while index<len(formula) and formula[index].isdecimal():\\n index += 1\\n quant = int(formula[start:index])\\n return quant, index\\n\\n def get_quant(elem_dict, symbol):\\n return 0 if symbol not in elem_dict else elem_dict[symbol]\\n\\n def parse_r(formula, index, level):\\n start_index = index\\n start_level = level\\n elem_dict = {}\\n while index < len(formula):\\n ch = formula[index]\\n if ch == \\\"(\\\":\\n group_dict, index = parse_r(formula,index+1,level+1)\\n quant, index = parse_quant(formula, index)\\n for symbol in group_dict:\\n prev = get_quant(elem_dict, symbol)\\n curr = prev + group_dict[symbol] * quant\\n elem_dict[symbol] = curr\\n elif ch.isalpha():\\n symbol = formula[index:index+2]\\n if symbol in periodic_table_dict:\\n index += 2\\n else:\\n symbol = formula[index:index+1]\\n if symbol in periodic_table_dict:\\n index += 1\\n else:\\n raise FormulaError(\\\"invalid formula; \\\"\\n f\\\"unknown element symbol: {symbol}\\\",\\n formula, index)\\n quant, index = parse_quant(formula, index)\\n prev = get_quant(elem_dict, symbol)\\n elem_dict[symbol] = prev + quant\\n elif ch == \\\")\\\":\\n if level == 0:\\n raise FormulaError(\\\"invalid formula; \\\"\\n \\\"unmatched close parenthesis\\\",\\n formula, index)\\n level -= 1\\n index += 1\\n break\\n else:\\n if ch.isdecimal():\\n # Decimal digit not preceded by an\\n # element symbol or close parenthesis\\n message = \\\"invalid formula\\\"\\n else:\\n # Illegal character: [^()0-9a-zA-Z]\\n message = \\\"invalid formula; \\\" + \\\\\\n f\\\"illegal character: {ch}\\\"\\n raise FormulaError(message, formula, index)\\n if level > 0 and level >= start_level:\\n raise FormulaError(\\\"invalid formula; \\\"\\n \\\"unmatched open parenthesis\\\",\\n formula, start_index - 1)\\n return elem_dict, index\\n\\n # Return the compound list of element symbols and\\n # quantities. Each element in the compound list\\n # will be a list in this form: [\\\"symbol\\\", quantity]\\n elem_dict, _ = parse_r(formula, 0, 0)\\n return list(elem_dict.items())\",\n \"def parse_tags(source):\\n unmatched_count = 0\\n start_pos = 0\\n opened = False\\n open_pos = 0\\n cur_pos = 0\\n\\n finished = []\\n segments = []\\n\\n for character in source:\\n #scan for mismatched parenthesis:\\n if character == '(':\\n unmatched_count += 1\\n if not opened:\\n open_pos = cur_pos\\n opened = True\\n\\n if character == ')':\\n unmatched_count -= 1\\n\\n if opened and unmatched_count == 0:\\n clean = source[start_pos:open_pos]\\n clean = clean.strip()\\n if clean:\\n finished.extend(clean.split())\\n\\n segment = source[open_pos:cur_pos+1]\\n #segments.append(segment)\\n \\n #get rid of bounding parentheses:\\n pruned = segment[1:-1]\\n group = pruned.split()\\n finished.append(group)\\n\\n opened = False\\n start_pos = cur_pos+1\\n \\n cur_pos += 1\\n\\n assert unmatched_count == 0\\n\\n if start_pos != cur_pos:\\n #get anything that was left over here\\n remainder = source[start_pos:cur_pos].strip()\\n finished.extend(remainder.split())\\n \\n ## #now check on recursion:\\n ## for item in segments:\\n ## #get rid of bounding parentheses:\\n ## pruned = item[1:-1]\\n ## if recurse:\\n ## results = parse_tags(pruned, recurse)\\n ## finished.expand(results)\\n ## else:\\n ## finished.append(pruned.strip())\\n \\n return finished\",\n \"def expand_to_valid_structure(string, beg, end, fst, snd):\\n assert 0 <= beg <= end <= len(string)\\n\\n beg_level, end_level = find_nesting_levels(string, beg, end, fst, snd)\\n\\n # First find nbeg\\n i = beg - 1\\n if beg_level == 0:\\n nbeg = beg\\n else:\\n nbeg = None\\n while i >= 0:\\n if string[i] == fst:\\n if beg_level > 0:\\n beg_level -= 1\\n else:\\n nbeg = i\\n break\\n elif string[i] == snd:\\n beg_level += 1\\n i -= 1\\n\\n # Then find nend\\n i = end\\n if end_level == 0:\\n nend = end\\n else:\\n nend = None\\n while i < len(string):\\n if string[i] == snd:\\n if end_level > 0:\\n end_level -= 1\\n else:\\n nend = i + 1\\n break\\n elif string[i] == fst:\\n end_level += 1\\n i += 1\\n\\n if nbeg != None and nend != None:\\n return Interval(nbeg, nend)\",\n \"def parse_maths_string(string:str, parent_name:str, variables:dict):\\n if string == \\\"\\\":\\n return None\\n maths_tree = MathTree.construct_tree(string, parent_name, variables)\\n \\n val = maths_tree.get_tree_value(parent_name)\\n #print(\\\"String:\\\",string)\\n #print(\\\"Maths Tree:\\\", maths_tree)\\n #print(\\\"result:\\\",val)\\n #print()\\n \\n return val\",\n \"def parse(string):\\n \\n global local_vars\\n print \\\"parse(\\\"+string+\\\")\\\"\\n\\n # variables\\n if string in local_vars: # e.g. 'y'\\n return string\\n elif string == 'it':\\n # print 'it: ',references[0]\\n return g.it\\n\\n # operators\\n elif string.find('\\\\gamma') == 0:\\n return gamma(string[7],string[9:-1])\\n elif string.find('\\\\iota') == 0:\\n # treating iota as gamma for now\\n return iota(string[6],string[8:-1])\\n\\n # function application\\n else:\\n fun = string.split( '(' , 1)[0]\\n arg = parse(string.split( '(' , 1)[1][:-1])\\n exec(fun+'(arg)')\",\n \"def parse(string):\\r\\n \\r\\n global local_vars\\r\\n # print \\\"parse(\\\"+string+\\\")\\\"\\r\\n\\r\\n # variables\\r\\n if string in local_vars: # e.g. 'y'\\r\\n return string\\r\\n elif string == 'it':\\r\\n # print 'it: ',references[0]\\r\\n return g.it\\r\\n\\r\\n # operators\\r\\n elif string.find('\\\\gamma') == 0:\\r\\n return gamma(string[7],string[9:-1])\\r\\n elif string.find('\\\\iota') == 0:\\r\\n # treating iota as gamma for now\\r\\n return iota(string[6],string[8:-1])\\r\\n\\r\\n # function application\\r\\n else:\\r\\n fun = string.split( '(' , 1)[0]\\r\\n arg = parse(string.split( '(' , 1)[1][:-1])\\r\\n exec(fun+'(arg)')\",\n \"def getNodeTreeFromStr(string):\\n document = publish_doctree(string)\\n\\n return list([node for node in document.traverse()[1:] if node.parent == document]) # we've to return the chidren of the document, as returning the document itself, seems to duplicate the content of the current file being processed.\",\n \"def _parse_query(queryStr):\\n mainNode = LogicNode.LogicNode()\\n queryStr = queryStr.replace(' ','')\\n \\n logicList, myOPList = _break_query(queryStr)\\n\\n #converts operator strings to actual operators\\n convertOp = {\\n '&':operator.and_,\\n '|':operator.or_,\\n '^':operator.xor\\n }\\n\\n for item in myOPList:\\n mainNode.operators.append(convertOp[item])\\n \\n #adds the simple comparisons to the LogicNode\\n mainNode.add_children(logicList)\\n return mainNode\",\n \"def parse_logic(logic):\\n\\n ###print \\\"parse_logic(logic): logic:\\\",logic\\n\\n tokens = logic.split()\\n\\n # begin recursive logic parse\\n return grammar_0(tokens)\",\n \"def getleaf(tre_str):\\n leaves = []\\n tmp = tre_str.split(\\\",\\\")\\n for i in tmp:\\n i = i.replace(\\\"(\\\", \\\"\\\").replace(\\\")\\\", \\\"\\\").replace(\\\":\\\", \\\"\\\")\\n if \\\"_\\\" in i:\\n if \\\" \\\" in i:\\n leaves.append(i.strip().split()[0])\\n else:\\n leaves.append(i)\\n return leaves\",\n \"def parse_tags(tagstring):\\n if not tagstring:\\n return []\\n\\n tagstring = force_str(tagstring)\\n\\n words = []\\n buffer = []\\n # Defer splitting of non-quoted sections until we know if there are\\n # any unquoted commas.\\n to_be_split = []\\n i = iter(tagstring)\\n try:\\n while True:\\n c = six.next(i)\\n if c == '\\\"':\\n if buffer:\\n to_be_split.append(''.join(buffer))\\n buffer = []\\n c = six.next(i)\\n while c != '\\\"':\\n buffer.append(c)\\n c = six.next(i)\\n if buffer:\\n word = ''.join(buffer).strip()\\n if word:\\n words.append(word)\\n buffer = []\\n else:\\n buffer.append(c)\\n except StopIteration:\\n # If we were parsing an open quote which was never closed treat\\n # the buffer as unquoted.\\n if buffer:\\n to_be_split.append(''.join(buffer))\\n if to_be_split:\\n for chunk in to_be_split:\\n words.extend(split_strip(chunk, settings.TAGGIT_SELECTIZE['DELIMITER']))\\n words = list(set(words))\\n words.sort()\\n return words\",\n \"def parseComposite(s):\\n\\n answerlist = []\\n try:\\n RespDict = json.loads(s)\\n except:\\n return None\\n for records in RespDict[\\\"Response\\\"]:\\n if('Type' in records):\\n for record in records[\\\"Response\\\"]:\\n if(record is None):\\n continue\\n if(records['Type'] == 'T'):\\n if (record[\\\"Selected\\\"] is True):\\n if (record['val'].find(\\\"<math\\\") != -1):\\n value = MathMLExtraction(record[\\\"val\\\"])\\n else:\\n value=record['val']\\n answerlist.append(\\\"{}-{}\\\".format(records[\\\"PartId\\\"], value))\\n elif(records['Type'] == 'MATCHMS'):#MatchMS\\n value=\\\"{}-{}\\\".format(record['source'], record['target'])\\n answerlist.append(\\\"{}-{}\\\".format(records[\\\"PartId\\\"], value))\\n elif(records['Type']=='MCSS' or records['Type'] == 'MCMS' or records['Type'] == 'MAPMS' or\\n records['Type'] == 'MAPSS' or records['Type'] == 'InlineChoices'):\\n #MAPMS and MAPSS look the same as MCMS and MCSS\\n if (record[\\\"Selected\\\"] is True):\\n if (record[\\\"val\\\"] == \\\"\\\"):\\n value='X'\\n else:\\n value=record[\\\"val\\\"]\\n answerlist.append(\\\"{}-{}\\\".format(records[\\\"PartId\\\"], value))\\n else:\\n warnings.warn(\\\"Type is missing for Part ID\\\", records['PartId'])\\n continue\\n return answerlist\",\n \"def deserialize(st: str, words: Optional[List] = None, convert_underscores: bool = True) -> Tuple[TreeNode, List]:\\n tree_stack = []\\n current_depth = 0\\n last_token = ''\\n root = TreeNode()\\n tree_stack.append((root, current_depth))\\n next_is_distance = False\\n\\n combo = []\\n my_stack = []\\n my_stack.append((combo, current_depth))\\n\\n for token in _tokenize_newick(st, convert_underscores=convert_underscores):\\n # Check for a label\\n if last_token not in '(,):':\\n val = Sequence(words[int(last_token)]) if words else int(last_token)\\n if not next_is_distance:\\n tree_stack[-1][0].name = val if last_token else None\\n else:\\n next_is_distance = False\\n if last_token:\\n my_stack[-1][0].append(val)\\n else:\\n my_stack[-1][0].append(None)\\n\\n # Check for a distance\\n if token == ':':\\n next_is_distance = True\\n elif last_token == ':':\\n try:\\n tree_stack[-1][0].length = float(token)\\n except ValueError:\\n raise NewickFormatError(\\\"Could not read length as numeric type\\\"\\n \\\": %s.\\\" % token)\\n elif token == '(':\\n current_depth += 1\\n tree_stack.append((TreeNode(), current_depth))\\n my_stack.append((list(), current_depth))\\n elif token == ',':\\n tree_stack.append((TreeNode(), current_depth))\\n my_stack.append((list(), current_depth))\\n elif token == ')':\\n if len(tree_stack) < 2:\\n raise NewickFormatError(\\\"Could not parse file as newick.\\\"\\n \\\" Parenthesis are unbalanced.\\\")\\n children = []\\n my_children = []\\n # Pop all nodes at this depth as they belong to the remaining\\n # node on the top of the stack as children.\\n while current_depth == tree_stack[-1][1]:\\n node, _ = tree_stack.pop()\\n children.insert(0, node)\\n nc, _ = my_stack.pop()\\n [my_children.insert(0, c) for c in nc]\\n parent = tree_stack[-1][0]\\n my_parent = my_stack[-1][0]\\n\\n if parent.children:\\n raise NewickFormatError(\\\"Could not parse file as newick.\\\"\\n \\\" Contains unnested children.\\\")\\n # This is much faster than TreeNode.extend\\n for child in children:\\n child.parent = parent\\n parent.children = children\\n\\n my_parent.append(my_children)\\n\\n current_depth -= 1\\n elif token == ';':\\n if len(tree_stack) == 1:\\n return root, my_stack\\n break\\n\\n last_token = token\\n\\n raise NewickFormatError(\\\"Could not parse file as newick.\\\"\\n \\\" `(Parenthesis)`, `'single-quotes'`,\\\"\\n \\\" `[comments]` may be unbalanced, or tree may be\\\"\\n \\\" missing its root.\\\")\",\n \"def search_productions(citem, chart):\\n if len(chart[citem]) == 0:\\n return [] \\n if citem == \\\"START\\\":\\n return [{\\\"START\\\":child[0]} for child in chart[citem]]\\n \\n prodlist = list(chart[citem])\\n lefts = set(x[0] for x in prodlist)\\n lengths = set(len(x) for x in prodlist)\\n assert len(lengths) == 1\\n split_len = lengths.pop()\\n \\n # figure out all items that could have been used to complete this nonterminal \\n result = [] \\n if prodlist[0][0].target == Item.NONTERMINAL:\\n assert split_len == 2\\n symbol = prodlist[0][0].outside_symbol, prodlist[0][0].outside_index\\n for child in prodlist: \\n assert child[1].target == Item.ROOT\\n other_nts = search_productions(child[0], chart) \\n if other_nts:\\n for option in other_nts:\\n d = dict(option)\\n d[symbol] = child[1]\\n result.append(d)\\n else:\\n result.append(dict([(symbol, child[1])]))\\n return result\\n \\n elif prodlist[0][0].target == Item.BINARY:\\n assert split_len == 2\\n for child in prodlist: \\n assert len(child) == 2\\n r1 = search_productions(child[0], chart)\\n r2 = search_productions(child[1], chart)\\n if r1 and r2: #possibilities: all combinations of assignments to NTs in the subtree\\n other_iterator = itertools.product(r1,r2)\\n for p1, p2 in other_iterator:\\n nts = dict(p1)\\n nts.update(p2)\\n result.append(nts)\\n else: # Only one of the subtrees has nonterminals. \\n result.extend(r1)\\n result.extend(r2)\\n return result \\n\\n elif prodlist[0][0].target == Item.TERMINAL:\\n for child in prodlist: \\n assert len(child) == 1\\n other_nts = search_productions(child[0], chart)\\n if other_nts:\\n result.extend(other_nts)\\n return result\",\n \"def build_subtoken_index(self):\\n terms = []\\n with open(self.path_token_terms, 'r', encoding='utf8') as f:\\n for line in f:\\n term = line.strip('\\\\n')\\n terms.append(term)\\n terms = set(terms)\\n for term in terms:\\n term_list = term.split('_')\\n subterms = get_sublists(term_list)\\n self.subtoken_index[term] = [t for t in subterms\\n if '_'.join(t) in terms]\",\n \"def parse_lisp_helper(lisp_code, start_index):\\n assert lisp_code[start_index] == \\\"(\\\"\\n first_closing_paren = lisp_code.find(\\\")\\\", start_index)\\n next_opening_paren = lisp_code.find(\\\"(\\\", start_index+1)\\n\\n # base case, no more opening paren\\n if next_opening_paren < 0 or next_opening_paren > first_closing_paren:\\n return split_and_cast(lisp_code[start_index+1:first_closing_paren], \\\" \\\"), \\\\\\n first_closing_paren\\n\\n # inductive case\\n ast = split_and_cast(lisp_code[start_index+1: next_opening_paren], \\\" \\\")\\n while next_opening_paren > 0 and lisp_code[first_closing_paren:]: \\n sub_ast, first_closing_paren = parse_lisp_helper(lisp_code,\\n next_opening_paren)\\n ast.append(sub_ast)\\n next_opening_paren = lisp_code.find(\\\"(\\\", first_closing_paren+1)\\n\\n # add all the scalar values between the closing bracket, and next\\n # opening bracket\\n if next_opening_paren > 0 and next_opening_paren > first_closing_paren:\\n values = split_and_cast(lisp_code[first_closing_paren+1:next_opening_paren], \\\" \\\")\\n ast.extend(values)\\n\\n\\n # now finish parsing everything else after the last set of parens\\n if first_closing_paren > -1:\\n next_closing_paren = lisp_code.find(\\\")\\\", first_closing_paren+1)\\n ast.extend(split_and_cast(lisp_code[first_closing_paren+1:next_closing_paren], \\\\\\n \\\" \\\"))\\n else:\\n next_closing_paren = len(lisp_code)\\n\\n return ast, next_closing_paren\",\n \"def parse_expression(\\n root: typing.Optional[Sequence],\\n text: str,\\n end: typing.List[str] = None,\\n is_literal=True,\\n) -> typing.Optional[int]:\\n end = end or []\\n found: bool = False\\n next_index: int = 0\\n literal: str = \\\"\\\"\\n last_taggable: typing.Optional[Taggable] = None\\n last_group: typing.Optional[Sequence] = root\\n\\n # Process text character-by-character\\n for current_index, c in enumerate(text):\\n if current_index < next_index:\\n # Skip ahread\\n current_index += 1\\n continue\\n\\n # Get previous character\\n if current_index > 0:\\n last_c = text[current_index - 1]\\n else:\\n last_c = \\\"\\\"\\n\\n next_index = current_index + 1\\n\\n if c in end:\\n # Found end character of expression (e.g., ])\\n next_index += 1\\n found = True\\n break\\n\\n if (c == \\\":\\\") and (last_c in [\\\")\\\", \\\"]\\\"]):\\n # Handle sequence substitution\\n assert isinstance(last_taggable, Substitutable)\\n next_index = parse_expression(\\n None, text[current_index + 1 :], end=[\\\" \\\"] + end, is_literal=False\\n )\\n\\n if next_index is None:\\n # End of text\\n next_index = len(text) + 1\\n else:\\n next_index += current_index - 1\\n\\n last_taggable.substitution = text[current_index + 1 : next_index].strip()\\n\\n elif c in [\\\"<\\\", \\\"(\\\", \\\"[\\\", \\\"{\\\", \\\"|\\\"]:\\n # Begin group/tag/alt/etc.\\n\\n # Break literal here\\n literal = literal.strip()\\n if literal:\\n assert last_group is not None\\n words = list(split_words(literal))\\n last_group.items.extend(words)\\n\\n last_taggable = words[-1]\\n literal = \\\"\\\"\\n\\n if c == \\\"<\\\":\\n # Rule reference\\n assert last_group is not None\\n rule = RuleReference()\\n next_index = current_index + parse_expression(\\n None, text[current_index + 1 :], end=[\\\">\\\"], is_literal=False\\n )\\n\\n rule_name = text[current_index + 1 : next_index - 1]\\n if \\\".\\\" in rule_name:\\n # Split by last dot\\n last_dot = rule_name.rindex(\\\".\\\")\\n rule.grammar_name = rule_name[:last_dot]\\n rule.rule_name = rule_name[last_dot + 1 :]\\n else:\\n # Use entire name\\n rule.rule_name = rule_name\\n\\n rule.text = text[current_index:next_index]\\n last_group.items.append(rule)\\n last_taggable = rule\\n elif c == \\\"(\\\":\\n # Group (expression)\\n assert last_group is not None\\n group = Sequence(type=SequenceType.GROUP)\\n next_index = current_index + parse_expression(\\n group, text[current_index + 1 :], end=[\\\")\\\"]\\n )\\n\\n group = unwrap_sequence(group)\\n group.text = text[current_index + 1 : next_index - 1]\\n last_group.items.append(group)\\n last_taggable = group\\n elif c == \\\"[\\\":\\n # Optional\\n # Recurse with group sequence to capture multi-word children.\\n optional_seq = Sequence(type=SequenceType.GROUP)\\n next_index = current_index + parse_expression(\\n optional_seq, text[current_index + 1 :], end=[\\\"]\\\"]\\n )\\n\\n optional_seq = unwrap_sequence(optional_seq)\\n optional = Sequence(type=SequenceType.ALTERNATIVE)\\n if optional_seq.items:\\n if (\\n (len(optional_seq.items) == 1)\\n and (not optional_seq.tag)\\n and (not optional_seq.substitution)\\n ):\\n # Unpack inner item\\n inner_item = optional_seq.items[0]\\n optional.items.append(inner_item)\\n elif optional_seq.type == SequenceType.ALTERNATIVE:\\n # Unwrap inner alternative\\n optional.items.extend(optional_seq.items)\\n else:\\n # Keep inner group\\n optional_seq.text = text[current_index + 1 : next_index - 1]\\n optional.items.append(optional_seq)\\n\\n # Empty alternative\\n optional.items.append(Word(text=\\\"\\\"))\\n optional.text = text[current_index + 1 : next_index - 1]\\n last_group.items.append(optional)\\n last_taggable = optional\\n elif c == \\\"{\\\":\\n assert last_taggable is not None\\n tag = Tag()\\n\\n # Tag\\n next_index = current_index + parse_expression(\\n None, text[current_index + 1 :], end=[\\\"}\\\"], is_literal=False\\n )\\n\\n # Exclude {}\\n tag.tag_text = text[current_index + 1 : next_index - 1]\\n\\n if \\\":\\\" in tag.tag_text:\\n lhs, rhs = tag.tag_text.split(\\\":\\\", maxsplit=1)\\n tag.tag_text = lhs\\n tag.substitution = rhs\\n\\n last_taggable.tag = tag\\n elif c == \\\"|\\\":\\n assert root is not None\\n if root.type != SequenceType.ALTERNATIVE:\\n # Create alternative\\n alternative = Sequence(type=SequenceType.ALTERNATIVE)\\n if len(root.items) == 1:\\n # Add directly\\n alternative.items.append(root.items[0])\\n else:\\n # Wrap in group\\n last_group = Sequence(type=SequenceType.GROUP, items=root.items)\\n alternative.items.append(last_group)\\n\\n # Modify original sequence\\n root.items = [alternative]\\n\\n # Overwrite root\\n root = alternative\\n\\n if not last_group.text:\\n # Fix text\\n last_group.text = \\\" \\\".join(item.text for item in last_group.items)\\n\\n # Create new group for any follow-on expressions\\n last_group = Sequence(type=SequenceType.GROUP)\\n alternative.items.append(last_group)\\n else:\\n # Accumulate into current literal\\n literal += c\\n\\n # End of expression; Break literal.\\n literal = literal.strip()\\n if is_literal and literal:\\n assert root is not None\\n words = list(split_words(literal))\\n last_group.items.extend(words)\\n\\n if last_group:\\n if len(last_group.items) == 1:\\n # Simplify final group\\n root.items[-1] = last_group.items[0]\\n elif not last_group.text:\\n # Fix text\\n last_group.text = \\\" \\\".join(item.text for item in last_group.items)\\n\\n if end and (not found):\\n # Signal end not found\\n return None\\n\\n return next_index\",\n \"def parse_string(self, in_str):\\n match = MAIN_REGEX.search(in_str)\\n if not match:\\n err_str = \\\"Unable to parse string: %s\\\" % in_str\\n raise ValueError(err_str)\\n self.parse_completed(match.group(1))\\n self.parse_priority(match.group(2))\\n if match.group(3) and match.group(4):\\n self.parse_completion_date(match.group(3))\\n self.parse_creation_date(match.group(4))\\n else:\\n self.parse_creation_date(match.group(3))\\n self.parse_description(match.group(5))\",\n \"def parse_string(str_value):\\n comps = str_value.split(\\\"/\\\")\\n assert len(comps) <= 2, \\\"Cannot parse {0} as Rational\\\".format(str_value) \\n \\n num_string = comps[0].strip()\\n if (len(comps) == 1):\\n return Rational(int(num_string))\\n else:\\n den_string = comps[1].strip()\\n return Rational(int(num_string), int(den_string))\",\n \"def parse_expression(str_expression):\\n expression = convert_to_postfix(str_expression)\\n var_count = count_arguments(str_expression)\\n table = init_table(var_count)\\n parsed_table = [[] for i in range(len(table))]\\n\\n for token in expression:\\n for i, row in enumerate(table):\\n if token in string.ascii_uppercase:\\n parsed_table[i].append(row[ord(token) - 65])\\n else:\\n parsed_table[i].append(token)\\n\\n for i, row in enumerate(parsed_table):\\n table[i].append(solve(row))\\n\\n return table\",\n \"def opsplit(expstr):\\n\\n #ops are the one char operators (sorted on precidence)\\n ops = expr.getOps()\\n #Remove outer parentesis if we have them\\n if expstr[0] == '(' and expstr[-1] == ')' and balanced(expstr[1:-1]):\\n expstr = expstr[1:-1]\\n #Add a '0' to the beginning of the string if we start with an operator\\n if expstr[0] in ops:\\n expstr = '0'+expstr\\n for op in ops:\\n pc = 0\\n cc = len(expstr)-1\\n revexpstr = list(expstr)\\n revexpstr.reverse()\\n #Search for the operator backwards (to preserve operator presidence)\\n for c in revexpstr:\\n if c == '(':\\n pc += 1\\n elif c == ')':\\n pc -= 1\\n if c == op and pc == 0:\\n #Build the tree recursively\\n return [op,opsplit(expstr[:cc]),opsplit(expstr[cc+1:])]\\n cc -=1\\n #if we find something that looks like a function, parse it separately \\n if funcpattern(expstr):\\n fnamestr = funcname(expstr)\\n fargs = funcargs(expstr)\\n farglist = [opsplit(arg) for arg in fargs]\\n return [fnamestr]+farglist\\n return expstr\",\n \"def search_in_tree(self, tree, substring):\\n s_options_for_match = set()\\n node = tree\\n idx = 0\\n substring_length = len(substring)\\n while idx < substring_length and len(node[substring[idx]]) != 0:\\n node = node[substring[idx]]\\n s_options_for_match.update(node['end'])\\n idx += 1\\n if idx == substring_length:\\n s_options_for_match.update(node['part'])\\n\\n return s_options_for_match\",\n \"def _parse_ins_string(string):\\n istart_markers = set([\\\"[\\\", \\\"(\\\", \\\"!\\\"])\\n marker_dict = {\\\"[\\\": \\\"]\\\", \\\"(\\\": \\\")\\\", \\\"!\\\": \\\"!\\\"}\\n # iend_markers = set([\\\"]\\\",\\\")\\\",\\\"!\\\"])\\n setdum = {\\\"dum\\\", \\\"DUM\\\"}\\n obs_names = []\\n slen = len(string)\\n idx = 0\\n while True:\\n if idx >= slen - 1:\\n break\\n char = string[idx]\\n if char in istart_markers:\\n # em = iend_markers[istart_markers.index(char)]\\n em = marker_dict[char]\\n # print(\\\"\\\\n\\\",idx)\\n # print(string)\\n # print(string[idx+1:])\\n # print(string[idx+1:].index(em))\\n # print(string[idx+1:].index(em)+idx+1)\\n eidx = min(slen, string.find(em, idx + 1))\\n obs_name = string[idx + 1 : eidx]\\n if obs_name not in setdum:\\n obs_names.append(obs_name)\\n idx = eidx + 1\\n else:\\n idx += 1\\n return obs_names\",\n \"def sub_tag(str):\\n bracketed_tag = r\\\"(\\\\${\\\" + tag_start_char + tag_char + r\\\"*})\\\"\\n m = re.search(bracketed_tag, str)\\n if m:\\n tag = m.group(1)\\n tag = tag[2:len(tag)-1]\\n if tag not in tag_xpath:\\n raise ConversionError(\\\"Undefined tag in ${} substitution\\\", tag)\\n single_replace = str[:m.start()] + tag_xpath[tag] + str[m.end():]\\n return sub_tag(single_replace)\\n else:\\n return str\",\n \"def find_bracket_group(input_string, start):\\n return find_closure_group(input_string, start, group=[\\\"{\\\", \\\"}\\\"])\",\n \"def lexer(string): # TODO: refactor\\n parsedlist = []\\n parsedstring = ''\\n leftbcounter = 0\\n rightbcounter = 0\\n qcounter = 0\\n for index, a in enumerate(string):\\n if qcounter == 2:\\n if a.isalpha():\\n qcounter = 1\\n else:\\n qcounter = 0\\n if a == '(':\\n leftbcounter += 1\\n if a == ')':\\n rightbcounter += 1\\n if a == \\\"'\\\" and leftbcounter == rightbcounter:\\n qcounter += 1\\n if a != ' ' and leftbcounter == rightbcounter \\\\\\n and qcounter == 0:\\n parsedstring += a\\n if index+1 == len(string):\\n parsedlist.append(parsedstring)\\n parsedstring = ''\\n elif leftbcounter != rightbcounter:\\n parsedstring += a\\n elif qcounter > 0:\\n parsedstring += a\\n if index+1 == len(string):\\n parsedlist.append(parsedstring)\\n parsedstring = ''\\n else:\\n parsedlist.append(parsedstring)\\n parsedstring = ''\\n if leftbcounter != rightbcounter:\\n raise BadRequest()\\n bl = []\\n sl = []\\n counter = 0\\n for index, query in enumerate(parsedlist, 1):\\n if query == \\\"and\\\" or query == \\\"or\\\" or query == \\\"not\\\":\\n if sl:\\n bl.append(sl)\\n bl.append([query])\\n counter = 0\\n sl = []\\n continue\\n sl.append(query)\\n counter += 1\\n if index == len(parsedlist) and sl:\\n bl.append(sl)\\n # i later added a third nested list to seperate AND and OR\\n query_list = []\\n al = []\\n counter = 0\\n for index, grouped_query in enumerate(bl, 1):\\n if grouped_query[0] == \\\"or\\\":\\n query_list.append(al)\\n query_list.append([grouped_query])\\n counter = 0\\n al = []\\n continue\\n al.append(grouped_query)\\n counter += 1\\n if index == len(bl):\\n query_list.append(al)\\n\\n for x in query_list:\\n for y in x:\\n if y[0] == 'and' or y[0] == 'or' or y[0] == 'not':\\n QueryObjects.B.append(y[0])\\n continue\\n if y[0][0] == '(' and y[0][-1] == ')':\\n QueryObjects.B.append(y[0][0])\\n lexer(y[0][1:-1])\\n QueryObjects.B.append(y[0][-1])\\n else:\\n QueryObjects.IND += 1\\n n = 'arg' + str(QueryObjects.IND)\\n QueryObjects.D[n] = query_mapping(y, QueryObjects.IND)[\\\"query\\\"]\\n QueryObjects.B.append(n)\\n return QueryObjects.B\",\n \"def _is_compound_of(entry: _LexiconEntry) -> str:\\n return entry[\\\"is_compound\\\"].lower()\",\n \"def find_nesting_levels(string, beg, end, fst, snd):\\n beg_level = 0\\n end_level = 0\\n\\n for i in range(beg, end):\\n if string[i] == fst:\\n end_level += 1\\n if string[i] == snd:\\n if end_level > 0:\\n end_level -= 1\\n else:\\n beg_level += 1\\n\\n return beg_level, end_level\",\n \"def parse(string):\\n posslash = string.find('/')\\n if posslash < 0:\\n return Rational(int(string), 1)\\n else:\\n strs = string.split('/')\\n return Rational(int(strs[0].strip()), int(strs[1].strip()))\",\n \"def test_parse():\\n first = parse_formula(\\\"PO4H2(CH2)12CH3\\\")\\n assert first == {\\\"P\\\":1, \\\"O\\\":4, \\\"H\\\":29, \\\"C\\\":13}\\n\\n second = parse_formula(\\\"H2O\\\")\\n assert second == {\\\"H\\\":2, \\\"O\\\":1}\",\n \"def parse_cst(self):\\n stack = []\\n self.tokenizer.next().must_be('{')\\n for token in self.tokenizer:\\n stack += [ token ] # Build a stack to process\\n if token.text == \\\".\\\":\\n # We've got a rule to process. Start by determining correct syntax.\\n stack[1].must_be(':')\\n ## Name analysis\\n stack[0].assert_symbol_name()\\n production_elements = stack[2:-1]\\n for element in production_elements:\\n element.assert_symbol_name()\\n if stack[0].text in self.GlobalSymbolDict: # Redefined lexical sym or add a new production?\\n existingSymbol = self.GlobalSymbolDict[stack[0].text]\\n if existingSymbol.is_gla:\\n raise Exception(\\\"Lexical Symbol %s redefined at %d,%d. Originally at %d,%d\\\" % \\\\\\n (stack[0].text, stack[0].line, stack[0].col, \\\\\\n existingSymbol.defining_token.line, existingSymbol.defining_token.col))\\n existingSymbol.productions += [Production(existingSymbol,production_elements)]\\n else: # Brand new symbol occurrence\\n s = Symbol(stack[0])\\n s.is_gla = False\\n s.productions = [Production(s,production_elements)]\\n self.GlobalSymbolDict[stack[0].text] = s\\n stack = []\\n elif token.text == \\\"{\\\":\\n raise Exception(\\\"Unexpected %s\\\" % token)\\n elif token.text == \\\"}\\\":\\n if len(stack) > 1: raise Exception(\\\"Unfinished lexical specification beginning with %s\\\" % stack[0])\\n #pp = pprint.PrettyPrinter()\\n #pp.pprint(self.GlobalSymbolDict)\\n return\\n else: pass\",\n \"def _extract_terms(self, obj):\\r\\n terms = set()\\r\\n if 'paths' in obj:\\r\\n for path in obj['paths']:\\r\\n segs = re.split('[/{}]', path)\\r\\n for seg in segs:\\r\\n terms.add(seg.lower())\\r\\n self.terms = terms\",\n \"def construct_top_level_depends(terms):\\n assert len(terms) == 2\\n # Strip the end_of_input\\n deps = terms[0]\\n\\n if len(deps) == 1:\\n return deps[0]\\n elif not deps:\\n return None\\n else:\\n return Conjunction(deps)\",\n \"def parse_NFelt(K, s):\\n return K([QQ(c) for c in s.split(\\\",\\\")])\",\n \"def substrings(s):\\r\\n if s:\\r\\n yield from prefixes(s) # Get all the substrings that contains the first letter.\\r\\n yield from substrings(s[1:]) # Slice the first letter of s, then get substrings of s[1:]\\r\",\n \"def parse_str( s: str ) -> list:\\n\\n tree = ET.fromstring( s )\\n if tree is None: return None\\n return parse_tree( tree )\",\n \"def parse_search_terms(self, search_terms):\\n # v. kludgish.. TODO: do this a little more gracefully\\n self.search_terms, b = [], []\\n for index, st in enumerate(search_terms):\\n if st == \\\"OR\\\":\\n self.search_terms.append(b)\\n b = []\\n else:\\n b.append(st)\\n\\n if index+1 == len(search_terms):\\n self.search_terms.append(b)\",\n \"def make_tree(self, strings):\\n # start from tree root\\n root = self.tree()\\n # mark if letter is the end of string or just its part\\n root['end'] = set()\\n root['part'] = set(self.s_options_total)\\n for idx, string in enumerate(strings):\\n node = root\\n for letter in string:\\n new_node = node[letter]\\n new_node.setdefault('end', set())\\n new_node.setdefault('part', set()).add(idx)\\n node = new_node\\n node['end'].add(idx)\\n node['part'].remove(idx)\\n\\n return root\",\n \"def _break_query(queryStr):\\n logicStatements = []\\n opList = []\\n\\n #TODO: Add check for balanced parenthesis\\n\\n\\n if('(' in queryStr and ')' in queryStr):\\n\\n currentPairLevel = 0 #indicates the current nest level of parens\\n pairSearchLevel = 0 #level of open paren that match is being found for\\n openPairIndex = 0 #the index of the open parenthesis in queryStr\\n closePairIndex = 0 #index of close parenthesis in queryStr\\n outerOpenFound = False\\n indexPairs = []\\n for index, char in enumerate(queryStr):\\n\\n if(char=='('):\\n currentPairLevel += 1\\n #if first open parenthesis\\n if(not outerOpenFound):\\n openPairIndex = index\\n pairSearchLevel = currentPairLevel\\n outerOpenFound = True\\n elif(char==')'):\\n #if the parenthesis is at the same nest level as the open\\n if(currentPairLevel == pairSearchLevel):\\n closePairIndex = index\\n indexPairs.append([openPairIndex,closePairIndex])\\n outerOpenFound = False\\n currentPairLevel -= 1\\n\\n #used the positions of the parenthesis to pull sliced from the query\\n for index, pair in enumerate(indexPairs):\\n logicStatements.append(queryStr[(pair[0]+1):pair[1]])\\n\\n #if not the last parenthesis pair then get operator after it\\n if not(index == len(indexPairs)-1):\\n opList.append(queryStr[pair[1]+1])\\n \\n return logicStatements, opList\",\n \"def build(\\n word_dict: AsrDictionary,\\n subword_dict: AsrDictionary,\\n subword_tokenizer: Callable[[str], List[str]] = None,\\n ):\\n\\n root = lexical_prefix_tree(\\n word_dict=word_dict,\\n subword_dict=subword_dict,\\n subword_tokenizer=subword_tokenizer,\\n ) # build traditional tree data structure by reusing existing routines\\n\\n # Performs pre-order traversal of this tree to assign an index for each node\\n max_num_children = 0\\n nodes = [None] # nodes[0] is a dummy node for OOV\\n node_to_id_dict = {}\\n stack = [root]\\n\\n while len(stack) > 0:\\n curr = stack.pop()\\n node_id = len(nodes)\\n nodes.append(curr)\\n node_to_id_dict[curr] = node_id\\n if len(curr.children) > max_num_children:\\n max_num_children = len(curr.children)\\n\\n # Guarantee that the children are traversed ascendingly according to the subword index\\n for _, next_node in sorted(\\n curr.children.items(), key=lambda t: t[0], reverse=True\\n ):\\n stack.append(next_node)\\n\\n # Construct the tree\\n num_nodes = len(nodes)\\n children = np.full([num_nodes, max_num_children], 0, dtype=np.int64)\\n prev_subword_idx = np.full([num_nodes], subword_dict.pad(), dtype=np.int64)\\n word_idx = np.full([num_nodes], -1, dtype=np.int64)\\n word_set_idx = np.full([num_nodes, 2], word_dict.pad(), dtype=np.int64)\\n\\n for node_id in range(1, len(nodes)): # skip 0, which is `None`\\n node = nodes[node_id]\\n # Guarantee that the children are traversed ascendingly according to the subword index\\n for i, (subword_id, child) in enumerate(\\n sorted(node.children.items(), key=lambda t: t[0])\\n ):\\n child_node_id = node_to_id_dict[child]\\n children[node_id, i] = child_node_id\\n prev_subword_idx[child_node_id] = subword_id\\n\\n word_idx[node_id] = node.word_idx\\n if node.word_set is not None:\\n word_set_idx[node_id] = node.word_set\\n else:\\n word_set_idx[node_id] = [0, len(word_dict) - 1]\\n\\n return TensorizedPrefixTree(\\n children=torch.from_numpy(children),\\n prev_subword_idx=torch.from_numpy(prev_subword_idx),\\n word_idx=torch.from_numpy(word_idx),\\n word_set_idx=torch.from_numpy(word_set_idx),\\n )\",\n \"def decompTwo(string):\\r\\n index = 0\\r\\n while True:\\r\\n index = string.find('->', index)\\r\\n if index > 0:\\r\\n if isFormula(string[:index]) and isFormula(string[index + 2:]):\\r\\n return [string[:index], string[index + 2:]]\\r\\n else:\\r\\n index += 2\\r\\n else:\\r\\n break\\r\\n return ['', string]\",\n \"def build_sublemma_index(self):\\n terms = []\\n with open(self.path_lemma_terms, 'r', encoding='utf8') as f:\\n for line in f:\\n term = line.strip('\\\\n')\\n terms.append(term)\\n terms = set(terms)\\n for term in terms:\\n term_list = term.split('_')\\n subterms = get_sublists(term_list)\\n self.sublemma_index[term] = [t for t in subterms if t in terms]\",\n \"def parseTerms(cmds):\\n if len(cmds) != 0:\\n print(\\\"Term\\\")\\n delimit = \\\"[*|/|%]+\\\"\\n factors = re.split(delimit, cmds[0])\\n parseFactors(cmds[0])\\n parseTerms(cmds[1:])\",\n \"def parse_polynomial(s):\\n\\n def parse_n(s):\\n '''Parse the number part of a polynomial string term'''\\n if not s:\\n return 1\\n elif s == '-':\\n return -1\\n elif s == '+':\\n return 1\\n return float(eval(s))\\n\\n def parse_p(s, powerPattern):\\n '''Parse the power part of a polynomial string term'''\\n if not s:\\n return 0\\n multipliers = powerPattern.findall(s)[0]\\n if not multipliers:\\n return 1\\n return int(multipliers)\\n s = str(s).replace(' ', '') # remove all whitespace from string\\n m = re.search('[a-zA-Z]+', s)\\n try:\\n varLetter = m.group(0)\\n except AttributeError:\\n varLetter = 'P'\\n termPattern = re.compile(\\n '([+-]?\\\\d*\\\\.?\\\\d*)\\\\**({var}?\\\\^?\\\\d?)'.format(var=varLetter))\\n powerPattern = re.compile('{var}\\\\^?(\\\\d)?'.format(var=varLetter))\\n order_multipliers = {}\\n\\n for n, p in termPattern.findall(s):\\n n, p = n.strip(), p.strip()\\n if not n and not p:\\n continue\\n n, p = parse_n(n), parse_p(p, powerPattern)\\n if p in order_multipliers:\\n order_multipliers[p] += n\\n else:\\n order_multipliers[p] = n\\n highest_order = max(\\n max(order_multipliers.keys()), 1) # order must be at least linear\\n multipliers = [0] * (highest_order + 1)\\n for key, val in order_multipliers.items():\\n multipliers[key] = val\\n\\n return multipliers\",\n \"def tokenize(book_string):\\n begin = re.sub(r'^(\\\\n *)*', '\\\\x02', book_string) # Begin of file\\n final = re.sub(r'(\\\\n *)+$', '\\\\x03', begin) # End of file\\n middle = re.sub(r'(\\\\n *){2,}', '\\\\x03\\\\x02 ', final) # Middle start/stop of parag\\n no_line = re.sub(r'\\\\n', ' ', middle) # Other new lines with space\\n\\n slist = re.split(pattern=r'(?=\\\\x02|\\\\x03)|(?<=\\\\x02|\\\\x03)|\\\\b', string=no_line)\\n slist = list(map(str.strip, filter(str.strip, slist))) # Filter empty, strip space\\n return slist\",\n \"def split_word_in_all_comps(self, term: str) -> List[str]:\\n all_stems = []\\n\\n words = term.split()\\n for word in words:\\n stems = self.decompound(word)\\n all_stems.extend(stems)\\n\\n for stem in stems:\\n more_stems = self.split_word_in_all_comps(stem)\\n all_stems.extend(more_stems)\\n\\n return all_stems\",\n \"def parse_raw(parent, text):\\n path, fname = os.path.split(os.path.abspath(parent.filename))\\n path = path.split(os.sep)\\n parent_tags = []\\n parent_stack = [parent]\\n # Parent tags for raw/{graphics, objects} are handled later\\n if path[-1] == 'init':\\n parent_tags = init_filename_parents.get(fname, [])\\n for kind, token in tokenize_raw(text):\\n if kind == 'Tag':\\n contents = token[1:-1]\\n if ':' in contents:\\n name, value = contents.split(':', 1)\\n else:\\n name, value = contents, token[0] == '['\\n is_parent = False\\n for g in parent_tags:\\n if fnmatch(name, g):\\n is_parent = True\\n while (parent_stack[-1].name in final_level_tags or\\n any([fnmatch(p.name, g) for p in parent_stack])):\\n parent_stack.pop()\\n node = DFRawTag(parent_stack[-1], name, value)\\n if is_parent:\\n parent_stack.append(node)\\n if path[-2] == 'raw' and name == 'OBJECT':\\n parent_tags = object_parents[value]\\n elif kind == 'Comment':\\n DFRawComment(parent_stack[-1], token)\\n else:\\n log.e('Unknown raw token while parsing: '+kind)\\n raise Exception('Unknown raw token kind: '+kind)\",\n \"def reassemble_parens(cls, propstr, errstr, context, splitstr=','):\\n vars = list()\\n proplist = propstr.split(splitstr)\\n while len(proplist) > 0:\\n var = proplist.pop(0)\\n while var.count('(') != var.count(')'):\\n if len(proplist) == 0:\\n raise ParseSyntaxError(errstr, token=propstr, context=context)\\n # End if\\n var = var + ',' + proplist.pop(0)\\n # End while\\n var = var.strip()\\n if len(var) > 0:\\n vars.append(var)\\n # End if\\n # End while\\n return vars\",\n \"def all_phrases(grammar, root):\\n #\\n # if root not in grammar:\\n # return [[root]]\\n #\\n # phrases = []\\n # for structure in grammar[root]:\\n # for fragment in structure:\\n # phrases = phrases + all_phrases(grammar,fragment)\\n # print(phrases)\\n # return phrases\\n\\n if root not in grammar:\\n return [[root]]\\n phrases = []\\n for structure in grammar[root]:\\n phrase_template = []\\n for speech_part in structure:\\n if speech_part not in grammar:\\n if len(phrase_template)>0:\\n new_phrase_template = []\\n for phrase in phrase_template:\\n if type(phrase)==str:\\n phrase = [phrase]\\n new_phrase_template.append(phrase+[speech_part])\\n phrase_template = new_phrase_template\\n else:\\n phrase_template.append([speech_part])\\n else:\\n if len(phrase_template)>0:\\n new_phrase_template = []\\n for phrase in phrase_template:\\n if type(phrase)==str:\\n phrase = [phrase]\\n for fragment in grammar[speech_part]:\\n fragmented_bool = False\\n for fragmented in fragment:\\n if fragmented in grammar:\\n fragmented_bool = True\\n for subfragment in grammar[fragmented]:\\n new_phrase_template.append(phrase+subfragment)\\n if not fragmented_bool:\\n new_phrase_template.append(phrase+fragment)\\n phrase_template = new_phrase_template\\n else:\\n for fragment in grammar[speech_part]:\\n if fragment[0] in grammar:\\n for subfragment in grammar[fragment[0]]:\\n phrase_template.append(subfragment)\\n else:\\n phrase_template.append(fragment)\\n phrases = phrases + phrase_template\\n return phrases\",\n \"def readTree(text, ind, verbose=False):\\n if verbose:\\n print(\\\"Reading new subtree\\\", text[ind:][:10])\\n\\n # consume any spaces before the tree\\n while text[ind].isspace():\\n ind += 1\\n\\n if text[ind] == \\\"(\\\":\\n if verbose:\\n print(\\\"Found open paren\\\")\\n tree = []\\n ind += 1\\n\\n # record the label after the paren\\n label = \\\"\\\"\\n while not text[ind].isspace() and text != \\\"(\\\":\\n label += text[ind]\\n ind += 1\\n\\n tree.append(label)\\n if verbose:\\n print(\\\"Read in label:\\\", label)\\n\\n # read in all subtrees until right paren\\n subtree = True\\n while subtree:\\n # if this call finds only the right paren it'll return False\\n subtree, ind = readTree(text, ind, verbose=verbose)\\n if subtree:\\n tree.append(subtree)\\n\\n # consume the right paren itself\\n ind += 1\\n assert(text[ind] == \\\")\\\")\\n ind += 1\\n\\n if verbose:\\n print(\\\"End of tree\\\", tree)\\n\\n return tree, ind\\n\\n elif text[ind] == \\\")\\\":\\n # there is no subtree here; this is the end paren of the parent tree\\n # which we should not consume\\n ind -= 1\\n return False, ind\\n\\n else:\\n # the subtree is just a terminal (a word)\\n word = \\\"\\\"\\n while not text[ind].isspace() and text[ind] != \\\")\\\":\\n word += text[ind]\\n ind += 1\\n\\n if verbose:\\n print(\\\"Read in word:\\\", word)\\n\\n return word, ind\",\n \"def test_parse_taxonomy(self):\\r\\n example_tax = \\\\\\r\\n \\\"\\\"\\\"412 PC.635_647\\tRoot;Bacteria;Firmicutes; \\\"Clostridia\\\";Clostridiales\\t0.930\\r\\n319 PC.355_281\\tRoot;Bacteria;Bacteroidetes \\t0.970\\r\\n353 PC.634_154\\tRoot; Bacteria ; Bacteroidetes\\t0.830\\r\\n17 PC.607_302\\tRoot;Bacteria;Bacteroidetes\\t0.960\\r\\n13 PC.481_1214\\tRoot;Bacteria;Firmicutes;\\\"Clostridia\\\";Clostridiales\\t0.870\\r\\n338 PC.593_1314\\tRoot; Bacteria \\t0.990\\t42556\\tAdditional fields ignored\\\"\\\"\\\"\\r\\n res = parse_taxonomy(example_tax.split('\\\\n'))\\r\\n self.assertEqual(res['412'],\\r\\n [\\\"Root\\\", \\\"Bacteria\\\", \\\"Firmicutes\\\", \\\"\\\\\\\"Clostridia\\\\\\\"\\\", \\\"Clostridiales\\\"])\\r\\n self.assertEqual(res['338'],\\r\\n [\\\"Root\\\", \\\"Bacteria\\\"])\",\n \"def parseGOOBO(filename):\\n with open(filename, \\\"r\\\") as infile:\\n currentGOTerm = None\\n for line in infile:\\n line = line.strip()\\n if not line: continue #Skip empty\\n if line == \\\"[Term]\\\":\\n if currentGOTerm: yield processGOTerm(currentGOTerm)\\n currentGOTerm = defaultdict(list)\\n elif line == \\\"[Typedef]\\\":\\n #Skip [Typedef sections]\\n currentGOTerm = None\\n else: #Not [Term]\\n #Only process if we're inside a [Term] environment\\n if currentGOTerm is None: continue\\n key, sep, val = line.partition(\\\":\\\")\\n currentGOTerm[key].append(val.strip())\\n #Add last term\\n if currentGOTerm is not None:\\n yield processGOTerm(currentGOTerm)\",\n \"def trees_from_string(this_class, text):\\n # Note: the native method below gives us memory ownership of\\n # the InputTree objects in the vector. We acquire their pointers\\n # and store them in a Python list (the vector won't stick\\n # around). InputTree objects typically contain other InputTree\\n # objects and the outer tree will free the inner trees when it is\\n # deleted. So, we only need (and want) to acquire the pointer of\\n # the outermost InputTree tree.\\n trees = list(parser.inputTreesFromString(text))\\n for tree in trees:\\n tree.this.acquire()\\n return list(map(this_class, trees))\",\n \"def parse_from_regex(string,pattern,fields):\\n\\n string = string.replace('\\\\\\\\','/') # USE POSIX PLEASE\\n num_groups = flat_paren_counter(pattern)\\n if isinstance(fields,str):\\n fields = [fields]\\n num_fields = len(fields)\\n if not num_fields == num_groups:\\n return {}\\n match = re.search(pattern,string)\\n if not num_groups == len(match.groups()):\\n return {}\\n \\n l = []\\n \\n for field,value in zip(fields,list(match.groups())):\\n d = nested_notation_to_tree(field,value)\\n l.append(d)\\n return deep_merge_N(l)\",\n \"def parse_rule(text: str) -> Tuple[str, Dict[str, int]]:\\n kind, contents_text = text.split(\\\" bags contain \\\")\\n contents: Dict[str, int] = defaultdict(int)\\n if contents_text != \\\"no other bags.\\\":\\n for subbag_text in contents_text[:-1].split(\\\", \\\"):\\n count, subkind = parse_bagexpr(subbag_text)\\n contents[subkind] += count\\n return kind, contents\",\n \"def __init__(self,treeString):\\n\\t\\tself.treeString=treeString\\n\\t\\tif self.checkString(self.treeString) == True:\\n\\t\\t\\tself.root=node.node(None)\\n\\t\\t\\tself.currNode=self.root\\n\\t\\t\\tself.buildTree(self.treeString)\\n\\t\\t\\t\\\"\\\"\\\"once information from buildTree is assigned to individual nodes, \\n\\t\\t\\tthe nodes then parse that information into names, branch lengths, etc\\n\\t\\t\\trecursive function allows the call to be made only to the root\\\"\\\"\\\"\\n\\t\\t\\t#use this step to do likelihood calculation\\n\\t\\t\\tself.root.processInfo()\\n\\t\\telse:\\n\\t\\t\\t#change to an error in long run\\n\\t\\t\\tprint \\\"improperly formatted newick string\\\"\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7481961","0.6179253","0.6024916","0.58284104","0.58159286","0.57567114","0.55579245","0.54866225","0.54343325","0.54079","0.5405899","0.53275555","0.53219724","0.5318563","0.5275198","0.5262341","0.52378106","0.523213","0.5202051","0.50821346","0.507025","0.5061221","0.5053436","0.505105","0.5000119","0.49940982","0.4978869","0.49731618","0.49613035","0.49602675","0.4956346","0.49510926","0.4932766","0.49232325","0.48979732","0.4893207","0.4891708","0.488517","0.48574138","0.48532125","0.48513472","0.4825584","0.48173973","0.48008123","0.47924113","0.47785756","0.47698006","0.47616348","0.47496462","0.47468615","0.47439528","0.4739397","0.47304147","0.47132528","0.4703578","0.4697676","0.46890762","0.4688173","0.4683006","0.46798915","0.4669934","0.4653064","0.4641342","0.46404693","0.46294633","0.46260214","0.4620984","0.46130598","0.4607089","0.4604367","0.46007982","0.45891014","0.45827535","0.4575349","0.45673394","0.45609444","0.45518017","0.4545484","0.4545134","0.45432684","0.45418793","0.4533664","0.45270127","0.45268425","0.45156586","0.45148906","0.45128545","0.45086813","0.450182","0.44881007","0.44878584","0.44821608","0.44799754","0.4463943","0.4463141","0.44527188","0.44520712","0.44508854","0.44477448","0.44433922"],"string":"[\n \"0.7481961\",\n \"0.6179253\",\n \"0.6024916\",\n \"0.58284104\",\n \"0.58159286\",\n \"0.57567114\",\n \"0.55579245\",\n \"0.54866225\",\n \"0.54343325\",\n \"0.54079\",\n \"0.5405899\",\n \"0.53275555\",\n \"0.53219724\",\n \"0.5318563\",\n \"0.5275198\",\n \"0.5262341\",\n \"0.52378106\",\n \"0.523213\",\n \"0.5202051\",\n \"0.50821346\",\n \"0.507025\",\n \"0.5061221\",\n \"0.5053436\",\n \"0.505105\",\n \"0.5000119\",\n \"0.49940982\",\n \"0.4978869\",\n \"0.49731618\",\n \"0.49613035\",\n \"0.49602675\",\n \"0.4956346\",\n \"0.49510926\",\n \"0.4932766\",\n \"0.49232325\",\n \"0.48979732\",\n \"0.4893207\",\n \"0.4891708\",\n \"0.488517\",\n \"0.48574138\",\n \"0.48532125\",\n \"0.48513472\",\n \"0.4825584\",\n \"0.48173973\",\n \"0.48008123\",\n \"0.47924113\",\n \"0.47785756\",\n \"0.47698006\",\n \"0.47616348\",\n \"0.47496462\",\n \"0.47468615\",\n \"0.47439528\",\n \"0.4739397\",\n \"0.47304147\",\n \"0.47132528\",\n \"0.4703578\",\n \"0.4697676\",\n \"0.46890762\",\n \"0.4688173\",\n \"0.4683006\",\n \"0.46798915\",\n \"0.4669934\",\n \"0.4653064\",\n \"0.4641342\",\n \"0.46404693\",\n \"0.46294633\",\n \"0.46260214\",\n \"0.4620984\",\n \"0.46130598\",\n \"0.4607089\",\n \"0.4604367\",\n \"0.46007982\",\n \"0.45891014\",\n \"0.45827535\",\n \"0.4575349\",\n \"0.45673394\",\n \"0.45609444\",\n \"0.45518017\",\n \"0.4545484\",\n \"0.4545134\",\n \"0.45432684\",\n \"0.45418793\",\n \"0.4533664\",\n \"0.45270127\",\n \"0.45268425\",\n \"0.45156586\",\n \"0.45148906\",\n \"0.45128545\",\n \"0.45086813\",\n \"0.450182\",\n \"0.44881007\",\n \"0.44878584\",\n \"0.44821608\",\n \"0.44799754\",\n \"0.4463943\",\n \"0.4463141\",\n \"0.44527188\",\n \"0.44520712\",\n \"0.44508854\",\n \"0.44477448\",\n \"0.44433922\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8231147"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":79092,"cells":{"query":{"kind":"string","value":"Recursively calculate the syntactic complexity of the compound term. The connector adds 1 complexity, and the subterms syntactic complexities are summed as well."},"document":{"kind":"string","value":"def _calculate_syntactic_complexity(self):\n count = 1 # the copula\n for subterm in self.subterms:\n count = count + subterm._calculate_syntactic_complexity()\n\n return count"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _calculate_syntactic_complexity(self):\n count = 0\n if self.connector is not None:\n count = 1 # the term connector\n for subterm in self.subterms:\n count = count + subterm._calculate_syntactic_complexity()\n return count","def _calculate_complexity(workflow):\n complexity = estimate_complexity(workflow.type_, workflow.reana_specification)\n workflow.complexity = complexity\n Session.commit()\n return complexity","def complexity(self):\n n = 0\n ctx = self\n while ctx is not None:\n n += 1\n ctx = ctx.parent()\n return n","def simplify(term):\n simplified_term = term\n\n if isinstance(term,StatementTerm):\n simplified_term = StatementTerm(subject_term=simplify(term.get_subject_term()),\n predicate_term=simplify(term.get_predicate_term()),\n copula=term.get_copula(),\n interval=term.interval)\n elif isinstance(term,CompoundTerm):\n if term.connector == NALSyntax.TermConnector.Negation and \\\n len(term.subterms) == 1 and \\\n isinstance(term.subterms[0],CompoundTerm) and \\\n term.subterms[0].connector == NALSyntax.TermConnector.Negation :\n # (--,(--,(S --> P)) <====> (S --> P)\n # Double negation theorem. 2 Negations cancel out\n simplified_term = simplify(term.subterms[0].subterms[0]) # get the inner statement\n # elif NALSyntax.TermConnector.is_conjunction(term.connector):\n # #(&&,A,B..C)\n # new_subterms = []\n # new_intervals = []\n # for i in range(len(term.subterms)):\n # subterm = simplify(term.subterms[i])\n # if i < len(term.intervals): new_intervals.append(term.intervals[i])\n # if isinstance(subterm, CompoundTerm) and subterm.connector == term.connector:\n # # inner conjunction\n # new_subterms.extend(subterm.subterms)\n # new_intervals.extend(subterm.intervals)\n # else:\n # new_subterms.append(subterm)\n #\n # simplified_term = CompoundTerm(subterms=new_subterms,\n # term_connector=term.connector,\n # intervals=new_intervals)\n elif term.connector is NALSyntax.TermConnector.ExtensionalDifference:\n pass\n elif term.connector is NALSyntax.TermConnector.IntensionalDifference:\n pass\n elif term.connector is NALSyntax.TermConnector.ExtensionalImage:\n pass\n elif term.connector is NALSyntax.TermConnector.IntensionalImage:\n pass\n\n\n return simplified_term","def commands_complexity():\n complexity()","def cyclomaticComplexity (self):\n self.tarjan()\n return len(self.__edges) - len(self.__nodes) + 2 * len(self.__scc)","def __simplifyRecurse(self): # TODO make this work with ^\n # check if we're a + node, a * node, or a simple node\n if isinstance(self.poly, (int, float, Variable.Variable)):\n return self\n elif self.poly[0] == \"+\":\n self.__handlePowPlus()\n\n newPoly = Polynomial()\n newPoly.poly = [\"+\"]\n for branch in self.poly[1:]:\n simplifiedBranch = ensurePoly(branch).__simplifyRecurse()\n if not simplifiedBranch.isSimple():\n for additiveTerm in simplifiedBranch.poly[1:]:\n newPoly.poly.append(additiveTerm)\n else:\n newPoly.poly.append(simplifiedBranch)\n return newPoly\n elif self.poly[0] == \"*\":\n self.__handlePowTimes()\n\n nonSimple, simple = self.__partitionSimpleAndNonSimpleBranches()\n\n if len(nonSimple) == 0: # this means our * node gives a monomial!\n return Polynomial(input=self)\n else:\n # do the full distribution\n simplified = self.__distribute(nonSimple, simple)\n newPoly = Polynomial()\n newPoly.poly = [\"+\"]\n for branch in simplified.poly[1:]:\n recursive = ensurePoly(branch).__simplifyRecurse()\n if recursive.poly[0] == \"*\":\n newPoly.poly.append(recursive)\n elif recursive.poly[0] == \"+\":\n newPoly.poly.extend(recursive.poly[1:])\n return newPoly\n\n elif self.poly[0] == \"^\":\n # this case will only be hit when we have a ^ node as the root\n newPoly = Polynomial()\n newPoly.poly = [\"*\"]\n for _ in range(self.poly[2]):\n newPoly.poly.append(self.poly[1])\n\n simp = newPoly.__simplifyRecurse()\n return simp","def get_total_complexity(n):\n total = 0\n for i in range(1, n + 1):\n total += get_complexity(i)\n return total","def complexity(self):\n raise NotImplementedError()","def design_complexity(design: Design) -> int:\n diversity = 3 * len(design.required)\n abundance = 2 * sum(design.required.values())\n return diversity + abundance + design.additional","def calculate_compound_costs(self, recursive: bool = True):\n assert self.graph_handler\n if not self.start_compounds_set:\n raise RuntimeError(\"No start conditions given\")\n if len(self.graph_handler.graph.nodes) == 0:\n raise RuntimeError(\"No nodes in graph\")\n cmps_to_check = [n for n in self.graph_handler.graph.nodes if ';' not in n\n and n not in self.start_compounds]\n # # # Set all compounds to be checked to pseudo inf cost\n for cmp_id in cmps_to_check:\n self.compound_costs[cmp_id] = self._pseudo_inf\n # # # Dictionary for current run\n tmp_compound_costs: Dict[str, float] = {}\n # # # Determine convergence variables for while loop\n current_inf_count = sum(value == self._pseudo_inf for value in self.compound_costs.values())\n prev_inf_count = current_inf_count\n # # # Convergence criteria\n compound_costs_change = None\n compound_costs_opt_change = 1\n converged = False\n # # # Find paths until either no costs are unknown or the None count has not changed\n while (not converged):\n compound_costs_opt_change = 0\n print(\"Remaining Nodes:\", len(cmps_to_check))\n for tmp_start_node in self.start_compounds:\n # # # Loop over all nodes to be checked starting from start nodes\n for target in cmps_to_check:\n # # # Determine cost and path with dijkstra's algorithm\n tmp_cost, _ = nx.single_source_dijkstra(self.graph_handler.graph, tmp_start_node, target,\n cutoff=None, weight=self.__weight_func)\n # # # Check if the obtained cost is larger than infinity (pseudo_inf)\n # # # and continue with the next target if this is the case\n if (tmp_cost - self._pseudo_inf) > 0.0:\n continue\n # # # Add cost of the starting node\n tmp_cost += self.compound_costs[tmp_start_node]\n # # # Check for value in compound_costs dict and\n if (self.compound_costs[target] != self._pseudo_inf and\n 10e-6 < self.compound_costs[target] - tmp_cost):\n compound_costs_opt_change += 1\n # # # Not already set check\n if self.compound_costs[target] == self._pseudo_inf or (\n self.compound_costs != self._pseudo_inf and 10e-6 < self.compound_costs[target] - tmp_cost):\n # # # Not discovered in current run OR new tmp cost lower than stored cost\n if (target not in tmp_compound_costs.keys()):\n tmp_compound_costs[target] = tmp_cost\n elif (tmp_cost < tmp_compound_costs[target]):\n tmp_compound_costs[target] = tmp_cost\n # # # Write obtained compound_costs to overall dictionary\n for key, value in tmp_compound_costs.items():\n self.compound_costs[key] = value\n # # # Remove found nodes if recursive is false\n if not recursive:\n cmps_to_check.remove(key)\n # # # Reset tmp_pr_cost\n tmp_compound_costs = {}\n # # # Convergence Check\n current_inf_count = sum(value == self._pseudo_inf for value in self.compound_costs.values())\n compound_costs_change = prev_inf_count - current_inf_count\n prev_inf_count = current_inf_count\n\n print(50 * '-')\n print(\"Current None:\", current_inf_count)\n print(\"PR Change:\", compound_costs_change)\n print(\"PR Opt Change:\", compound_costs_opt_change)\n # # # Convergence Check\n if (compound_costs_change == 0 and compound_costs_opt_change == 0):\n converged = True\n\n # # # Final check if all compound costs are solved\n if current_inf_count == 0:\n self.compound_costs_solved = True","def complexity(self):\n complexity = 0\n for k in self.keys():\n for i, j in combinations(range(1, max(k) + 1), 2):\n seq = filter(lambda x: x == i or x == j, k)\n cpxty = len([p for p, q in pairwise(seq) if p != q])\n complexity = max(cpxty, complexity)\n return complexity","def complexity(self):\n from kinbaku._pygenie import gettype, getpath\n from kinbaku.python import Dotpath\n if not self.contents:\n return\n try:\n stats = measure_complexity(self.contents, self.fname)\n except SyntaxError:\n return None\n\n out = PrettyPrinter(StringIO()).flatten_stats(stats)\n out = [ [ gettype(_type),\n getpath(_type,dotpath),\n score ] for _type, dotpath, score in out ]\n return out","def calc_complexity_step(self, adj_ens, feat_ens, sizes_subg_ens):\n num_ensemble = len(feat_ens)\n dims_ens = []\n ops = 0\n for i in range(num_ensemble):\n if len(self.type_feature_augment) > 0:\n for ia, _ in enumerate(self.type_feature_augment): # this does not change feat dim\n ops += np.prod(list(self.aug_layers[i][ia].weight.shape)) * feat_ens[i].shape[0]\n dims_respool = []\n dims_conv = (layers.Dims_X(*(feat_ens[i].shape)), layers.Dims_adj(adj_ens[i].shape[0], adj_ens[i].size))\n for md in self.conv_layers[i]:\n dims_conv, _ops = md.complexity(*dims_conv)\n dims_respool.append(dims_conv[0])\n ops += _ops\n dims_emb, _ops = self.res_pool_layers[i].complexity(dims_respool, sizes_subg_ens)\n ops += _ops\n dims_ens.append(dims_emb)\n dims_cls, _ops = self.ensembler.complexity(dims_ens)\n ops += _ops\n _dims_final, _ops = self.classifier.complexity(dims_cls)\n ops += _ops\n return ops","def rational_function_coefficient_descent(rational_function, sigma, poly_ring):\n\n if rational_function.parent().is_field():\n S = rational_function.parent().ring()\n else:\n S = rational_function.parent()\n\n if rational_function == S(0):\n return poly_ring(0)\n\n num = S(rational_function.numerator())\n denom = S(rational_function.denominator())\n f = num.coefficients()\n fe = num.exponents()\n g = denom.coefficients()\n ge = denom.exponents()\n #force the cancellation of common coefficient factors by scaling by f[-1]\n ff = [ field_descent(sigma, x/f[-1]) for x in f]\n gg = [ field_descent(sigma, x/f[-1]) for x in g]\n if None in ff or None in gg:\n return\n\n z = poly_ring.gen(0)\n numer = sum( poly_ring(ff[i])*z**fe[i] for i in range(len(ff)) )\n denom = sum( poly_ring(gg[i])*z**ge[i] for i in range(len(gg)) )\n return numer / denom","def complexity(s, **kwargs):\n num, den = 1, 1\n for k in range(1, len(s)):\n k4 = 4**k # For DNA\n num += min(len(set(s[i:i+k] for i in range(len(s) - k + 1))), k4)\n den += min(len(s) - k + 1, k4)\n return num / den","def complexity(self) -> str:\n return pulumi.get(self, \"complexity\")","def parse_toplevel_subterms_and_connector(cls, compound_term_string):\n compound_term_string = compound_term_string.replace(\" \",\"\")\n subterms = []\n intervals = []\n internal_string = compound_term_string[1:-1] # string with no outer parentheses () or set brackets [], {}\n\n # check for intensional/extensional set [a,b], {a,b}\n connector = NALSyntax.TermConnector.get_term_connector_from_string(compound_term_string[0])\n if connector is None:\n # otherwise check for regular Term/Statement connectors\n if internal_string[1] == NALSyntax.StatementSyntax.TermDivider.value:\n connector_string = internal_string[0] # Term connector\n else:\n connector_string = internal_string[0:2] # Statement connector\n connector = NALSyntax.TermConnector.get_term_connector_from_string(connector_string)\n\n assert (internal_string[\n len(\n connector.value)] == NALSyntax.StatementSyntax.TermDivider.value), \"Connector not followed by comma in CompoundTerm string \" + compound_term_string\n internal_string = internal_string[len(connector.value) + 1:]\n\n assert (connector is not None), \"Connector could not be parsed from CompoundTerm string.\"\n\n depth = 0\n subterm_string = \"\"\n for i, c in enumerate(internal_string):\n if c == NALSyntax.StatementSyntax.Start.value or NALSyntax.TermConnector.is_set_bracket_start(c):\n depth += 1\n elif c == NALSyntax.StatementSyntax.End.value or NALSyntax.TermConnector.is_set_bracket_end(c):\n depth -= 1\n\n if c == NALSyntax.StatementSyntax.TermDivider.value and depth == 0:\n if subterm_string.isdigit():\n intervals.append(int(subterm_string))\n else:\n subterm = Term.from_string(subterm_string)\n subterms.append(subterm)\n subterm_string = \"\"\n else:\n subterm_string += c\n\n subterm = Term.from_string(subterm_string)\n subterms.append(subterm)\n\n return subterms, connector, intervals","def count_consonants_recursive(input):\n if len(input) == 0:\n return 0\n if input[0].lower() in consonants:\n return 1 + count_consonants_recursive(input[1:])\n else:\n return count_consonants_recursive(input[1:])","def complex_sum(c_1,c_2):\n return c_1 + c_2","def nth_order_const_coeff(*coeffs: List[Symbol], t: Symbol = t) -> Tuple[List[Symbol], Procedure]:\n\n # First, set up characteristic equation.\n char_eq_r, r = sympy.S.Zero, Dummy('r')\n\n for order, coeff in enumerate(coeffs[::-1]):\n char_eq_r += coeff * r ** order\n\n char_eq = Poly(char_eq_r, r)\n\n # Can't just call roots because it doesn't return rootof for unsolveable\n # polynomials.\n char_eq_roots = roots(char_eq, multiple=True)\n\n root_dict = defaultdict(int) # type: Dict[int, int]\n\n conjugate_roots = []\n for root in char_eq_roots:\n root_dict[root] += 1\n\n sols = []\n for root, mult in root_dict.items():\n for i in range(mult):\n if isinstance(root, RootOf):\n sols.append(t**i * exp(root*t))\n elif root.is_real:\n sols.append(t**i*exp(root*t))\n else:\n if root in conjugate_roots:\n continue\n reroot = re(root)\n imroot = im(root)\n conjugate_roots.append(conjugate(root))\n sols.append(t**i*exp(reroot*t) * sin(abs(imroot) * t))\n sols.append(t**i*exp(reroot*t) * cos(imroot * t))\n\n # collect roots for display\n p_roots = []\n count = 1\n for root, mult in root_dict.items():\n p_roots.append(Eq(Dummy('r_{}'.format(\n \",\".join([str(i) for i in range(count, count + mult)]))), root, evaluate=False))\n count += mult\n\n procedure = Procedure()\n procedure\\\n .text('Characteristic equation: ', nl=True)\\\n .eq(Eq(char_eq_r, 0, evaluate=False))\\\n .text('Roots: ')\\\n .equarr(p_roots)\\\n .text('General Solution: ', nl=True)\\\n .eq(Eq(Dummy('y'), to_general(sols)[0], evaluate=False))\n\n return sols, procedure","def _cmplx_add_ ( s , o ) :\n return o + complex ( s )","def __mul__(self, other, nested=False):\n\n other = formula(other, namespace=self.namespace)\n\n selftermnames = self.termnames()\n othertermnames = other.termnames()\n\n I = len(selftermnames)\n J = len(othertermnames)\n\n terms = []\n termnames = []\n\n for i in range(I):\n for j in range(J):\n termname = '%s*%s' % (str(selftermnames[i]), str(othertermnames[j]))\n pieces = termname.split('*')\n pieces.sort()\n termname = '*'.join(pieces)\n termnames.append(termname)\n\n selfnames = self.terms[i].names()\n othernames = other.terms[j].names()\n\n if self.terms[i].name is 'intercept':\n _term = other.terms[j]\n _term.namespace = other.namespace\n\n elif other.terms[j].name is 'intercept':\n _term = self.terms[i]\n _term.namespace = self.namespace\n else:\n names = []\n\n d1 = len(selfnames) \n d2 = len(othernames)\n\n for r in range(d1):\n for s in range(d2):\n name = '%s*%s' % (str(selfnames[r]), str(othernames[s]))\n pieces = name.split('*')\n pieces.sort()\n name = '*'.join(pieces)\n names.append(name)\n\n def product_func(value, d1=d1, d2=d2):\n\n out = []\n for r in range(d1):\n for s in range(d2):\n out.append(value[r] * value[d1+s])\n return N.array(out)\n\n sumterms = self + other\n sumterms.terms = [self, other] # enforce the order we want\n sumterms.namespace = self.namespace\n\n _term = quantitative(names, func=sumterms, termname=termname,\n transform=product_func)\n _term.namespace = self.namespace\n\n\n terms.append(_term)\n\n return formula(terms, namespace=self.namespace)","def simplify(self): # TODO too complex, refactor\n simplified = self.__simplifyRecurse()\n # distributed out the polynomial. Now need to collect like terms\n simplified.vars = self.vars.copy()\n orderedVars = sorted(list(self.vars))\n\n powers = {} # will have keys of tuples. The tuples will represent the power of a variable. Values will be the\n for monomial in simplified.poly[1:]:\n power = [0] * len(orderedVars)\n total = 0\n\n if monomial.isSimple():\n monomial.poly = [\"*\", monomial.poly]\n\n for term in monomial.poly[1:]:\n term = ensurePoly(term)\n if isinstance(term.poly, (int, float)):\n total += term.poly\n elif isinstance(term.poly, (Variable.Variable)):\n power[orderedVars.index(term.poly)] += 1\n\n power = tuple(power)\n if power not in powers:\n powers[power] = total\n else:\n powers[power] = min(total, powers[power])\n\n finalPoly = Polynomial()\n finalPoly.poly = [\"+\"]\n finalPoly.vars = self.vars.copy()\n for power in sorted(list(powers.keys())):\n monomial = Polynomial()\n monomial.poly = [\"*\"]\n if powers[power] != 0:\n monomial.poly.append(powers[power])\n\n for pow, ind in zip(power, range(len(power))):\n if pow == 0:\n continue\n elif pow == 1:\n monomial.poly.append(orderedVars[ind])\n else:\n monomial.poly.append(orderedVars[ind]**pow)\n finalPoly.poly.append(monomial)\n return finalPoly","def continued_fraction(a) -> list:\n e = _sympify(a)\n if all(i.is_Rational for i in e.atoms()):\n if e.is_Integer:\n return continued_fraction_periodic(e, 1, 0)\n elif e.is_Rational:\n return continued_fraction_periodic(e.p, e.q, 0)\n elif e.is_Pow and e.exp is S.Half and e.base.is_Integer:\n return continued_fraction_periodic(0, 1, e.base)\n elif e.is_Mul and len(e.args) == 2 and (\n e.args[0].is_Rational and\n e.args[1].is_Pow and\n e.args[1].base.is_Integer and\n e.args[1].exp is S.Half):\n a, b = e.args\n return continued_fraction_periodic(0, a.q, b.base, a.p)\n else:\n # this should not have to work very hard- no\n # simplification, cancel, etc... which should be\n # done by the user. e.g. This is a fancy 1 but\n # the user should simplify it first:\n # sqrt(2)*(1 + sqrt(2))/(sqrt(2) + 2)\n p, d = e.expand().as_numer_denom()\n if d.is_Integer:\n if p.is_Rational:\n return continued_fraction_periodic(p, d)\n # look for a + b*c\n # with c = sqrt(s)\n if p.is_Add and len(p.args) == 2:\n a, bc = p.args\n else:\n a = S.Zero\n bc = p\n if a.is_Integer:\n b = S.NaN\n if bc.is_Mul and len(bc.args) == 2:\n b, c = bc.args\n elif bc.is_Pow:\n b = Integer(1)\n c = bc\n if b.is_Integer and (\n c.is_Pow and c.exp is S.Half and\n c.base.is_Integer):\n # (a + b*sqrt(c))/d\n c = c.base\n return continued_fraction_periodic(a, d, c, b)\n raise ValueError(\n 'expecting a rational or quadratic irrational, not %s' % e)","def time_complexities():\n return \"Best Case: O(n), Average Case: O(n), Worst Case: O(n)\"","def __mul__(self, other, nested=False):\n\n other = Formula(other)\n\n selftermnames = self.termnames()\n othertermnames = other.termnames()\n\n I = len(selftermnames)\n J = len(othertermnames)\n\n terms = []\n termnames = []\n\n for i in range(I):\n for j in range(J):\n termname = '%s*%s' % (str(selftermnames[i]), str(othertermnames[j]))\n pieces = sorted(termname.split('*'))\n termname = '*'.join(pieces)\n termnames.append(termname)\n\n selfnames = self.terms[i].names()\n othernames = other.terms[j].names()\n\n if self.terms[i].name is 'intercept':\n _term = other.terms[j]\n _term.namespace = other.namespace\n elif other.terms[j].name is 'intercept':\n _term = self.terms[i]\n _term.namespace = self.namespace\n else:\n names = []\n\n d1 = len(selfnames)\n d2 = len(othernames)\n\n for r in range(d1):\n for s in range(d2):\n name = '%s*%s' % (str(selfnames[r]), str(othernames[s]))\n pieces = sorted(name.split('*'))\n name = '*'.join(pieces)\n names.append(name)\n\n def product_func(value, d1=d1, d2=d2):\n\n out = []\n for r in range(d1):\n for s in range(d2):\n out.append(value[r] * value[d1+s])\n return np.array(out)\n\n cself = copy.copy(self.terms[i])\n cother = copy.copy(other.terms[j])\n sumterms = cself + cother\n sumterms.terms = [cself, cother] # enforce the order we want\n\n _term = Quantitative(names, func=sumterms,\n termname=termname,\n transform=product_func)\n\n if _namespace_equal(self.namespace, other.namespace):\n _term.namespace = self.namespace\n\n terms.append(_term)\n\n return Formula(terms)","def countRecursiveReferences(self) -> Tuple[Dict[str, List[str]], Dict[str, Dict[str, int]]]:\n countReferences = {}\n isReferencedBy = {}\n for nt in self.non_terminals: # for each non-terminal in the grammar\n for production in self.grammar[nt]: # for each possible production on that non terminal\n count = {}\n for option in production.split(): # iterate over the production's terms\n count.setdefault(option, 0)\n if option in self.non_terminals: # if the term is a non terminal\n count[option] += 1 # the number of times that option has been referenced increases\n isReferencedBy.setdefault(option, set())\n isReferencedBy[option].add(nt)\n \n for key in count:\n count.setdefault(key, 0)\n countReferences.setdefault(key, {})\n countReferences[key].setdefault(nt, 0)\n\n countReferences[key][nt] = max(\n countReferences[key][nt], count[key]) # the number of references of the non terminal is for this\n # term is the maximum between all productions in this non terminal\n\n return isReferencedBy, countReferences","def test_complexity(tmp_path: Path, capsys) -> None:\n file_content = '\"\"\"Docstring.\"\"\"\\n\\n'\n program = \"\"\"\n elements = [open(str(i)) for i in range(10)]\n\n\n def foo():\n \\\"\\\"\\\"Docstring.\\\"\\\"\\\"\n if elements[0]:\n aaa = 1\n elif elements[1]:\n aaa = 1\n elif elements[2]:\n aaa = 1\n elif elements[3]:\n aaa = 1\n elif elements[4]:\n aaa = 1\n elif elements[5]:\n aaa = 1\n elif elements[6]:\n aaa = 1\n elif elements[7]:\n aaa = 1\n elif elements[8]:\n aaa = 1\n elif elements[9]:\n aaa = 1\n print(aaa)\n \"\"\"\n file_content += dedent(program)\n run_linter(tmp_path, capsys, file_content, \"'foo' is too complex (11)\")","def calc_process_cohesion(partitions, graph):\n ch = 0\n for part in partitions:\n crc = calc_community_relation_cohesion(part, graph)\n cic = calc_community_information_cohesion(part, graph)\n ch = ch + (crc * cic)\n ch = ch / len(partitions)\n return ch","def continued_fraction_reduce(cf):\n from sympy.solvers import solve\n\n period = []\n x = Dummy('x')\n\n def untillist(cf):\n for nxt in cf:\n if isinstance(nxt, list):\n period.extend(nxt)\n yield x\n break\n yield nxt\n\n a = S.Zero\n for a in continued_fraction_convergents(untillist(cf)):\n pass\n\n if period:\n y = Dummy('y')\n solns = solve(continued_fraction_reduce(period + [y]) - y, y)\n solns.sort()\n pure = solns[-1]\n rv = a.subs(x, pure).radsimp()\n else:\n rv = a\n if rv.is_Add:\n rv = factor_terms(rv)\n if rv.is_Mul and rv.args[0] == -1:\n rv = rv.func(*rv.args)\n return rv","def innerProd(linearCombo1, linearCombo2):\n innerProd = 0\n # TODO: I'm starting with simple sets on both sides, not sum of sets, \n # with coefficient 1. We need to fix this later\n # TODO: find way to represent dashed vs undashed arrows\n # For now, assume both are already sums (sets) of dashed subdiagrams\n\n # copy linear combinations to make it easier to alter them as needed\n linearComboCopy1 = deepcopy(linearCombo1)\n linearComboCopy2 = deepcopy(linearCombo2)\n print len(linearComboCopy2[0][1])\n\n # get list of subdiagrams, get coefficients\n for coeffAndSubdiagrams1 in linearComboCopy1:\n subdiagramSet1 = coeffAndSubdiagrams1[1]\n coeff1 = coeffAndSubdiagrams1[0]\n subdiagramsToRemove1 = []\n\n for coeffAndSubdiagrams2 in linearComboCopy2:\n subdiagramSet2 = coeffAndSubdiagrams2[1]\n coeff2 = coeffAndSubdiagrams2[0]\n subdiagramsToRemove2 = []\n\n # look for equivalent pairs of dashed subdiagrams in both lists\n for subdiagram1 in subdiagramSet1:\n for subdiagram2 in subdiagramSet2: \n # for equivalent pairs of dashed subdiagrams, increment innerProd by \n # product of coefficients and remove the subdiagrams to avoid \n # over-counting diagrams\n if equiv(subdiagram1, subdiagram2):\n innerProd += coeff1 * coeff2\n subdiagramsToRemove1.append(subdiagram1)\n subdiagramsToRemove2.append(subdiagram2)\n print \" \", innerProd\n # remove the used subdiagrams\n # print \"sub 2\\t\" + str(subdiagramSet2)\n # print \" 2 \" + str(subdiagramsToRemove2)\n # print \" 1 \" + str(subdiagramsToRemove1)\n for removal2 in subdiagramsToRemove2:\n # print \" remove \" + str(removal2)\n subdiagramSet2.remove(removal2)\n subdiagramsToRemove2 = []\n # for removal1 in subdiagramsToRemove1:\n # subdiagramSet1.remove(removal1) \n return innerProd","def number_of_connectives(formula):\n pass\n # ======== YOUR CODE HERE ========","def compute(n):\n if n == 1:\n return 1\n else:\n i = find_i(n)\n return 2 * compute(n - i) + 2 ** i - 1","def parse_algebra(self):\r\n # 0.33 or 7 or .34 or 16.\r\n number_part = Word(nums)\r\n inner_number = (number_part + Optional(\".\" + Optional(number_part))) | (\".\" + number_part)\r\n # pyparsing allows spaces between tokens--`Combine` prevents that.\r\n inner_number = Combine(inner_number)\r\n\r\n # SI suffixes and percent.\r\n number_suffix = MatchFirst(Literal(k) for k in SUFFIXES.keys())\r\n\r\n # 0.33k or 17\r\n plus_minus = Literal('+') | Literal('-')\r\n number = Group(\r\n Optional(plus_minus) +\r\n inner_number +\r\n Optional(CaselessLiteral(\"E\") + Optional(plus_minus) + number_part) +\r\n Optional(number_suffix)\r\n )\r\n number = number(\"number\")\r\n\r\n # Predefine recursive variables.\r\n expr = Forward()\r\n\r\n # Handle variables passed in. They must start with letters/underscores\r\n # and may contain numbers afterward.\r\n inner_varname = Word(alphas + \"_\", alphanums + \"_\")\r\n varname = Group(inner_varname)(\"variable\")\r\n varname.setParseAction(self.variable_parse_action)\r\n\r\n # Same thing for functions.\r\n function = Group(inner_varname + Suppress(\"(\") + expr + Suppress(\")\"))(\"function\")\r\n function.setParseAction(self.function_parse_action)\r\n\r\n atom = number | function | varname | \"(\" + expr + \")\"\r\n atom = Group(atom)(\"atom\")\r\n\r\n # Do the following in the correct order to preserve order of operation.\r\n pow_term = atom + ZeroOrMore(\"^\" + atom)\r\n pow_term = Group(pow_term)(\"power\")\r\n\r\n par_term = pow_term + ZeroOrMore('||' + pow_term) # 5k || 4k\r\n par_term = Group(par_term)(\"parallel\")\r\n\r\n prod_term = par_term + ZeroOrMore((Literal('*') | Literal('/')) + par_term) # 7 * 5 / 4\r\n prod_term = Group(prod_term)(\"product\")\r\n\r\n sum_term = Optional(plus_minus) + prod_term + ZeroOrMore(plus_minus + prod_term) # -5 + 4 - 3\r\n sum_term = Group(sum_term)(\"sum\")\r\n\r\n # Finish the recursion.\r\n expr << sum_term # pylint: disable=W0104\r\n self.tree = (expr + stringEnd).parseString(self.math_expr)[0]","def complexity(self, mode='#nodes'):\n if mode == '#nodes':\n return len(self.nodes)","def get_complexity(n):\n try:\n return complexity_map[n]\n except KeyError:\n if n - 1 in complexity_map:\n complexity_map[n] = complexity_map[n - 1] + 1\n for i in range(2, int(floor(n / 2) + 1)):\n if n % i == 0:\n complexity = get_complexity(i) + get_complexity(n / i)\n if n not in complexity_map or complexity < complexity_map[n]:\n complexity_map[n] = complexity\n return complexity_map[n]","def _AddCompound(self, kegg_id, how_many):\n i = self._FindCompoundIndex(kegg_id)\n if i is not None:\n self.reactants[i].coeff += how_many\n else:\n self.reactants += [CompoundWithCoeff.FromId(how_many, kegg_id)]\n \n # clear the cache since the reaction has changed\n self._catalyzing_enzymes = None","def test_linear_comb() -> None:\n SumStr = FormalLinearCombination(\n str, complex, complex(0, 0), lambda z1, z2: z1+z2)\n flc_1a2b3c = SumStr(\n [(complex(1, 0), \"a\"), (complex(2, 0), \"b\"), (complex(3, 0), \"c\")])\n assert str(flc_1a2b3c) == \"(1+0j)*a+(2+0j)*b+(3+0j)*c\"\n two_flc_1a2b3c = flc_1a2b3c+flc_1a2b3c\n exp_two_flc_1a2b3c = SumStr(\n [(complex(2, 0), \"a\"), (complex(4, 0), \"b\"), (complex(6, 0), \"c\")])\n assert str(two_flc_1a2b3c) == \"(2+0j)*a+(4+0j)*b+(6+0j)*c\"\n assert exp_two_flc_1a2b3c == two_flc_1a2b3c\n assert str(flc_1a2b3c*flc_1a2b3c) == \"(1+0j)*aa+(2+0j)*ab+(3+0j)*ac\"+\\\n \"+(2+0j)*ba+(4+0j)*bb+(6+0j)*bc\"+\\\n \"+(3+0j)*ca+(6+0j)*cb+(9+0j)*cc\"","def solve_part2(input, verbose=False):\n equations = parse(input)\n\n result = []\n for eq in equations:\n result.append(solve_equation_addition_precendence(eq, verbose))\n\n if verbose:\n print(f\"results: {result}\")\n\n return sum(result)","def concretise_ast(node):\n node.children = list(node.get_children())\n\n for child in node.children:\n counter = concretise_ast(child)","def calculate (self,phrase):\r\n\r\n\r\n def bracketed (phrase,bracketing='()'):\r\n\r\n \"\"\"Returns TRUE if <phrase> is encompassed by a left bracket and a right bracket\r\n at the same hierarchical level\"\"\"\r\n\r\n level = 0\r\n left_point = None\r\n right_point = None\r\n \r\n\r\n for count,char in enumerate(phrase):\r\n\r\n if char == bracketing[0]:\r\n if level == 0:\r\n left_point = count\r\n level+=1\r\n if char == bracketing[1]:\r\n level-=1\r\n if level == 0:\r\n right_point = count\r\n if not (left_point is None) and (not right_point is None) and left_point == 0 and right_point == len(phrase)-1:\r\n return True\r\n return False\r\n\r\n def quoted (phrase):\r\n\r\n level = 0\r\n foundchar = ''\r\n left_point = None\r\n right_point = None \r\n for count,char in enumerate(phrase):\r\n\r\n if char in ['\"',\"'\"] and level == 0:\r\n foundchar = char\r\n left_point = count\r\n level += 1\r\n elif level == 1 and char == foundchar:\r\n right_point = count\r\n level += 1\r\n if not (left_point is None) and (not right_point is None) and left_point == 0 and right_point == len(phrase)-1:\r\n return True\r\n return False \r\n \r\n \r\n\r\n def is_function(phrase):\r\n\r\n \"\"\"Tests to see if a phrase begins with a predefined function,\r\n in which case it returns information about the iarity of function\"\"\"\r\n \r\n \r\n for x in self.functions.keys():\r\n\r\n if len(x) < len(phrase) and phrase[0:len(x)] == x:\r\n if bracketed(phrase[len(x):]):\r\n if self.functions[x][1]-1 <= phrase.count(',') <= self.functions[x][2]-1:\r\n return x, self.functions[x][0], self.functions[x][2], phrase[len(x):]\r\n else:\r\n return False,False,False,False \r\n \r\n\r\n def all_simple (phrase):\r\n\r\n \"\"\"Tests if a phrase is a simple string representing an expression, rather than an operation\"\"\"\r\n\r\n\r\n for x in phrase:\r\n if (x not in self.operations and not (isinstance(x,(int,type(ListType()),float,bool) or (isinstance(x,str) and quoted(x)))) or self.current_register.contains(x)):\r\n return False\r\n return True\r\n \r\n def parse (phrase):\r\n\r\n \r\n COMPTERMS = ['==','>=','<=','!=','>','<',]\r\n\r\n\r\n def contains_comp (x):\r\n \"\"\"True is x contains any of the COMP Terms\"\"\"\r\n\r\n for comp in COMPTERMS:\r\n if comp in x:\r\n return True\r\n return False\r\n\r\n\r\n \r\n \"\"\"Parses and analzes the phrase\"\"\"\r\n\r\n \r\n if phrase in ['bTrue','bFalse','EmptyList']:\r\n return {'bTrue':True,\r\n 'bFalse':False,\r\n 'EmptyList':ListType()}[phrase]\r\n\r\n if isinstance(phrase,str):\r\n \r\n if quoted(phrase):\r\n return phrase\r\n else:\r\n try:\r\n return float(phrase)\r\n except:\r\n pass\r\n \r\n\r\n # If the phrase is a string\r\n phrase = phrase.strip()\r\n\r\n func_name, func, iarity, func_phrase = is_function(phrase)\r\n # tests is it is function; otherwise the values are false.\r\n \r\n \r\n\r\n if func_name:\r\n if iarity == 1:\r\n # If the function accepts one value\r\n return func(parse(func_phrase))\r\n if iarity == 2:\r\n # Two values \r\n func_phrase = func_phrase[1:-1]\r\n term1,term2 = func_phrase.split(',')[0],func_phrase.split(',')[1]\r\n return func(parse(term1),parse(term2))\r\n if iarity == 3:\r\n func_phrase = func_phrase[1:-1]\r\n term1,term2, term3 = func_phrase.split(',')[0],func_phrase.split(',')[1],func_phrase.split(',')[2]\r\n return func(parse(term1),parse(term2),parse(term3))\r\n \r\n if iarity >3:\r\n # A list of values \r\n func_phrase = func_phrase[1:-1]\r\n return func([parse(x) for x in func_phrase.split(',')])\r\n elif phrase and phrase[0] == '-' and bracketed(phrase[1:]):\r\n # Translates negative sign (as opposed to operators) into corresponding function \r\n return -parse(phrase[2:-1])\r\n\r\n\r\n elif bracketed(phrase):\r\n # removes top-level bracket\r\n phrase = phrase[1:-1]\r\n return parse(phrase)\r\n elif phrase in self.operations:\r\n return phrase\r\n elif self.current_register.contains(phrase):\r\n # for variables and constants\r\n return self.current_register.get(phrase)\r\n elif contains_comp(phrase) and '(' not in phrase and ')' not in phrase:\r\n return calc.computer.get(phrase)\r\n elif phrase and phrase[0]=='@' and phrase[-1]=='@':\r\n # to retrieve values from the log \r\n index = int(parse(phrase[1:-1]))\r\n if 0<= index <= len(self.lines):\r\n return self.lines[index][0]\r\n else:\r\n \r\n phrase = list(phrase)\r\n #phrase is converted to a list to allowing indexical assignments\r\n operation_sequence = []\r\n level = 0\r\n inquotes = False\r\n quote_form = ''\r\n for counter, x in enumerate(phrase):\r\n\r\n # Search for operators that are not enclosed in parantheses\r\n\r\n if not inquotes and x in ['\"',\"'\"]:\r\n inquotes = True\r\n quote_form = x\r\n elif inquotes and x == quote_form:\r\n if counter < len(phrase)-1:\r\n if phrase[counter+1] in ['+']:\r\n phrase[counter+1] = '#+#'\r\n\r\n if x == '(':\r\n level +=1\r\n\r\n if x == ')':\r\n level -=1\r\n if level == 0:\r\n if counter<len(phrase)-1:\r\n if phrase[counter+1] in self.operations:\r\n # If an operator is found, surround it with pound signs\r\n phrase[counter+1] = '#'+phrase[counter+1]+'#'\r\n if phrase[counter+2] in self.operations:\r\n phrase[counter+2] = '~'\r\n # For a minus sign that is not an operator\r\n\r\n \r\n phrase = ''.join(phrase).replace('~','-').split('#')\r\n # Split the phrase into expressions linked by operators \r\n newphrase = []\r\n for x in phrase:\r\n # a clumsy way to distinction between numerical values, and string operators\r\n try:\r\n newphrase.append(float(x))\r\n except:\r\n newphrase.append(x)\r\n phrase = newphrase\r\n\r\n return parse(phrase)\r\n \r\n \r\n\r\n if isinstance(phrase,list):\r\n # If the phrase has already been parsed into a list \r\n if len(phrase) == 1:\r\n return (parse(phrase[0]))\r\n if all_simple(phrase):\r\n # If every value in the phrase list has been reduced to\r\n # a numerical value or an operator\r\n \r\n\r\n for operation in self.operations:\r\n\r\n #In order to preserve the correct order of operations,\r\n #the operations are analyzed in succession\r\n\r\n while operation in phrase:\r\n\r\n #This repeat as long as the operation is in the phrase,\r\n #since with each pass it only \"reduced\"\r\n #expression/operator/expression triplet\r\n \r\n\r\n newlist = [] # For the result of each pass through the list.\r\n lastvalue = None\r\n counter = 0\r\n stop = False\r\n while counter < len(phrase) and not stop:\r\n \r\n \r\n if counter < len(phrase)-2:\r\n a = phrase[counter]\r\n op = phrase[counter+1]\r\n b = phrase[counter+2]\r\n #take a triplet of values from the list\r\n\r\n if op == operation:\r\n # if an operator is found, reduced the triplet, and\r\n # then add the reduced value, together with the rest\r\n # of the list to the \r\n if operation == '*':\r\n c = a*b\r\n elif operation == '+':\r\n if isinstance(a,str) and isinstance(b,str):\r\n c = a[0:-1]+b[1:]\r\n else:\r\n c = a+b\r\n elif operation == '/':\r\n c = a/b\r\n elif operation == '^':\r\n c = a**b\r\n elif operation == '%':\r\n c = a % b\r\n elif operation == '-':\r\n c = a - b\r\n newlist.append(c)\r\n newlist += phrase[counter+3:] \r\n stop = True\r\n else:\r\n newlist.append(a)\r\n else:\r\n # otherwise, just add the text value to the new list\r\n newlist.append(phrase[counter])\r\n counter +=1 \r\n \r\n \r\n phrase = newlist\r\n\r\n \r\n else:\r\n # if the list is not yet simple, return a new list after parsing each element.\r\n phrase = [parse(x) for x in phrase]\r\n return parse(phrase)\r\n\r\n if isinstance(phrase,(int,float,type(ListType()),bool)):\r\n # if a numerical value, stop the recursion\r\n \r\n return phrase \r\n\r\n return parse(phrase)","def cosh(self):\n return type(self)(self.parent(),\n self._simplify(self._express.cosh()))","def visit_Compound(self, node):\n for child in node.children:\n self.visit(child)","def get_nested_sum():\n l_int = [1,2,[], 3,[4,[], 5,[6]],[7],[8,9], 10,[[],11]]\n print 'Sum:', nested_sum(l_int) \n return","def _calc_C(self, lambdify=True):\n\n C = None\n C_func = None\n # check to see if we have our term saved in file\n C, C_func = self._load_from_file('C', lambdify)\n\n if C is None and C_func is None:\n # if no saved file was loaded, generate function\n print('Generating centrifugal and Coriolis compensation function')\n\n # first get the inertia matrix\n M = self._calc_M(lambdify=False)\n\n # C_{kj} = sum_i c_{ijk}(q) \\dot{q}_i\n # c_{ijk} = 1/2 * sum_i (\\frac{\\partial M_{kj}}{\\partial q_j} +\n # \\frac{\\partial M_{ki}}{\\partial q_j} - \\frac{\\partial M_{ij}}\n # {\\partial q_k})\n C = sp.zeros(self.N_JOINTS, self.N_JOINTS)\n for kk in range(self.N_JOINTS):\n for jj in range(self.N_JOINTS):\n for ii in range(self.N_JOINTS):\n dMkjdqi = M[kk, jj].diff(self.q[ii])\n dMkidqj = M[kk, ii].diff(self.q[jj])\n dMijdqk = M[ii, jj].diff(self.q[kk])\n C[kk, jj] += .5 * (dMkjdqi + dMkidqj - dMijdqk) * self.dq[ii]\n C[kk, jj] = C[kk, jj]\n C = sp.Matrix(C)\n\n # save to file\n abr_control.utils.os_utils.makedirs(\n '%s/C' % self.config_folder)\n cloudpickle.dump(C, open(\n '%s/C/C' % self.config_folder, 'wb'))\n\n if lambdify is False:\n # if should return expression not function\n return C\n\n if C_func is None:\n C_func = self._generate_and_save_function(\n filename='C', expression=C,\n parameters=self.q+self.dq)\n return C_func","def complexity(text:str) -> float:\n words = text.split(' ')\n freqs = [frequency(w) for w in words]\n return sum(freqs) / (len(frequency_list) - freqs.count(0)) #sum of the frequencies / all the words that were in the list","def get_circuit_size(self, circuit: ACircuit, recursive: bool = False) -> Tuple[int, int]:","def combine_expression(self, connector, sub_expressions):\n lhs, rhs = sub_expressions\n if connector == '%%':\n return 'MOD(%s)' % ','.join(sub_expressions)\n elif connector == '&':\n return 'BAND(%s)' % ','.join(sub_expressions)\n elif connector == '|':\n return 'BOR(%s)' % ','.join(sub_expressions)\n elif connector == '^':\n return 'POWER(%s)' % ','.join(sub_expressions)\n elif connector == '<<':\n return '(%(lhs)s * POWER(2, %(rhs)s))' % {'lhs': lhs, 'rhs': rhs}\n elif connector == '>>':\n return 'FLOOR(%(lhs)s / POWER(2, %(rhs)s))' % {'lhs': lhs, 'rhs': rhs}\n return super().combine_expression(connector, sub_expressions)","def custom_quadratic(n_particles, coefficients, is_bosonic):\n if is_bosonic:\n op = bosonic_op if n_particles == 2 else bosonic_op_3\n else:\n op = fermionic_op if n_particles == 2 else fermionic_op_3\n\n if n_particles == 2:\n (J_11, J_22), (J_12,) = coefficients\n return J_11 * op[\"a1^dag a1\"] + J_12 * (op[\"a1^dag a2\"] + op[\"a2^dag a1\"]) + J_22 * op[\"a2^dag a2\"]\n\n elif n_particles == 3:\n (J_11, J_22, J_33), (J_12, J_13, J_23) = coefficients\n return (\n J_11 * op[\"a1^dag a1\"]\n + J_12 * (op[\"a1^dag a2\"] + op[\"a2^dag a1\"])\n + J_13 * (op[\"a1^dag a3\"] + op[\"a3^dag a1\"])\n + J_22 * op[\"a2^dag a2\"]\n + J_23 * (op[\"a2^dag a3\"] + op[\"a3^dag a2\"])\n + J_33 * op[\"a3^dag a3\"]\n )","def _nt_sum(cobj, prop, theta):\n # Build sum term\n i = 1\n s = 0\n while True:\n try:\n ni = getattr(cobj, f\"{prop}_coeff_n{i}\")\n ti = getattr(cobj, f\"{prop}_coeff_t{i}\")\n s += ni * theta**ti\n i += 1\n except AttributeError:\n break\n return s","def dfs(self, nums, cur_sum, S):\n ways = 0\n nums_length = len(nums)\n if nums_length == 0:\n if cur_sum == S:\n return 1\n return 0\n\n multiple = [1, -1]\n for value in multiple:\n new_num = nums[nums_length - 1]\n new_nums = nums[0:nums_length - 1]\n new_sum = cur_sum + new_num * value\n ways = ways + self.dfs(new_nums, new_sum, S)\n\n return ways","def associativity(ob):\n return 0","def conjugation(conj_id, present_base, perfect_base, present_ending, participle_base, infinitive):\n\t\n\t#TODO: Rewrite the following with attribute calls:\n \n tense = {}\n #Tenses, aspects and moods in Latin:\n tense[\"ind_a_pr\"] = conj_ind_a_pr(conj_id, present_base)\n tense[\"ind_a_im\"] = conj_ind_a_im(conj_id, present_base)\n tense[\"ind_a_fu\"] = conj_ind_a_fu(conj_id, present_base)\n tense[\"ind_a_pe\"] = conj_ind_a_pe(conj_id, perfect_base)\n tense[\"ind_a_pl\"] = conj_ind_a_pl(conj_id, perfect_base)\n tense[\"ind_a_fp\"] = conj_ind_a_fp(conj_id, perfect_base)\n tense[\"imp_a_pr\"] = conj_imp_a_pr(conj_id, present_base)\n tense[\"imp_p_pr\"] = conj_imp_p_pr(conj_id, infinitive, present_base) # c\n tense[\"imp_p_fu\"] = conj_imp_p_fu(conj_id, present_base)\n tense[\"imp_a_fu\"] = conj_imp_a_fu(conj_id, present_base)\n tense[\"ind_p_pr\"] = conj_ind_p_pr(conj_id, present_base, present_ending)\n tense[\"ind_p_im\"] = conj_ind_p_im(conj_id, present_base)\n tense[\"ind_p_fu\"] = conj_ind_p_fu(conj_id, present_base, present_ending)\n tense[\"sub_a_pr\"] = conj_sub_a_pr(conj_id, present_base)\n tense[\"sub_p_pr\"] = conj_sub_p_pr(conj_id, present_base)\n tense[\"sub_a_im\"] = conj_sub_a_im(infinitive)\n tense[\"sub_p_im\"] = conj_sub_p_im(infinitive)\n tense[\"sub_a_pe\"] = conj_sub_a_pe(perfect_base)\n tense[\"sub_a_pl\"] = conj_sub_a_pl(perfect_base)\n \n #TODO: Put the above in dictionary as objects?\n #\n tense[\"ind_p_pe\"] = (Esse.ipra, participle_parpp(participle_base))\n tense[\"ind_p_pl\"] = (Esse.iima, participle_parpp(participle_base))\n tense[\"sub_p_pe\"] = (Esse.sub_pr, participle_parpp(participle_base))\n tense[\"sub_p_pl\"] = (Esse.sub_im, participle_parpp(participle_base))\n tense[\"ind_p_fp\"] = (Esse.ind_fu, participle_parpp(participle_base))\n \n return tense","def __init__(self, children):\n super().__init__('complex', children, None)\n self.real = children[0].real\n self.imag = children[1].imag\n self.complex = self.real + self.imag*1j","def encode_compound(db, tree):\n length = 0\n data = 0\n sf = 0\n subfields = []\n for cn in tree.childNodes:\n l = 0\n if cn.nodeName == 'Variable':\n l, v = encode_variable(db, cn)\n else:\n if cn.nodeName == 'Fixed':\n l, v = encode_fixed(db, cn)\n else:\n if cn.nodeName == 'Repetitive':\n l, v = encode_repetitive(db, cn)\n else:\n if cn.nodeName == 'Variable':\n l, v = encode_variable(db, cn)\n else:\n if cn.nodeName == 'Compound':\n l, v = encode_compound(db, cn)\n\n if l > 0:\n subfields.append(sf)\n length += l\n data <<= (8 * l)\n data += v\n\n sf += 1\n\n n_octets = max(subfields) / 7 + 1\n primary_subfield = 0\n for i in sorted(subfields): # subfields\n primary_subfield += (1 << (8 * (i / 7) + (8 - (i % 7))))\n for i in range(n_octets - 1): # FX\n primary_subfield += (1 << 8 * (i + 1))\n\n data += (primary_subfield << (8 * length))\n\n return length + n_octets, data","def _cmplx_div_ ( s , o ) :\n return ( 1.0 / o ) * complex ( s )","def get_covered_terms(self):\n base = 0\n x_index = [index for index, item in enumerate(self.bin_str[::-1]) if item == '-']\n\n for index, item in enumerate(self.bin_str[::-1]):\n if item == '1':\n base += 2 ** index\n\n yield base\n\n for i in range(len(x_index)):\n for items in itertools.combinations(x_index, i + 1):\n accumulator = 0\n for index in items:\n accumulator += 2 ** index\n yield base + accumulator","def Cprimebound(relatorlist,Lambda=1):\n F,rels=fg.parseinputwords(relatorlist)\n if not all(r==F.cyclic_reduce(r) for r in rels):\n raise ValueError(\"Relators are not cyclically reduced.\")\n biggestratio=Fraction(1,min(len(r) for r in rels))\n if biggestratio>=Fraction(1,Lambda):\n return 1\n rels.sort(key=len) # sort list of relators with shortest first\n irels=[rel for rel in itertools.chain.from_iterable(zip([w() for w in rels],[(w**(-1))() for w in rels]))] # arrange relators and inverses in a list of the form relator1, inverse of relator1, relator2, inverse of relator2,...\n drels=[x+x for x in irels] # double the relators to look for pieces that would have wrapped\n for relatorindex in range(len(rels)):\n relator=irels[2*relatorindex]\n foundbiggest=False\n for L in range(len(relator),int(biggestratio*len(relator)),-1):# only check subwords of length L that would give biggest ratio if they were a piece\n for startingindex in range(len(relator)):\n p=(relator+relator)[startingindex:startingindex+L] # the subword of length L starting at index i in relator as a cyclic word\n # now we need to check if p is a piece\n # we do not need to check lower relatorindices, because we already scanned those relators for pieces\n if any(p in x for x in [(relator+relator)[startingindex+1:len(relator)+startingindex+L-1]]+[drels[i] for i in range(2*relatorindex+1,len(drels))]):# look in this (doubled) relator at higher starting indices, and in all later relators, for other copies of p. If found a matching subword, p is a piece.\n biggestratio=Fraction(len(p),len(relator))\n foundbiggest=True # we search pieces by decreasing length, so first one we find is longest\n if biggestratio>=Fraction(1,Lambda):\n return 1\n break\n if foundbiggest: # if we found the biggest piece in this relator we can move on to the next relator. \n break\n return biggestratio","def _compile(self, expression):\n t = re.split(r'\\s+(\\+|-)\\s+', expression)\n ocomps = t[::2] # output component sub-expressions\n signs = [1.] # implied + in front of expression\n signs.extend(1. if s == '+' else -1 for s in t[1::2]) \n factors = [(1., 1) for i in ocomps]\n for i, s in enumerate(ocomps):\n tt = re.split(r'\\s+(\\*|/)\\s+', s) # split on */ operator\n lval = self._lval(tt[0])\n if len(tt) > 1:\n factors[i] = self._rval(tt[2]), 1 if tt[1] == '*' else -1\n if not isinstance(lval, Output): \n if len(ocomps) == 1: # simple basic output (special case)\n self.is_basic = True\n self._factor = factors[0]\n self._compile_basic(lval)\n return\n else: # compound basic output\n ocomps[i] = Output(parent=self.parent,\n expression=lval,\n factor=factors[i],\n is_basic=True)\n else: # summary output\n ocomps[i] = lval #self.parent.outputs[lval]\n self._ocomps = ocomps\n self._signs = signs\n self._factors = factors","def Mol_SO(Nat, multip, charge, sym, SO_3rdrow_mols_val): # number of atoms, multiplicity, charge, array of atoms in molecule, value of SO_3rdrow_mols (from orca.inp file)\n\n Mol_SO = 0\n \n # Special Case - Acetleyne - S\n if Nat == 4 and multip == 2 and charge == 1:\n countH_temp =0\n countC_temp =0\n for tmp in range(len(sym)):\n if sym[tmp] == \"H\":\n countH_temp= countH_temp +1\n if sym[tmp] == \"C\":\n countC_temp = countC_temp +1\n if countH_temp == 2 and countC_temp == 2:\n Mol_SO = -0.07 #-0.07d0\n \n with open(\"Thermochemistry.out\", \"a\") as ther_chem:\n ther_chem.write(\"DETECTED A C2H2+ SYSTEM: Using SO parameters for acetylene cation\\n\")\n ther_chem.write(\"Ref: JCP 114, 9287, 2001\\n\\n\")\n # Special Case - Acetleyne - E\n \n # For diatomics with multip = 2\n if Nat == 2 and multip == 2 :\n sort_sym = sorted(sym, reverse=True)\n if SO_3rdrow_mols_val == \"true\": # for 3rd_row elements\n \n if charge == 0:\n if sort_sym[0] == 'O' and sort_sym[1] == 'Br': Mol_SO=-2.20\n \n # COMMMENT: paper has it for cation, but it looks like it is for neutral\n if sort_sym[0] == 'Se' and sort_sym[1] == 'H': Mol_SO=-4.21\n \n if charge == +1: ### RECHECK what the values of charge is!!!!!!!!!!!!!!!!!!!!!IMPORTANT\n if sort_sym[0] == 'K' and sort_sym[1] == 'Br': Mol_SO=-2.99\n if sort_sym[0] == 'H' and sort_sym[1] == 'As': Mol_SO=-3.54\n if sort_sym[0] == 'H' and sort_sym[1] == 'Br': Mol_SO=-6.26\n if sort_sym[0] == 'F' and sort_sym[1] == 'Br': Mol_SO=-6.10\n if sort_sym[0] == 'Na' and sort_sym[1] == 'Br': Mol_SO=-3.93\n if sort_sym[0] == 'Br' and sort_sym[1] == 'Br': Mol_SO=-6.55\n \n else: # for non 3rd row elements, first and second rows\n if charge == 0:\n if sort_sym[0] == 'H' and sort_sym[1] == 'C': Mol_SO=-0.07\n if sort_sym[0] == 'O' and sort_sym[1] == 'H': Mol_SO=-0.30\n if sort_sym[0] == 'O' and sort_sym[1] == 'N': Mol_SO=-0.27\n if sort_sym[0] == 'O' and sort_sym[1] == 'Cl': Mol_SO=-0.61\n if sort_sym[0] == 'S' and sort_sym[1] == 'H': Mol_SO=-1.01\n if sort_sym[0] == 'P' and sort_sym[1] == 'O': Mol_SO=-0.53\n if sort_sym[0] == 'Si' and sort_sym[1] == 'H': Mol_SO=-0.34\n \n if charge == -1:\n if sort_sym[0] == 'N' and sort_sym[1] == 'H': Mol_SO=-0.12\n if sort_sym[0] == 'P' and sort_sym[1] == 'H': Mol_SO=-0.45\n if sort_sym[0] == 'O' and sort_sym[1] == 'O': Mol_SO=-0.34\n if sort_sym[0] == 'S' and sort_sym[1] == 'S': Mol_SO=-1.12\n \n if charge == +1:\n if sort_sym[0] == 'H' and sort_sym[1] == 'F': Mol_SO=-0.62\n if sort_sym[0] == 'P' and sort_sym[1] == 'H': Mol_SO=-0.67\n if sort_sym[0] == 'H' and sort_sym[1] == 'Cl': Mol_SO=-1.60\n if sort_sym[0] == 'N' and sort_sym[1] == 'N': Mol_SO=-0.17\n if sort_sym[0] == 'O' and sort_sym[1] == 'O': Mol_SO=-0.43\n if sort_sym[0] == 'P' and sort_sym[1] == 'P': Mol_SO=-0.57\n if sort_sym[0] == 'S' and sort_sym[1] == 'S': Mol_SO=-1.25\n if sort_sym[0] == 'Cl' and sort_sym[1] == 'Cl': Mol_SO=-1.77\n if sort_sym[0] == 'F' and sort_sym[1] == 'Cl': Mol_SO=-1.60\n \n return(Mol_SO)","def visit_Compound(self, node):\n for statement in node.statements:\n self.visit(statement)","def length(cont):\r\n\r\n mySum = 0\r\n\r\n if cont == \"\":\r\n return 0\r\n else:\r\n mySum += 1 + length(cont[1:])\r\n return mySum","def calculate(self) -> complex128:\n\n if not self.__can_calculation_be_performed():\n raise AttributeError\n\n v_vectors = self.__calculate_v_vectors()\n\n permanent = 0\n for v_vector in v_vectors:\n v_sum = sum(v_vector)\n addend = pow(-1, v_sum)\n # Binomials calculation\n for i in range(len(v_vector)):\n addend *= binom(self.__input_state[i], v_vector[i])\n\n # Product calculation\n product = 1\n for j in range(len(self.__input_state)):\n if self.__output_state[j] == 0: # There's no reason to calculate the sum if t_j = 0\n continue\n # Otherwise we calculate the sum\n product_part = 0\n for i in range(len(self.__input_state)):\n product_part += (self.__input_state[i] - 2 * v_vector[i]) * self.__matrix[j][i]\n product_part = pow(product_part, self.__output_state[j])\n product *= product_part\n addend *= product\n permanent += addend\n\n permanent /= pow(2, sum(self.__input_state))\n\n return permanent","def get_complexes(self):\n q_cmplx = prefixes + \"\"\"\n SELECT ?complexTerm ?childName ?child ?stmt\n WHERE {\n {\n {?stmt belvoc:hasSubject ?complexTerm}\n UNION\n {?stmt belvoc:hasObject ?complexTerm .}\n UNION\n {?stmt belvoc:hasSubject ?term .\n ?term belvoc:hasChild ?complexTerm .}\n UNION\n {?stmt belvoc:hasObject ?term .\n ?term belvoc:hasChild ?complexTerm .}\n }\n ?complexTerm a belvoc:Term .\n ?complexTerm a belvoc:ComplexAbundance .\n ?complexTerm belvoc:hasChild ?child .\n ?child belvoc:hasConcept ?childName .\n }\n \"\"\"\n # Run the query\n res_cmplx = self.g.query(q_cmplx)\n\n # Store the members of each complex in a dict of lists, keyed by the\n # term for the complex\n cmplx_dict = collections.defaultdict(list)\n cmplx_ev = {}\n for stmt in res_cmplx:\n stmt_uri = stmt[3]\n ev = self._get_evidence(stmt_uri)\n for e in ev:\n e.epistemics['direct'] = True\n cmplx_name = term_from_uri(stmt[0])\n cmplx_id = stmt_uri + '#' + cmplx_name\n child = self._get_agent(stmt[1], stmt[2])\n cmplx_dict[cmplx_id].append(child)\n # This might be written multiple times but with the same\n # evidence\n cmplx_ev[cmplx_id] = ev\n # Now iterate over the stored complex information and create binding\n # statements\n for cmplx_id, cmplx_list in cmplx_dict.items():\n if len(cmplx_list) < 2:\n msg = 'Complex %s has less than 2 members! Skipping.' % \\\n cmplx_name\n logger.warning(msg)\n else:\n self.statements.append(Complex(cmplx_list,\n evidence=cmplx_ev[cmplx_id]))","def get_number_operators(self) -> int:\n if self.sons:\n return 1 + sum([son.get_number_operators() for son in self.sons])\n return 0","def collect_nested(expr, aggressive=False):\n\n def run(expr):\n # Return semantic (rebuilt expression, factorization candidates)\n\n if expr.is_Number or expr.is_Symbol:\n return expr, [expr]\n elif expr.is_Indexed or expr.is_Atom:\n return expr, []\n elif expr.is_Add:\n rebuilt, candidates = zip(*[run(arg) for arg in expr.args])\n\n w_numbers = [i for i in rebuilt if any(j.is_Number for j in i.args)]\n wo_numbers = [i for i in rebuilt if i not in w_numbers]\n\n w_numbers = collect_const(expr.func(*w_numbers))\n wo_numbers = expr.func(*wo_numbers)\n\n if aggressive is True and wo_numbers:\n for i in flatten(candidates):\n wo_numbers = collect(wo_numbers, i)\n\n rebuilt = expr.func(w_numbers, wo_numbers)\n return rebuilt, []\n elif expr.is_Mul:\n rebuilt, candidates = zip(*[run(arg) for arg in expr.args])\n rebuilt = collect_const(expr.func(*rebuilt))\n return rebuilt, flatten(candidates)\n elif expr.is_Equality:\n rebuilt, candidates = zip(*[run(expr.lhs), run(expr.rhs)])\n return expr.func(*rebuilt, evaluate=False), flatten(candidates)\n else:\n rebuilt, candidates = zip(*[run(arg) for arg in expr.args])\n return expr.func(*rebuilt), flatten(candidates)\n\n return run(expr)[0]","def process():\r\n\t### INPUT ####\r\n\tpq = eat(str)\r\n\tp, q = map(int, pq.split('/'))\r\n\t\r\n\t### COMPUT ####\r\n\td = gcd(p, q)\r\n\tp, q = p//d, q//d\r\n\teprint(bin(q), bin(p))\r\n\tif len(bin(q).strip('0')) != 2:\r\n\t\treturn IMPOSSIBLE\r\n\t#length of p\r\n\tbinp = bin(p)\r\n\tbinq = bin(q)\r\n\treturn len(binq) - len(binp)\r\n\t\r\n\t### OUTPUT ####\r\n\treturn solve()","def convex_conj(self):\n convex_conjs = [func.convex_conj for func in self.functionals]\n return SeparableSum(*convex_conjs)","def __add__(self, other):\n self.sum_complex_num = Complex((self.real + other.real), (self.imaginary + other.imaginary))\n return self.sum_complex_num","def radical_c2(self, atoms):\n\n c1, c2 = atoms.keys()\n c1_ndx, c2_ndx = atoms.values()\n\n chain1, chain2 = self.determine_chains([c1, c2])\n\n # to get indexing right\n c1_ndx -= self.monomer.indices[chain1]['C1']\n c2_ndx -= self.monomer.indices[chain2]['C2']\n\n # types after reaction\n types = {'chain1': {'C1': 'c3', 'C2': 'c2', 'C3': 'c2', 'C4': 'c2', 'H1': 'hc', 'H2': 'hc', 'H3': 'ha',\n 'H4': 'ha', 'H5': 'ha'}, # chain1 contains c1\n 'chain2': {'C1': 'c3', 'C2': 'c3', 'C3': 'c2', 'C4': 'c2', 'H1': 'hc', 'H2': 'hc', 'H3': 'hc',\n 'H4': 'ha', 'H5': 'ha'}} # chain2 contains c2 radical\n\n # update types\n reacted_types = {'chain1': {c1_ndx + self.monomer.indices[chain1][a]: types['chain1'][a]\n for a in types['chain1'].keys()},\n 'chain2': {c2_ndx + self.monomer.indices[chain2][a]: types['chain2'][a]\n for a in types['chain2'].keys()}}\n\n # new bonds\n bonds = [[c1_ndx + self.monomer.indices[chain1]['C1'], c2_ndx + self.monomer.indices[chain2]['C2'], 'carbon']]\n\n # no dummy bonds to add\n\n # define indices of left-over radicals\n radicals = [c1_ndx + self.monomer.indices[chain1]['C2']]\n\n chain1_impropers = ['C1'] # [1]\n chain2_impropers = ['C2'] # [2]\n rm_improper = []\n for c in chain1_impropers:\n rm_improper.append([c1_ndx + self.monomer.indices[chain1][x] for x in self.monomer.impropers[chain1][c]])\n for c in chain2_impropers:\n rm_improper.append([c2_ndx + self.monomer.indices[chain2][x] for x in self.monomer.impropers[chain2][c]])\n\n # define terminated atoms\n terminated = [c1_ndx + self.monomer.indices[chain1]['C1'], c2_ndx + self.monomer.indices[chain2]['C2']]\n\n return reacted_types, bonds, radicals, rm_improper, terminated","def qed_cc( s, m, r):\n\n l1_t2 = s + m\n l2 = r + s\n\n if l1_t2 % 2 != 0:\n return 0\n\n denom = factorial(s) * factorial(m) * factorial(r)**2\n nom = double_factorial( l1_t2 - 1 ) * factorial( l2 )\n\n return Fraction( nom, denom )","def RyserFormula(num_coincidence: int, U_st: numpy.ndarray) -> complex:\n\n value_perm = 0\n set = CreateSubset(num_coincidence)\n\n for subset in set:\n num_elements = len(subset)\n value_times = 1\n for i in range(num_coincidence):\n value_sum = 0\n for j in subset:\n value_sum += U_st[i, j]\n value_times *= value_sum\n value_perm += value_times * (-1) ** num_elements\n value_perm *= (-1) ** num_coincidence\n return value_perm","def test_complexity():\n file_paths = glob.iglob('*/*.py')\n for file_path in file_paths:\n with open(file_path, 'r') as file_obj:\n blocks = radon.cc_visit(file_obj.read())\n for block in blocks:\n fail_msg = '{} ({}) has a cyclomatic complexity of {}'.format(\n block.name, file_path, block.complexity)\n yield case.assertLessEqual, block.complexity, 10, fail_msg","def simplify (self):\n if (self.debug): print(f'enter fraction.simplify')\n hcf = find_hcf(self.value[0], self.value[1])\n self.value = (self.value[0] // hcf.product(), self.value[1] // hcf.product())\n return","def solve_equation_addition_precendence(eq, verbose=False):\n tokens = tokenize(eq)\n if verbose:\n print(f\"eq: {tokens}\")\n\n stack = []\n ops = {\n None: do_push,\n \"(\": do_push,\n \")\": do_parenthesis,\n \"+\": do_addition,\n \"*\": do_push,\n }\n\n for t in tokens:\n if isinstance(t, int):\n op = stack[-1] if len(stack) else None\n ops[op](stack, t)\n elif t == \"+\" or t == \"*\" or t == \"(\":\n stack.append(t)\n elif t == \")\":\n ops[\")\"](stack, t)\n # solve preparenthesis addition\n if len(stack) > 2:\n v = stack.pop()\n assert isinstance(v, int)\n ops[stack[-1]](stack, v)\n else:\n assert False, f\"fail token: {t}\"\n\n if verbose:\n print(f\"stack: {stack}\")\n\n # solve multiplications\n while len(stack) > 1:\n rhs = stack.pop()\n assert isinstance(rhs, int)\n op = stack.pop()\n if op == \"*\":\n lhs = stack.pop()\n assert isinstance(lhs, int)\n stack.append(lhs * rhs)\n else:\n assert False, f\"invalid operator (not *): {op}\"\n\n assert len(stack) == 1\n return stack[0]","def sum_proper_divisors(n):\r\n return sum(proper_divisors(n))","def tree_string(self):\n if self.body is None:\n return 0\n if self.left is None and self.right is None:\n return self.body\n left_sum = self.left.tree_string()\n right_sum = self.right.tree_string()\n if self.body == add:\n return str(left_sum) + '+' + str(right_sum)\n elif self.body == sub:\n return str(left_sum) + '-' + str(right_sum)\n elif self.body == mul:\n return str(left_sum) + '*' + str(right_sum)\n else:\n return str(left_sum) + '/' + str(right_sum)","def score( canvas ):\n\n score = 0\n\n score += length_score(canvas)\n score += angle_score(canvas)\n\n # 1. Chainbreaks for all junction loops.\n\n # 2. Nucleotides should be at least 15 from ALL other nts. Don't double-count.\n for seqpos1, nt1 in canvas.nucleotides.iteritems():\n for seqpos2, nt2 in canvas.nucleotides.iteritems():\n if seqpos1 >= seqpos2: continue\n #if distance( nt1, nt2 ) < 15: score += 100\n # Don't do a square root you don't have to\n if distance_squared( nt1, nt2 ) < 225: score += 100\n\n\n # 2b. Depending on base pair width, it's possible that the 'best' orientation for two stacks is\n # for them to be overlapping...\n # nt --- nt\n # | nt |-- nt\n # nt -|- nt |\n # | nt |-- nt\n # so, penalize this ( 'between two bp'ed nts' penalized like hitting a nt )\n for seqpos, nt in canvas.nucleotides.iteritems():\n for stem in canvas.stems:\n for bp in stem.base_pairs:\n if nt == bp.nt1 or nt == bp.nt2:\n continue\n # if nt in question is 'in between' nt1 and nt2. how to judge?\n if nt.x > bp.nt1.x and nt.x < bp.nt2.x \\\n and closer_than( nt.y, bp.nt1.y, canvas.bp_offset_height*0.8 ):\n score += 100\n\n # Look at pairs of adjacent nts in stem\n for seqpos1, nt1 in stem.nucleotides.iteritems():\n if seqpos1 + 1 in stem.nucleotides.keys():\n nt2 = stem.nucleotides[ seqpos1 + 1 ]\n if nt.y > nt1.y and nt.y < nt2.y \\\n and closer_than( nt.x, nt1.x, canvas.bp_offset_width*0.8 ):\n score += 100\n\n # 3. Stems should be straight and vertical.\n ### Resolved via kinematics?\n\n # 4. Coaxial stacks, where known, should be colinear.\n for idx1, idx2 in canvas.list_of_coaxialities:\n # idx1 and idx2 are coaxial stems.\n # Any two BPs from these stems should do, but -- because I have no idea\n # how we intend to handle 'alternate-order' stacks (where the first nt in a bp\n # is stacked on the second nt in another), compare either direction.\n bp1 = canvas.stems[idx1].base_pairs[0]\n bp2 = canvas.stems[idx2].base_pairs[0]\n penalty1 = harmonic_penalty( bp1.nt1.x - bp2.nt1.x, 0, 1 ) + harmonic_penalty( bp1.nt2.x - bp2.nt2.x, 0, 1 )\n penalty2 = harmonic_penalty( bp1.nt1.x - bp2.nt2.x, 0, 1 ) + harmonic_penalty( bp1.nt2.x - bp2.nt1.x, 0, 1 )\n score += min( penalty1, penalty2 )\n\n\n # 5. Apical loops should be symmetrical and near a circular path.\n for loop in canvas.loops:\n for seqpos in loop.nucleotides.keys():\n pass\n\n return score","def n_complex_components(self):\n return self.n_components // 2 + (self.n_components % 2)","def problem9_complex(n):\n # Start with 1 to avoid triples with zero.\n for u in range(1, n):\n for v in range(u, n):\n # When u == v one of the a, b becomes 0\n if u != v:\n\n # The following two blocks do the same thing.\n # First one uses complex numbers.\n # Second one uses generalised formulas.\n\n # comp = complex(u, v) ** 2\n # a = abs(comp.real)\n # b = abs(comp.imag)\n # c = sqrt(a ** 2 + b ** 2)\n\n a = abs(u ** 2 - v ** 2)\n b = abs(2 * u * v)\n c = abs(u ** 2 + v ** 2)\n\n if a + b + c == n:\n return a * b * c\n return None","def visit_term(self, node, children):\n if self.debug:\n print(\"Term {}\".format(children))\n term = children[0]\n for i in range(2, len(children), 2):\n if children[i-1] == \"*\":\n term *= children[i]\n else:\n term /= children[i]\n if self.debug:\n print(\"Term = {}\".format(term))\n return term","def length(formula):\n if isinstance(formula, Atom):\n return 1\n if isinstance(formula, Not):\n return length(formula.inner) + 1\n if isinstance(formula, Implies) or isinstance(formula, And) or isinstance(formula, Or):\n return length(formula.left) + length(formula.right) + 1","def check_rec(eqparams, tracecombo=(dict(), 0, set(range(10))), p=0):\n # Basic parameters of the equation,\n # maximal digit rank\n # characters with multipliers by rank\n # unique non-zero characters by rank\n # unique zero-allowed characters by rank\n # all unique characters by rank\n maxp, tchars, unzchars, uokzchars, uchars = eqparams\n # recursion cumulative parameters\n # established characters with digits\n # carry-over from the previous level\n # remaining unassigned digits\n prevdict, cover, remdigs = tracecombo\n # the maximal 10-power (beyond the maximal rank)\n # is reached\n if p == maxp:\n # Carry-over is zero, meaning solution is found\n if cover == 0:\n return prevdict\n else:\n # Otherwise the solution in this branch is not found\n # return empty\n return dict()\n diglets = uchars[p] # all new unique letters from the current level\n partsum = cover # Carry over from lower level\n remexp = [] # TBD letters\n # Break down the current level letter into what can be\n # calculated in the partial sum and remaining TBD letter-digits\n for c, v in tchars[p]:\n if c in prevdict:\n partsum += v * prevdict[c]\n else:\n remexp.append((c, v))\n # Generate permutations for the remaining digits and currecnt level\n # non-zero letters and zero-allowed letters\n for newdigs in digPerms(remdigs, unzchars[p], uokzchars[p]):\n # build the dictionary for the new letters and this level\n newdict = dict(zip(diglets, newdigs))\n # complete the partial sum into test sum using the current permutation\n testsum = partsum + sum([newdict[c] * v\n for c, v in remexp])\n # check if the sum is divisible by 10\n d, r = divmod(testsum, 10)\n if r == 0:\n # if divisible, update the dictionary to all established\n newdict.update(prevdict)\n # proceed to the next level of recursion with\n # the same eqparams, but updated digit dictionary,\n # new carry over and remaining digits to assign\n rectest = check_rec(eqparams,\n (newdict, d, remdigs - set(newdigs)),\n p + 1)\n # if the recursive call returned a non-empty dictionary\n # this means the recursion has found a solution\n # otherwise, proceed to the new permutation\n if rectest and len(rectest) > 0:\n return rectest\n # if no permutations are avaialble or no\n # permutation gave the result return None\n return None","def test_ccsd_doubles_a_terms(parthole_drudge):\n\n dr = parthole_drudge\n p = dr.names\n\n a, b, c, d = p.V_dumms[:4]\n i, j, k, l = p.O_dumms[:4]\n u = dr.two_body\n t = IndexedBase('t')\n dr.set_dbbar_base(t, 2)\n\n tau = dr.define_einst(\n IndexedBase('tau')[a, b, i, j],\n Rational(1, 2) * t[a, b, i, j] + t[a, i] * t[b, j]\n )\n\n a_i = dr.define_einst(\n IndexedBase('ai')[k, l, i, j], u[i, c, k, l] * t[c, j]\n )\n\n a_ = dr.define(\n IndexedBase('a')[k, l, i, j],\n u[k, l, i, j] +\n a_i[k, l, i, j] - a_i[k, l, j, i]\n + u[k, l, c, d] * tau[c, d, i, j]\n )\n\n tensor = dr.define_einst(\n IndexedBase('r')[a, b, i, j],\n a_[k, l, i, j] * tau[a, b, k, l]\n )\n targets = [tensor]\n\n eval_seq = optimize(\n targets, substs={p.nv: p.no * 10}, strategy=Strategy.ALL | Strategy.SUM\n )\n assert verify_eval_seq(eval_seq, targets)\n # Here we just assert that the final step is a simple product.\n assert len(eval_seq[-1].rhs_terms) == 1","def test_simple_cc():\n hs_c = LocalSpace('c', dimension=3)\n hs_q = LocalSpace('q1', basis=('g', 'e'))\n Delta_1 = Symbol('Delta_1')\n Omega_1 = Symbol('Omega_1')\n g_1 = Symbol('g_1')\n a = Destroy(hs=hs_c)\n a_dag = Create(hs=hs_c)\n sig_p = LocalSigma('e', 'g', hs=hs_q)\n sig_m = LocalSigma('g', 'e', hs=hs_q)\n coeff = (-I / 2) * (Omega_1 * g_1 / Delta_1)\n jc_expr = coeff * (a * sig_p - a_dag * sig_m)\n\n simplified = rewrite_with_operator_pm_cc(jc_expr)\n assert simplified == coeff * OperatorPlusMinusCC(a * sig_p, sign=-1)\n assert (\n srepr(simplified.term)\n == \"OperatorPlusMinusCC(OperatorTimes(Destroy(hs=LocalSpace('c', \"\n \"dimension=3)), LocalSigma('e', 'g', hs=LocalSpace('q1', \"\n \"basis=('g', 'e')))), sign=-1)\"\n )\n expanded = simplified.doit()\n assert expanded == jc_expr","def normal(e, **kw_args):\n\n if not e:\n return S.Zero\n\n opts = {\n 'simplify_kronecker_deltas': False,\n 'expand': True,\n 'simplify_dummies': False,\n 'keep_only_fully_contracted': False,\n 'lam': 1\n }\n opts.update(kw_args)\n\n # break up any NO-objects, and evaluate commutators\n e = e.doit(wicks=True)\n\n # make sure we have only one term to consider\n e = e.expand()\n if isinstance(e, Add):\n return Add(*[ normal(term, **kw_args) for term in e.args])\n\n # For Mul-objects we can actually do something\n if isinstance(e, Mul):\n\n # we don't want to mess around with commuting part of Mul\n # so we factorize it out before starting recursion\n c_part = []\n string1 = []\n for factor in e.args:\n if factor.is_commutative:\n c_part.append(factor)\n else:\n string1.append(factor)\n n = len(string1)\n\n # catch trivial cases\n if n == 0:\n result = e\n elif n == 1:\n result = e\n else: # non-trivial\n if n > 2:\n # recursive step\n if isinstance(string1[0], CreateBoson) \\\n or (string1[0].is_Pow and \\\n isinstance(string1[0].args[0], CreateBoson)):\n # if the first term is ad^m\n result = string1[0] * normal(Mul(*string1[1:]), **kw_args)\n else:\n # if the first term is a^m,\n # bring the first two terms to normal order first\n result = normal(normal(Mul(*string1[:2]), **kw_args)*Mul(*string1[2:]), **kw_args)\n else: # n = 2,\n result = _normal(string1, opts['lam'])\n result = Mul(*c_part)*result\n\n if opts['expand']:\n result = result.expand()\n # if opts['simplify_kronecker_deltas']:\n # result = evaluate_deltas(result)\n\n return result\n\n # there was nothing to do\n return e","def degree_on_basis(self, b):\n return sum(b)","def connectors_calc(level):\n global connectors\n connectors = level*(level+1)/2\n return connectors","def C(relatorlist,quit_at=float('inf')):\n F,rels=fg.parseinputwords(relatorlist)\n if not all(r==F.cyclic_reduce(r) for r in rels):\n raise ValueError(\"Relators are not cyclically reduced.\")\n thepieces=pieces(rels)\n minnumberpieces=quit_at\n def min_string_piece_expression(whatsleft,thepieces,quit_at):\n # recursively determine the minimal expression of the string whatsleft as a concatenation of elements of thepieces, or stop once it is determined that any such expression requires at least quit_at many pieces\n # find a piece that agrees with a prefix of whatsleft and the recurse on the suffix\n if not whatsleft:\n return 0\n minexp=quit_at\n for p in thepieces:\n if p!=whatsleft[:len(p)]:\n continue\n else:\n minexp=min(minexp,1+min_string_piece_expression(whatsleft[len(p):],thepieces,minexp-1))\n return minexp\n def min_relator_piece_expression(relator,thepieces,quit_at):\n # This is first step in recursive search. Here we want to find a piece p such that for relator r we can write p=xy and r=yzx, with y nontrivial. That is, in this step only we think of r as cyclic word and allow first piece that wraps.\n r=relator()\n minexp=quit_at\n for p in thepieces:\n if len(p)>len(r):\n continue\n possiblestartingindices=[] # for given p there may be different possible choices of y\n for startingindex in range(len(r)-len(p)+1,len(r)+1):\n if p==(r+r)[startingindex:startingindex+len(p)]:\n possiblestartingindices.append(startingindex)\n if not possiblestartingindices:\n continue\n for startingindex in possiblestartingindices:\n # found a way to fit p into r spanning the beginning of r. This accounts for x and y part of r. Now recursively find shortest expression of z=whatsleft as a concatenation of pieces.\n whatsleft=(r+r)[startingindex+len(p):startingindex+len(r)]\n if not whatsleft:\n return 1\n else:\n minexp=min(minexp,1+min_string_piece_expression(whatsleft,thepieces,minexp-1))\n return minexp\n for thisrelator in rels:\n minnumberpieces=min(minnumberpieces,min_relator_piece_expression(thisrelator,thepieces,minnumberpieces))\n return minnumberpieces","def CalcSingleCompoundDescriptor(compos, argVect, atomDict, propDict):\n try:\n atomVarNames = argVect[0]\n compositionVarNames = argVect[1]\n formula = argVect[2]\n formula = _SubForCompoundDescriptors(formula, compositionVarNames, 'propDict')\n formula = _SubForAtomicVars(formula, atomVarNames, 'atomDict')\n evalTarget = _SubMethodArgs(formula, knownMethods)\n except Exception:\n if __DEBUG:\n import traceback\n print('Sub Failure!')\n traceback.print_exc()\n print(evalTarget)\n print(propDict)\n raise RuntimeError('Failure 1')\n else:\n return -666\n\n try:\n v = eval(evalTarget)\n except Exception:\n if __DEBUG:\n import traceback\n outF = open(RDConfig.RDCodeDir + '/ml/descriptors/log.txt', 'a+')\n outF.write('#------------------------------\\n')\n outF.write('formula: %s\\n' % repr(formula))\n outF.write('target: %s\\n' % repr(evalTarget))\n outF.write('propDict: %s\\n' % (repr(propDict)))\n\n outF.write('keys: %s\\n' % (repr(sorted(atomDict))))\n outF.close()\n print('ick!')\n print('formula:', formula)\n print('target:', evalTarget)\n print('propDict:', propDict)\n print('keys:', atomDict.keys())\n traceback.print_exc()\n raise RuntimeError('Failure 2')\n else:\n v = -666\n return v","def lucas_recur(n):\n if n == 0:\n return 2\n elif n == 1:\n return 1\n return lucas_recur(n - 1) + lucas_recur(n - 2)","def all_change(cur: Currency, r: float, max_permutation=1000, only_cents=True) -> List[Union[int, List]]:\n\n # sub problem: combinations to return n < r with a set of coins s' subset of s\n # base case: combinations to return 0 = 1: empty list\n # characteristic equation: sum of combinations using that coin with combinations without using that coin.\n\n # introducing convenient notation working in cents\n m = cur.num_denominations()\n S = [_ for _ in cur.iter_denominations()] if only_cents else [_float2int(x) for x in cur.iter_denominations()]\n n = _float2int(r) if not only_cents else r\n\n # Construct table\n T = [[[0, []] for _ in range(m)] for _ in range(n + 1)]\n\n # Base case (value zero has just one solution: empty list)\n for i in range(m):\n T[0][i] = [1, [[0 for _ in range(m)]]]\n\n # Fill rest of the table entries\n for i in range(1, n + 1):\n for j in range(m):\n # Count of solutions including S[j]\n x = T[i - S[j]][j][0] if i - S[j] >= 0 else 0\n\n # get max_permutation permutation value\n if x > 0:\n k = 0\n while len(T[i][j][1]) < max_permutation and k < len(T[i - S[j]][j][1]):\n sol = T[i - S[j]][j][1][k]\n T[i][j][1].append(sol[:])\n T[i][j][1][-1][j] += 1\n k += 1\n\n # Count of solutions excluding S[j]\n y = T[i][j - 1][0] if j >= 1 else 0\n\n # get max_permutation permutation value\n if y > 0:\n k = 0\n while len(T[i][j][1]) < max_permutation and k < len(T[i][j - 1][1]):\n sol = T[i][j - 1][1][k]\n T[i][j][1].append(sol[:])\n k += 1\n\n # total count\n T[i][j][0] = x + y\n\n return T[-1][-1]","def computeList(Code):\r\n \r\n l = len(Code);\r\n # Make sure number of left brackets still == no of right brackets\r\n checkBrackets(Code);\r\n \r\n if l == 0:\r\n return None\r\n \r\n # Base case: Code = ['T'] or ['F'] or has brackets.\r\n if l == 1:\r\n \r\n C = Code[0].strip('( )');\r\n \r\n if C in constants: return C;\r\n \r\n else: return Exception(\"output is neither true nor false.\");\r\n \r\n \r\n # Secondary case: No brackets remaining.\r\n elif not containsBrackets(Code):\r\n \r\n sub = {}; # records reduced indices in list, as a result of computation\r\n \r\n order = tuple();\r\n for prec in precedence:\r\n order += orderOfComputation(Code, prec); # Order of looking at the computation\r\n \r\n for i in order:\r\n \r\n s = total_sub(sub, i); # Computes the total to be subtracted from index.\r\n j = i-s; item = Code[j];\r\n \r\n # Negation case.\r\n if inputs[item] == 1:\r\n f = interpret[item]; inp = interpret[Code[j+1]];\r\n result = f(inp); string = inverse[result];\r\n Code = Code[:j] + [string] + Code[j+2:];\r\n \r\n # Update sub\r\n if not i in sub:\r\n sub[i] = 1;\r\n \r\n else:\r\n sub[i] += 1;\r\n \r\n # Binary Relation case.\r\n elif inputs[item] == 2:\r\n f = interpret[item]; \r\n inp = (interpret[Code[j-1]], interpret[Code[j+1]]);\r\n result = f(*inp); string = inverse[result];\r\n Code = Code[:j-1] + [string] + Code[j+2:];\r\n \r\n # Update sub\r\n if not i in sub:\r\n sub[i] = 2;\r\n \r\n else:\r\n sub[i] += 2;\r\n \r\n else:\r\n raise Exception('incomplete inputs set.')\r\n \r\n \r\n # Tertiary case: brackets left inside to compute.\r\n else: # Here, deal with brackets to make sure no brackets are contained in between.\r\n \r\n # Remove the same total number of brackets from each end.\r\n if not hasMidBrackets(Code):\r\n endB = endBrackets(Code); first = endB[0]; last = endB[1];\r\n Code = Code[first+1: last]; \r\n \r\n return computeList(Code);\r\n \r\n # Keep going until right bracket\r\n j = 0;\r\n while not \")\" in Code[j]: j += 1;\r\n \r\n # Go back for left bracket.\r\n i = j-1;\r\n while not \"(\" in Code[i] or i < 0: i -= 1;\r\n \r\n if i < 0: raise Exception(\"improper use of brackets.\");\r\n \r\n Code = Code[:i] + [ computeList(Code[i+1:j]) ] + Code[j+1:];\r\n \r\n return computeList(Code);","def complex(real, imag):","def theta(conc, S, educts):\n\n educts_per_reaction = educts.T\n\n # in every reaction j row, element at pos (column, species) i equals conc_i^educt_{ij}\n # educt_{ij} - how many units of i are educts in reaction j\n multiplicative_term_rows = np.power(conc, educts_per_reaction)\n\n # concentrations to educt product ----> product_{i=1}^{n_s}(conc_i^{educt_{ij}}\n concentration_product = np.prod(multiplicative_term_rows, axis=1)\n\n # returns one row with #reactions elements -> fluxes\n return concentration_product * S","def number_of_extensions(M, root=None):\n\n sp_order_formula = [i for i in M.series_partial_order_representation(root) if\n (i.__contains__('series') or i.__contains__('parallel'))]\n\n while sp_order_formula:\n\n # Extend the children of the current operator\n operator = sp_order_formula.pop()\n left, right = M.tree.successors(operator)\n\n for child in [left, right]:\n\n # Recursion if the child is a operator (also known as a sub-tree in Binary Construction Tree).\n if M.tree.node[child]['num_extension'] == 0:\n if child.__contains__('series') or child.__contains__('parallel'):\n M.tree.node[child]['num_extension'] = number_of_extensions(M, child)\n else:\n M.tree.node[child]['num_extension'] = 1\n\n # Employ the property of series-parallel partial order to calculate the number of extension\n if operator.__contains__('series'):\n num_extension = (M.tree.node[left]['num_extension']) * (M.tree.node[right]['num_extension'])\n M.tree.node[operator]['num_extension'] = num_extension\n\n if operator.__contains__('parallel'):\n # n1, n2 is the number of events (labels) on a partial order, we need to store the previous result.\n n1 = len([i for i in M.series_partial_order_representation(left) if\n not (i.__contains__('series') or i.__contains__('parallel'))])\n n2 = len([i for i in M.series_partial_order_representation(right) if\n not (i.__contains__('series') or i.__contains__('parallel'))])\n\n num_extension = (math.factorial(n1 + n2) / (math.factorial(n1) * (math.factorial(n2)))) * (\n M.tree.node[left]['num_extension']) * (M.tree.node[right]['num_extension'])\n\n M.tree.node[operator]['num_extension'] = num_extension\n #\n # # When series structure\n # if operator.__contains__('series') or operator.__contains__('parallel'):\n # try:\n # # Employ the property of series-parallel partial order to calculate the number of extension\n # if operator.__contains__('series'):\n # num_extension = (M.tree.node[left]['num_extension']) * (M.tree.node[right]['num_extension'])\n # M.tree.node[operator]['num_extension'] = num_extension\n #\n # if operator.__contains__('parallel'):\n # # n1, n2 is the number of events (labels) on a partial order, we need to store the previous result.\n # n1 = len(M.series_partial_order_representation(left))\n # n2 = len(M.series_partial_order_representation(right))\n #\n # num_extension = (math.factorial(n1 + n2) / (math.factorial(n1) * (math.factorial(n2)))) * (\n # M.tree.node[left]['num_extension']) * (M.tree.node[right]['num_extension'])\n #\n # M.tree.node[operator]['num_extension'] = num_extension\n #\n # print \"{}:{}\".format(operator, num_extension)\n # sp_order_formula.append(operator)\n # except Exception:\n # raise Exception\n #\n # # When parallel structure\n # else:\n # if len(temp_stack) > 0:\n # temp_left = temp_stack.pop()\n #\n # # When they share the same parent then push the temp_left to sp_order_formula\n # if M.tree.predecessors(temp_left)[0] == M.tree.predecessors(left)[0]:\n # sp_order_formula.append(operator)\n # sp_order_formula.append(right)\n # sp_order_formula.append(left)\n # sp_order_formula.append(temp_left)\n # # otherwise, keep pushing the new operator(parent) to temp_stack\n # else:\n # temp_stack.append(left)\n # sp_order_formula.append(operator)\n # sp_order_formula.append(right)\n #\n # result = sp_order_formula.pop()\n return M.tree.node[root]['num_extension']","def complex_value(self) -> global___Expression.ComplexValue:","def get_contributions(codings, sorted_factors):\n if codings:\n formulae = []\n for prod_of_factors in codings:\n cur_formula = I\n for n, c in codings[prod_of_factors]:\n if c == 'indicator':\n cur_formula = cur_formula * sorted_factors[n].formula\n else:\n cur_formula = cur_formula * sorted_factors[n].drop_first\n formulae.append((cur_formula, ':'.join(prod_of_factors)))\n else:\n formulae = [(Formula([1]),'1')]\n return formulae","def solve_part1(input, verbose=False):\n equations = parse(input)\n\n result = []\n for eq in equations:\n result.append(solve_equation_same_precedence(eq, verbose))\n\n if verbose:\n print(f\"results: {result}\")\n\n return sum(result)"],"string":"[\n \"def _calculate_syntactic_complexity(self):\\n count = 0\\n if self.connector is not None:\\n count = 1 # the term connector\\n for subterm in self.subterms:\\n count = count + subterm._calculate_syntactic_complexity()\\n return count\",\n \"def _calculate_complexity(workflow):\\n complexity = estimate_complexity(workflow.type_, workflow.reana_specification)\\n workflow.complexity = complexity\\n Session.commit()\\n return complexity\",\n \"def complexity(self):\\n n = 0\\n ctx = self\\n while ctx is not None:\\n n += 1\\n ctx = ctx.parent()\\n return n\",\n \"def simplify(term):\\n simplified_term = term\\n\\n if isinstance(term,StatementTerm):\\n simplified_term = StatementTerm(subject_term=simplify(term.get_subject_term()),\\n predicate_term=simplify(term.get_predicate_term()),\\n copula=term.get_copula(),\\n interval=term.interval)\\n elif isinstance(term,CompoundTerm):\\n if term.connector == NALSyntax.TermConnector.Negation and \\\\\\n len(term.subterms) == 1 and \\\\\\n isinstance(term.subterms[0],CompoundTerm) and \\\\\\n term.subterms[0].connector == NALSyntax.TermConnector.Negation :\\n # (--,(--,(S --> P)) <====> (S --> P)\\n # Double negation theorem. 2 Negations cancel out\\n simplified_term = simplify(term.subterms[0].subterms[0]) # get the inner statement\\n # elif NALSyntax.TermConnector.is_conjunction(term.connector):\\n # #(&&,A,B..C)\\n # new_subterms = []\\n # new_intervals = []\\n # for i in range(len(term.subterms)):\\n # subterm = simplify(term.subterms[i])\\n # if i < len(term.intervals): new_intervals.append(term.intervals[i])\\n # if isinstance(subterm, CompoundTerm) and subterm.connector == term.connector:\\n # # inner conjunction\\n # new_subterms.extend(subterm.subterms)\\n # new_intervals.extend(subterm.intervals)\\n # else:\\n # new_subterms.append(subterm)\\n #\\n # simplified_term = CompoundTerm(subterms=new_subterms,\\n # term_connector=term.connector,\\n # intervals=new_intervals)\\n elif term.connector is NALSyntax.TermConnector.ExtensionalDifference:\\n pass\\n elif term.connector is NALSyntax.TermConnector.IntensionalDifference:\\n pass\\n elif term.connector is NALSyntax.TermConnector.ExtensionalImage:\\n pass\\n elif term.connector is NALSyntax.TermConnector.IntensionalImage:\\n pass\\n\\n\\n return simplified_term\",\n \"def commands_complexity():\\n complexity()\",\n \"def cyclomaticComplexity (self):\\n self.tarjan()\\n return len(self.__edges) - len(self.__nodes) + 2 * len(self.__scc)\",\n \"def __simplifyRecurse(self): # TODO make this work with ^\\n # check if we're a + node, a * node, or a simple node\\n if isinstance(self.poly, (int, float, Variable.Variable)):\\n return self\\n elif self.poly[0] == \\\"+\\\":\\n self.__handlePowPlus()\\n\\n newPoly = Polynomial()\\n newPoly.poly = [\\\"+\\\"]\\n for branch in self.poly[1:]:\\n simplifiedBranch = ensurePoly(branch).__simplifyRecurse()\\n if not simplifiedBranch.isSimple():\\n for additiveTerm in simplifiedBranch.poly[1:]:\\n newPoly.poly.append(additiveTerm)\\n else:\\n newPoly.poly.append(simplifiedBranch)\\n return newPoly\\n elif self.poly[0] == \\\"*\\\":\\n self.__handlePowTimes()\\n\\n nonSimple, simple = self.__partitionSimpleAndNonSimpleBranches()\\n\\n if len(nonSimple) == 0: # this means our * node gives a monomial!\\n return Polynomial(input=self)\\n else:\\n # do the full distribution\\n simplified = self.__distribute(nonSimple, simple)\\n newPoly = Polynomial()\\n newPoly.poly = [\\\"+\\\"]\\n for branch in simplified.poly[1:]:\\n recursive = ensurePoly(branch).__simplifyRecurse()\\n if recursive.poly[0] == \\\"*\\\":\\n newPoly.poly.append(recursive)\\n elif recursive.poly[0] == \\\"+\\\":\\n newPoly.poly.extend(recursive.poly[1:])\\n return newPoly\\n\\n elif self.poly[0] == \\\"^\\\":\\n # this case will only be hit when we have a ^ node as the root\\n newPoly = Polynomial()\\n newPoly.poly = [\\\"*\\\"]\\n for _ in range(self.poly[2]):\\n newPoly.poly.append(self.poly[1])\\n\\n simp = newPoly.__simplifyRecurse()\\n return simp\",\n \"def get_total_complexity(n):\\n total = 0\\n for i in range(1, n + 1):\\n total += get_complexity(i)\\n return total\",\n \"def complexity(self):\\n raise NotImplementedError()\",\n \"def design_complexity(design: Design) -> int:\\n diversity = 3 * len(design.required)\\n abundance = 2 * sum(design.required.values())\\n return diversity + abundance + design.additional\",\n \"def calculate_compound_costs(self, recursive: bool = True):\\n assert self.graph_handler\\n if not self.start_compounds_set:\\n raise RuntimeError(\\\"No start conditions given\\\")\\n if len(self.graph_handler.graph.nodes) == 0:\\n raise RuntimeError(\\\"No nodes in graph\\\")\\n cmps_to_check = [n for n in self.graph_handler.graph.nodes if ';' not in n\\n and n not in self.start_compounds]\\n # # # Set all compounds to be checked to pseudo inf cost\\n for cmp_id in cmps_to_check:\\n self.compound_costs[cmp_id] = self._pseudo_inf\\n # # # Dictionary for current run\\n tmp_compound_costs: Dict[str, float] = {}\\n # # # Determine convergence variables for while loop\\n current_inf_count = sum(value == self._pseudo_inf for value in self.compound_costs.values())\\n prev_inf_count = current_inf_count\\n # # # Convergence criteria\\n compound_costs_change = None\\n compound_costs_opt_change = 1\\n converged = False\\n # # # Find paths until either no costs are unknown or the None count has not changed\\n while (not converged):\\n compound_costs_opt_change = 0\\n print(\\\"Remaining Nodes:\\\", len(cmps_to_check))\\n for tmp_start_node in self.start_compounds:\\n # # # Loop over all nodes to be checked starting from start nodes\\n for target in cmps_to_check:\\n # # # Determine cost and path with dijkstra's algorithm\\n tmp_cost, _ = nx.single_source_dijkstra(self.graph_handler.graph, tmp_start_node, target,\\n cutoff=None, weight=self.__weight_func)\\n # # # Check if the obtained cost is larger than infinity (pseudo_inf)\\n # # # and continue with the next target if this is the case\\n if (tmp_cost - self._pseudo_inf) > 0.0:\\n continue\\n # # # Add cost of the starting node\\n tmp_cost += self.compound_costs[tmp_start_node]\\n # # # Check for value in compound_costs dict and\\n if (self.compound_costs[target] != self._pseudo_inf and\\n 10e-6 < self.compound_costs[target] - tmp_cost):\\n compound_costs_opt_change += 1\\n # # # Not already set check\\n if self.compound_costs[target] == self._pseudo_inf or (\\n self.compound_costs != self._pseudo_inf and 10e-6 < self.compound_costs[target] - tmp_cost):\\n # # # Not discovered in current run OR new tmp cost lower than stored cost\\n if (target not in tmp_compound_costs.keys()):\\n tmp_compound_costs[target] = tmp_cost\\n elif (tmp_cost < tmp_compound_costs[target]):\\n tmp_compound_costs[target] = tmp_cost\\n # # # Write obtained compound_costs to overall dictionary\\n for key, value in tmp_compound_costs.items():\\n self.compound_costs[key] = value\\n # # # Remove found nodes if recursive is false\\n if not recursive:\\n cmps_to_check.remove(key)\\n # # # Reset tmp_pr_cost\\n tmp_compound_costs = {}\\n # # # Convergence Check\\n current_inf_count = sum(value == self._pseudo_inf for value in self.compound_costs.values())\\n compound_costs_change = prev_inf_count - current_inf_count\\n prev_inf_count = current_inf_count\\n\\n print(50 * '-')\\n print(\\\"Current None:\\\", current_inf_count)\\n print(\\\"PR Change:\\\", compound_costs_change)\\n print(\\\"PR Opt Change:\\\", compound_costs_opt_change)\\n # # # Convergence Check\\n if (compound_costs_change == 0 and compound_costs_opt_change == 0):\\n converged = True\\n\\n # # # Final check if all compound costs are solved\\n if current_inf_count == 0:\\n self.compound_costs_solved = True\",\n \"def complexity(self):\\n complexity = 0\\n for k in self.keys():\\n for i, j in combinations(range(1, max(k) + 1), 2):\\n seq = filter(lambda x: x == i or x == j, k)\\n cpxty = len([p for p, q in pairwise(seq) if p != q])\\n complexity = max(cpxty, complexity)\\n return complexity\",\n \"def complexity(self):\\n from kinbaku._pygenie import gettype, getpath\\n from kinbaku.python import Dotpath\\n if not self.contents:\\n return\\n try:\\n stats = measure_complexity(self.contents, self.fname)\\n except SyntaxError:\\n return None\\n\\n out = PrettyPrinter(StringIO()).flatten_stats(stats)\\n out = [ [ gettype(_type),\\n getpath(_type,dotpath),\\n score ] for _type, dotpath, score in out ]\\n return out\",\n \"def calc_complexity_step(self, adj_ens, feat_ens, sizes_subg_ens):\\n num_ensemble = len(feat_ens)\\n dims_ens = []\\n ops = 0\\n for i in range(num_ensemble):\\n if len(self.type_feature_augment) > 0:\\n for ia, _ in enumerate(self.type_feature_augment): # this does not change feat dim\\n ops += np.prod(list(self.aug_layers[i][ia].weight.shape)) * feat_ens[i].shape[0]\\n dims_respool = []\\n dims_conv = (layers.Dims_X(*(feat_ens[i].shape)), layers.Dims_adj(adj_ens[i].shape[0], adj_ens[i].size))\\n for md in self.conv_layers[i]:\\n dims_conv, _ops = md.complexity(*dims_conv)\\n dims_respool.append(dims_conv[0])\\n ops += _ops\\n dims_emb, _ops = self.res_pool_layers[i].complexity(dims_respool, sizes_subg_ens)\\n ops += _ops\\n dims_ens.append(dims_emb)\\n dims_cls, _ops = self.ensembler.complexity(dims_ens)\\n ops += _ops\\n _dims_final, _ops = self.classifier.complexity(dims_cls)\\n ops += _ops\\n return ops\",\n \"def rational_function_coefficient_descent(rational_function, sigma, poly_ring):\\n\\n if rational_function.parent().is_field():\\n S = rational_function.parent().ring()\\n else:\\n S = rational_function.parent()\\n\\n if rational_function == S(0):\\n return poly_ring(0)\\n\\n num = S(rational_function.numerator())\\n denom = S(rational_function.denominator())\\n f = num.coefficients()\\n fe = num.exponents()\\n g = denom.coefficients()\\n ge = denom.exponents()\\n #force the cancellation of common coefficient factors by scaling by f[-1]\\n ff = [ field_descent(sigma, x/f[-1]) for x in f]\\n gg = [ field_descent(sigma, x/f[-1]) for x in g]\\n if None in ff or None in gg:\\n return\\n\\n z = poly_ring.gen(0)\\n numer = sum( poly_ring(ff[i])*z**fe[i] for i in range(len(ff)) )\\n denom = sum( poly_ring(gg[i])*z**ge[i] for i in range(len(gg)) )\\n return numer / denom\",\n \"def complexity(s, **kwargs):\\n num, den = 1, 1\\n for k in range(1, len(s)):\\n k4 = 4**k # For DNA\\n num += min(len(set(s[i:i+k] for i in range(len(s) - k + 1))), k4)\\n den += min(len(s) - k + 1, k4)\\n return num / den\",\n \"def complexity(self) -> str:\\n return pulumi.get(self, \\\"complexity\\\")\",\n \"def parse_toplevel_subterms_and_connector(cls, compound_term_string):\\n compound_term_string = compound_term_string.replace(\\\" \\\",\\\"\\\")\\n subterms = []\\n intervals = []\\n internal_string = compound_term_string[1:-1] # string with no outer parentheses () or set brackets [], {}\\n\\n # check for intensional/extensional set [a,b], {a,b}\\n connector = NALSyntax.TermConnector.get_term_connector_from_string(compound_term_string[0])\\n if connector is None:\\n # otherwise check for regular Term/Statement connectors\\n if internal_string[1] == NALSyntax.StatementSyntax.TermDivider.value:\\n connector_string = internal_string[0] # Term connector\\n else:\\n connector_string = internal_string[0:2] # Statement connector\\n connector = NALSyntax.TermConnector.get_term_connector_from_string(connector_string)\\n\\n assert (internal_string[\\n len(\\n connector.value)] == NALSyntax.StatementSyntax.TermDivider.value), \\\"Connector not followed by comma in CompoundTerm string \\\" + compound_term_string\\n internal_string = internal_string[len(connector.value) + 1:]\\n\\n assert (connector is not None), \\\"Connector could not be parsed from CompoundTerm string.\\\"\\n\\n depth = 0\\n subterm_string = \\\"\\\"\\n for i, c in enumerate(internal_string):\\n if c == NALSyntax.StatementSyntax.Start.value or NALSyntax.TermConnector.is_set_bracket_start(c):\\n depth += 1\\n elif c == NALSyntax.StatementSyntax.End.value or NALSyntax.TermConnector.is_set_bracket_end(c):\\n depth -= 1\\n\\n if c == NALSyntax.StatementSyntax.TermDivider.value and depth == 0:\\n if subterm_string.isdigit():\\n intervals.append(int(subterm_string))\\n else:\\n subterm = Term.from_string(subterm_string)\\n subterms.append(subterm)\\n subterm_string = \\\"\\\"\\n else:\\n subterm_string += c\\n\\n subterm = Term.from_string(subterm_string)\\n subterms.append(subterm)\\n\\n return subterms, connector, intervals\",\n \"def count_consonants_recursive(input):\\n if len(input) == 0:\\n return 0\\n if input[0].lower() in consonants:\\n return 1 + count_consonants_recursive(input[1:])\\n else:\\n return count_consonants_recursive(input[1:])\",\n \"def complex_sum(c_1,c_2):\\n return c_1 + c_2\",\n \"def nth_order_const_coeff(*coeffs: List[Symbol], t: Symbol = t) -> Tuple[List[Symbol], Procedure]:\\n\\n # First, set up characteristic equation.\\n char_eq_r, r = sympy.S.Zero, Dummy('r')\\n\\n for order, coeff in enumerate(coeffs[::-1]):\\n char_eq_r += coeff * r ** order\\n\\n char_eq = Poly(char_eq_r, r)\\n\\n # Can't just call roots because it doesn't return rootof for unsolveable\\n # polynomials.\\n char_eq_roots = roots(char_eq, multiple=True)\\n\\n root_dict = defaultdict(int) # type: Dict[int, int]\\n\\n conjugate_roots = []\\n for root in char_eq_roots:\\n root_dict[root] += 1\\n\\n sols = []\\n for root, mult in root_dict.items():\\n for i in range(mult):\\n if isinstance(root, RootOf):\\n sols.append(t**i * exp(root*t))\\n elif root.is_real:\\n sols.append(t**i*exp(root*t))\\n else:\\n if root in conjugate_roots:\\n continue\\n reroot = re(root)\\n imroot = im(root)\\n conjugate_roots.append(conjugate(root))\\n sols.append(t**i*exp(reroot*t) * sin(abs(imroot) * t))\\n sols.append(t**i*exp(reroot*t) * cos(imroot * t))\\n\\n # collect roots for display\\n p_roots = []\\n count = 1\\n for root, mult in root_dict.items():\\n p_roots.append(Eq(Dummy('r_{}'.format(\\n \\\",\\\".join([str(i) for i in range(count, count + mult)]))), root, evaluate=False))\\n count += mult\\n\\n procedure = Procedure()\\n procedure\\\\\\n .text('Characteristic equation: ', nl=True)\\\\\\n .eq(Eq(char_eq_r, 0, evaluate=False))\\\\\\n .text('Roots: ')\\\\\\n .equarr(p_roots)\\\\\\n .text('General Solution: ', nl=True)\\\\\\n .eq(Eq(Dummy('y'), to_general(sols)[0], evaluate=False))\\n\\n return sols, procedure\",\n \"def _cmplx_add_ ( s , o ) :\\n return o + complex ( s )\",\n \"def __mul__(self, other, nested=False):\\n\\n other = formula(other, namespace=self.namespace)\\n\\n selftermnames = self.termnames()\\n othertermnames = other.termnames()\\n\\n I = len(selftermnames)\\n J = len(othertermnames)\\n\\n terms = []\\n termnames = []\\n\\n for i in range(I):\\n for j in range(J):\\n termname = '%s*%s' % (str(selftermnames[i]), str(othertermnames[j]))\\n pieces = termname.split('*')\\n pieces.sort()\\n termname = '*'.join(pieces)\\n termnames.append(termname)\\n\\n selfnames = self.terms[i].names()\\n othernames = other.terms[j].names()\\n\\n if self.terms[i].name is 'intercept':\\n _term = other.terms[j]\\n _term.namespace = other.namespace\\n\\n elif other.terms[j].name is 'intercept':\\n _term = self.terms[i]\\n _term.namespace = self.namespace\\n else:\\n names = []\\n\\n d1 = len(selfnames) \\n d2 = len(othernames)\\n\\n for r in range(d1):\\n for s in range(d2):\\n name = '%s*%s' % (str(selfnames[r]), str(othernames[s]))\\n pieces = name.split('*')\\n pieces.sort()\\n name = '*'.join(pieces)\\n names.append(name)\\n\\n def product_func(value, d1=d1, d2=d2):\\n\\n out = []\\n for r in range(d1):\\n for s in range(d2):\\n out.append(value[r] * value[d1+s])\\n return N.array(out)\\n\\n sumterms = self + other\\n sumterms.terms = [self, other] # enforce the order we want\\n sumterms.namespace = self.namespace\\n\\n _term = quantitative(names, func=sumterms, termname=termname,\\n transform=product_func)\\n _term.namespace = self.namespace\\n\\n\\n terms.append(_term)\\n\\n return formula(terms, namespace=self.namespace)\",\n \"def simplify(self): # TODO too complex, refactor\\n simplified = self.__simplifyRecurse()\\n # distributed out the polynomial. Now need to collect like terms\\n simplified.vars = self.vars.copy()\\n orderedVars = sorted(list(self.vars))\\n\\n powers = {} # will have keys of tuples. The tuples will represent the power of a variable. Values will be the\\n for monomial in simplified.poly[1:]:\\n power = [0] * len(orderedVars)\\n total = 0\\n\\n if monomial.isSimple():\\n monomial.poly = [\\\"*\\\", monomial.poly]\\n\\n for term in monomial.poly[1:]:\\n term = ensurePoly(term)\\n if isinstance(term.poly, (int, float)):\\n total += term.poly\\n elif isinstance(term.poly, (Variable.Variable)):\\n power[orderedVars.index(term.poly)] += 1\\n\\n power = tuple(power)\\n if power not in powers:\\n powers[power] = total\\n else:\\n powers[power] = min(total, powers[power])\\n\\n finalPoly = Polynomial()\\n finalPoly.poly = [\\\"+\\\"]\\n finalPoly.vars = self.vars.copy()\\n for power in sorted(list(powers.keys())):\\n monomial = Polynomial()\\n monomial.poly = [\\\"*\\\"]\\n if powers[power] != 0:\\n monomial.poly.append(powers[power])\\n\\n for pow, ind in zip(power, range(len(power))):\\n if pow == 0:\\n continue\\n elif pow == 1:\\n monomial.poly.append(orderedVars[ind])\\n else:\\n monomial.poly.append(orderedVars[ind]**pow)\\n finalPoly.poly.append(monomial)\\n return finalPoly\",\n \"def continued_fraction(a) -> list:\\n e = _sympify(a)\\n if all(i.is_Rational for i in e.atoms()):\\n if e.is_Integer:\\n return continued_fraction_periodic(e, 1, 0)\\n elif e.is_Rational:\\n return continued_fraction_periodic(e.p, e.q, 0)\\n elif e.is_Pow and e.exp is S.Half and e.base.is_Integer:\\n return continued_fraction_periodic(0, 1, e.base)\\n elif e.is_Mul and len(e.args) == 2 and (\\n e.args[0].is_Rational and\\n e.args[1].is_Pow and\\n e.args[1].base.is_Integer and\\n e.args[1].exp is S.Half):\\n a, b = e.args\\n return continued_fraction_periodic(0, a.q, b.base, a.p)\\n else:\\n # this should not have to work very hard- no\\n # simplification, cancel, etc... which should be\\n # done by the user. e.g. This is a fancy 1 but\\n # the user should simplify it first:\\n # sqrt(2)*(1 + sqrt(2))/(sqrt(2) + 2)\\n p, d = e.expand().as_numer_denom()\\n if d.is_Integer:\\n if p.is_Rational:\\n return continued_fraction_periodic(p, d)\\n # look for a + b*c\\n # with c = sqrt(s)\\n if p.is_Add and len(p.args) == 2:\\n a, bc = p.args\\n else:\\n a = S.Zero\\n bc = p\\n if a.is_Integer:\\n b = S.NaN\\n if bc.is_Mul and len(bc.args) == 2:\\n b, c = bc.args\\n elif bc.is_Pow:\\n b = Integer(1)\\n c = bc\\n if b.is_Integer and (\\n c.is_Pow and c.exp is S.Half and\\n c.base.is_Integer):\\n # (a + b*sqrt(c))/d\\n c = c.base\\n return continued_fraction_periodic(a, d, c, b)\\n raise ValueError(\\n 'expecting a rational or quadratic irrational, not %s' % e)\",\n \"def time_complexities():\\n return \\\"Best Case: O(n), Average Case: O(n), Worst Case: O(n)\\\"\",\n \"def __mul__(self, other, nested=False):\\n\\n other = Formula(other)\\n\\n selftermnames = self.termnames()\\n othertermnames = other.termnames()\\n\\n I = len(selftermnames)\\n J = len(othertermnames)\\n\\n terms = []\\n termnames = []\\n\\n for i in range(I):\\n for j in range(J):\\n termname = '%s*%s' % (str(selftermnames[i]), str(othertermnames[j]))\\n pieces = sorted(termname.split('*'))\\n termname = '*'.join(pieces)\\n termnames.append(termname)\\n\\n selfnames = self.terms[i].names()\\n othernames = other.terms[j].names()\\n\\n if self.terms[i].name is 'intercept':\\n _term = other.terms[j]\\n _term.namespace = other.namespace\\n elif other.terms[j].name is 'intercept':\\n _term = self.terms[i]\\n _term.namespace = self.namespace\\n else:\\n names = []\\n\\n d1 = len(selfnames)\\n d2 = len(othernames)\\n\\n for r in range(d1):\\n for s in range(d2):\\n name = '%s*%s' % (str(selfnames[r]), str(othernames[s]))\\n pieces = sorted(name.split('*'))\\n name = '*'.join(pieces)\\n names.append(name)\\n\\n def product_func(value, d1=d1, d2=d2):\\n\\n out = []\\n for r in range(d1):\\n for s in range(d2):\\n out.append(value[r] * value[d1+s])\\n return np.array(out)\\n\\n cself = copy.copy(self.terms[i])\\n cother = copy.copy(other.terms[j])\\n sumterms = cself + cother\\n sumterms.terms = [cself, cother] # enforce the order we want\\n\\n _term = Quantitative(names, func=sumterms,\\n termname=termname,\\n transform=product_func)\\n\\n if _namespace_equal(self.namespace, other.namespace):\\n _term.namespace = self.namespace\\n\\n terms.append(_term)\\n\\n return Formula(terms)\",\n \"def countRecursiveReferences(self) -> Tuple[Dict[str, List[str]], Dict[str, Dict[str, int]]]:\\n countReferences = {}\\n isReferencedBy = {}\\n for nt in self.non_terminals: # for each non-terminal in the grammar\\n for production in self.grammar[nt]: # for each possible production on that non terminal\\n count = {}\\n for option in production.split(): # iterate over the production's terms\\n count.setdefault(option, 0)\\n if option in self.non_terminals: # if the term is a non terminal\\n count[option] += 1 # the number of times that option has been referenced increases\\n isReferencedBy.setdefault(option, set())\\n isReferencedBy[option].add(nt)\\n \\n for key in count:\\n count.setdefault(key, 0)\\n countReferences.setdefault(key, {})\\n countReferences[key].setdefault(nt, 0)\\n\\n countReferences[key][nt] = max(\\n countReferences[key][nt], count[key]) # the number of references of the non terminal is for this\\n # term is the maximum between all productions in this non terminal\\n\\n return isReferencedBy, countReferences\",\n \"def test_complexity(tmp_path: Path, capsys) -> None:\\n file_content = '\\\"\\\"\\\"Docstring.\\\"\\\"\\\"\\\\n\\\\n'\\n program = \\\"\\\"\\\"\\n elements = [open(str(i)) for i in range(10)]\\n\\n\\n def foo():\\n \\\\\\\"\\\\\\\"\\\\\\\"Docstring.\\\\\\\"\\\\\\\"\\\\\\\"\\n if elements[0]:\\n aaa = 1\\n elif elements[1]:\\n aaa = 1\\n elif elements[2]:\\n aaa = 1\\n elif elements[3]:\\n aaa = 1\\n elif elements[4]:\\n aaa = 1\\n elif elements[5]:\\n aaa = 1\\n elif elements[6]:\\n aaa = 1\\n elif elements[7]:\\n aaa = 1\\n elif elements[8]:\\n aaa = 1\\n elif elements[9]:\\n aaa = 1\\n print(aaa)\\n \\\"\\\"\\\"\\n file_content += dedent(program)\\n run_linter(tmp_path, capsys, file_content, \\\"'foo' is too complex (11)\\\")\",\n \"def calc_process_cohesion(partitions, graph):\\n ch = 0\\n for part in partitions:\\n crc = calc_community_relation_cohesion(part, graph)\\n cic = calc_community_information_cohesion(part, graph)\\n ch = ch + (crc * cic)\\n ch = ch / len(partitions)\\n return ch\",\n \"def continued_fraction_reduce(cf):\\n from sympy.solvers import solve\\n\\n period = []\\n x = Dummy('x')\\n\\n def untillist(cf):\\n for nxt in cf:\\n if isinstance(nxt, list):\\n period.extend(nxt)\\n yield x\\n break\\n yield nxt\\n\\n a = S.Zero\\n for a in continued_fraction_convergents(untillist(cf)):\\n pass\\n\\n if period:\\n y = Dummy('y')\\n solns = solve(continued_fraction_reduce(period + [y]) - y, y)\\n solns.sort()\\n pure = solns[-1]\\n rv = a.subs(x, pure).radsimp()\\n else:\\n rv = a\\n if rv.is_Add:\\n rv = factor_terms(rv)\\n if rv.is_Mul and rv.args[0] == -1:\\n rv = rv.func(*rv.args)\\n return rv\",\n \"def innerProd(linearCombo1, linearCombo2):\\n innerProd = 0\\n # TODO: I'm starting with simple sets on both sides, not sum of sets, \\n # with coefficient 1. We need to fix this later\\n # TODO: find way to represent dashed vs undashed arrows\\n # For now, assume both are already sums (sets) of dashed subdiagrams\\n\\n # copy linear combinations to make it easier to alter them as needed\\n linearComboCopy1 = deepcopy(linearCombo1)\\n linearComboCopy2 = deepcopy(linearCombo2)\\n print len(linearComboCopy2[0][1])\\n\\n # get list of subdiagrams, get coefficients\\n for coeffAndSubdiagrams1 in linearComboCopy1:\\n subdiagramSet1 = coeffAndSubdiagrams1[1]\\n coeff1 = coeffAndSubdiagrams1[0]\\n subdiagramsToRemove1 = []\\n\\n for coeffAndSubdiagrams2 in linearComboCopy2:\\n subdiagramSet2 = coeffAndSubdiagrams2[1]\\n coeff2 = coeffAndSubdiagrams2[0]\\n subdiagramsToRemove2 = []\\n\\n # look for equivalent pairs of dashed subdiagrams in both lists\\n for subdiagram1 in subdiagramSet1:\\n for subdiagram2 in subdiagramSet2: \\n # for equivalent pairs of dashed subdiagrams, increment innerProd by \\n # product of coefficients and remove the subdiagrams to avoid \\n # over-counting diagrams\\n if equiv(subdiagram1, subdiagram2):\\n innerProd += coeff1 * coeff2\\n subdiagramsToRemove1.append(subdiagram1)\\n subdiagramsToRemove2.append(subdiagram2)\\n print \\\" \\\", innerProd\\n # remove the used subdiagrams\\n # print \\\"sub 2\\\\t\\\" + str(subdiagramSet2)\\n # print \\\" 2 \\\" + str(subdiagramsToRemove2)\\n # print \\\" 1 \\\" + str(subdiagramsToRemove1)\\n for removal2 in subdiagramsToRemove2:\\n # print \\\" remove \\\" + str(removal2)\\n subdiagramSet2.remove(removal2)\\n subdiagramsToRemove2 = []\\n # for removal1 in subdiagramsToRemove1:\\n # subdiagramSet1.remove(removal1) \\n return innerProd\",\n \"def number_of_connectives(formula):\\n pass\\n # ======== YOUR CODE HERE ========\",\n \"def compute(n):\\n if n == 1:\\n return 1\\n else:\\n i = find_i(n)\\n return 2 * compute(n - i) + 2 ** i - 1\",\n \"def parse_algebra(self):\\r\\n # 0.33 or 7 or .34 or 16.\\r\\n number_part = Word(nums)\\r\\n inner_number = (number_part + Optional(\\\".\\\" + Optional(number_part))) | (\\\".\\\" + number_part)\\r\\n # pyparsing allows spaces between tokens--`Combine` prevents that.\\r\\n inner_number = Combine(inner_number)\\r\\n\\r\\n # SI suffixes and percent.\\r\\n number_suffix = MatchFirst(Literal(k) for k in SUFFIXES.keys())\\r\\n\\r\\n # 0.33k or 17\\r\\n plus_minus = Literal('+') | Literal('-')\\r\\n number = Group(\\r\\n Optional(plus_minus) +\\r\\n inner_number +\\r\\n Optional(CaselessLiteral(\\\"E\\\") + Optional(plus_minus) + number_part) +\\r\\n Optional(number_suffix)\\r\\n )\\r\\n number = number(\\\"number\\\")\\r\\n\\r\\n # Predefine recursive variables.\\r\\n expr = Forward()\\r\\n\\r\\n # Handle variables passed in. They must start with letters/underscores\\r\\n # and may contain numbers afterward.\\r\\n inner_varname = Word(alphas + \\\"_\\\", alphanums + \\\"_\\\")\\r\\n varname = Group(inner_varname)(\\\"variable\\\")\\r\\n varname.setParseAction(self.variable_parse_action)\\r\\n\\r\\n # Same thing for functions.\\r\\n function = Group(inner_varname + Suppress(\\\"(\\\") + expr + Suppress(\\\")\\\"))(\\\"function\\\")\\r\\n function.setParseAction(self.function_parse_action)\\r\\n\\r\\n atom = number | function | varname | \\\"(\\\" + expr + \\\")\\\"\\r\\n atom = Group(atom)(\\\"atom\\\")\\r\\n\\r\\n # Do the following in the correct order to preserve order of operation.\\r\\n pow_term = atom + ZeroOrMore(\\\"^\\\" + atom)\\r\\n pow_term = Group(pow_term)(\\\"power\\\")\\r\\n\\r\\n par_term = pow_term + ZeroOrMore('||' + pow_term) # 5k || 4k\\r\\n par_term = Group(par_term)(\\\"parallel\\\")\\r\\n\\r\\n prod_term = par_term + ZeroOrMore((Literal('*') | Literal('/')) + par_term) # 7 * 5 / 4\\r\\n prod_term = Group(prod_term)(\\\"product\\\")\\r\\n\\r\\n sum_term = Optional(plus_minus) + prod_term + ZeroOrMore(plus_minus + prod_term) # -5 + 4 - 3\\r\\n sum_term = Group(sum_term)(\\\"sum\\\")\\r\\n\\r\\n # Finish the recursion.\\r\\n expr << sum_term # pylint: disable=W0104\\r\\n self.tree = (expr + stringEnd).parseString(self.math_expr)[0]\",\n \"def complexity(self, mode='#nodes'):\\n if mode == '#nodes':\\n return len(self.nodes)\",\n \"def get_complexity(n):\\n try:\\n return complexity_map[n]\\n except KeyError:\\n if n - 1 in complexity_map:\\n complexity_map[n] = complexity_map[n - 1] + 1\\n for i in range(2, int(floor(n / 2) + 1)):\\n if n % i == 0:\\n complexity = get_complexity(i) + get_complexity(n / i)\\n if n not in complexity_map or complexity < complexity_map[n]:\\n complexity_map[n] = complexity\\n return complexity_map[n]\",\n \"def _AddCompound(self, kegg_id, how_many):\\n i = self._FindCompoundIndex(kegg_id)\\n if i is not None:\\n self.reactants[i].coeff += how_many\\n else:\\n self.reactants += [CompoundWithCoeff.FromId(how_many, kegg_id)]\\n \\n # clear the cache since the reaction has changed\\n self._catalyzing_enzymes = None\",\n \"def test_linear_comb() -> None:\\n SumStr = FormalLinearCombination(\\n str, complex, complex(0, 0), lambda z1, z2: z1+z2)\\n flc_1a2b3c = SumStr(\\n [(complex(1, 0), \\\"a\\\"), (complex(2, 0), \\\"b\\\"), (complex(3, 0), \\\"c\\\")])\\n assert str(flc_1a2b3c) == \\\"(1+0j)*a+(2+0j)*b+(3+0j)*c\\\"\\n two_flc_1a2b3c = flc_1a2b3c+flc_1a2b3c\\n exp_two_flc_1a2b3c = SumStr(\\n [(complex(2, 0), \\\"a\\\"), (complex(4, 0), \\\"b\\\"), (complex(6, 0), \\\"c\\\")])\\n assert str(two_flc_1a2b3c) == \\\"(2+0j)*a+(4+0j)*b+(6+0j)*c\\\"\\n assert exp_two_flc_1a2b3c == two_flc_1a2b3c\\n assert str(flc_1a2b3c*flc_1a2b3c) == \\\"(1+0j)*aa+(2+0j)*ab+(3+0j)*ac\\\"+\\\\\\n \\\"+(2+0j)*ba+(4+0j)*bb+(6+0j)*bc\\\"+\\\\\\n \\\"+(3+0j)*ca+(6+0j)*cb+(9+0j)*cc\\\"\",\n \"def solve_part2(input, verbose=False):\\n equations = parse(input)\\n\\n result = []\\n for eq in equations:\\n result.append(solve_equation_addition_precendence(eq, verbose))\\n\\n if verbose:\\n print(f\\\"results: {result}\\\")\\n\\n return sum(result)\",\n \"def concretise_ast(node):\\n node.children = list(node.get_children())\\n\\n for child in node.children:\\n counter = concretise_ast(child)\",\n \"def calculate (self,phrase):\\r\\n\\r\\n\\r\\n def bracketed (phrase,bracketing='()'):\\r\\n\\r\\n \\\"\\\"\\\"Returns TRUE if <phrase> is encompassed by a left bracket and a right bracket\\r\\n at the same hierarchical level\\\"\\\"\\\"\\r\\n\\r\\n level = 0\\r\\n left_point = None\\r\\n right_point = None\\r\\n \\r\\n\\r\\n for count,char in enumerate(phrase):\\r\\n\\r\\n if char == bracketing[0]:\\r\\n if level == 0:\\r\\n left_point = count\\r\\n level+=1\\r\\n if char == bracketing[1]:\\r\\n level-=1\\r\\n if level == 0:\\r\\n right_point = count\\r\\n if not (left_point is None) and (not right_point is None) and left_point == 0 and right_point == len(phrase)-1:\\r\\n return True\\r\\n return False\\r\\n\\r\\n def quoted (phrase):\\r\\n\\r\\n level = 0\\r\\n foundchar = ''\\r\\n left_point = None\\r\\n right_point = None \\r\\n for count,char in enumerate(phrase):\\r\\n\\r\\n if char in ['\\\"',\\\"'\\\"] and level == 0:\\r\\n foundchar = char\\r\\n left_point = count\\r\\n level += 1\\r\\n elif level == 1 and char == foundchar:\\r\\n right_point = count\\r\\n level += 1\\r\\n if not (left_point is None) and (not right_point is None) and left_point == 0 and right_point == len(phrase)-1:\\r\\n return True\\r\\n return False \\r\\n \\r\\n \\r\\n\\r\\n def is_function(phrase):\\r\\n\\r\\n \\\"\\\"\\\"Tests to see if a phrase begins with a predefined function,\\r\\n in which case it returns information about the iarity of function\\\"\\\"\\\"\\r\\n \\r\\n \\r\\n for x in self.functions.keys():\\r\\n\\r\\n if len(x) < len(phrase) and phrase[0:len(x)] == x:\\r\\n if bracketed(phrase[len(x):]):\\r\\n if self.functions[x][1]-1 <= phrase.count(',') <= self.functions[x][2]-1:\\r\\n return x, self.functions[x][0], self.functions[x][2], phrase[len(x):]\\r\\n else:\\r\\n return False,False,False,False \\r\\n \\r\\n\\r\\n def all_simple (phrase):\\r\\n\\r\\n \\\"\\\"\\\"Tests if a phrase is a simple string representing an expression, rather than an operation\\\"\\\"\\\"\\r\\n\\r\\n\\r\\n for x in phrase:\\r\\n if (x not in self.operations and not (isinstance(x,(int,type(ListType()),float,bool) or (isinstance(x,str) and quoted(x)))) or self.current_register.contains(x)):\\r\\n return False\\r\\n return True\\r\\n \\r\\n def parse (phrase):\\r\\n\\r\\n \\r\\n COMPTERMS = ['==','>=','<=','!=','>','<',]\\r\\n\\r\\n\\r\\n def contains_comp (x):\\r\\n \\\"\\\"\\\"True is x contains any of the COMP Terms\\\"\\\"\\\"\\r\\n\\r\\n for comp in COMPTERMS:\\r\\n if comp in x:\\r\\n return True\\r\\n return False\\r\\n\\r\\n\\r\\n \\r\\n \\\"\\\"\\\"Parses and analzes the phrase\\\"\\\"\\\"\\r\\n\\r\\n \\r\\n if phrase in ['bTrue','bFalse','EmptyList']:\\r\\n return {'bTrue':True,\\r\\n 'bFalse':False,\\r\\n 'EmptyList':ListType()}[phrase]\\r\\n\\r\\n if isinstance(phrase,str):\\r\\n \\r\\n if quoted(phrase):\\r\\n return phrase\\r\\n else:\\r\\n try:\\r\\n return float(phrase)\\r\\n except:\\r\\n pass\\r\\n \\r\\n\\r\\n # If the phrase is a string\\r\\n phrase = phrase.strip()\\r\\n\\r\\n func_name, func, iarity, func_phrase = is_function(phrase)\\r\\n # tests is it is function; otherwise the values are false.\\r\\n \\r\\n \\r\\n\\r\\n if func_name:\\r\\n if iarity == 1:\\r\\n # If the function accepts one value\\r\\n return func(parse(func_phrase))\\r\\n if iarity == 2:\\r\\n # Two values \\r\\n func_phrase = func_phrase[1:-1]\\r\\n term1,term2 = func_phrase.split(',')[0],func_phrase.split(',')[1]\\r\\n return func(parse(term1),parse(term2))\\r\\n if iarity == 3:\\r\\n func_phrase = func_phrase[1:-1]\\r\\n term1,term2, term3 = func_phrase.split(',')[0],func_phrase.split(',')[1],func_phrase.split(',')[2]\\r\\n return func(parse(term1),parse(term2),parse(term3))\\r\\n \\r\\n if iarity >3:\\r\\n # A list of values \\r\\n func_phrase = func_phrase[1:-1]\\r\\n return func([parse(x) for x in func_phrase.split(',')])\\r\\n elif phrase and phrase[0] == '-' and bracketed(phrase[1:]):\\r\\n # Translates negative sign (as opposed to operators) into corresponding function \\r\\n return -parse(phrase[2:-1])\\r\\n\\r\\n\\r\\n elif bracketed(phrase):\\r\\n # removes top-level bracket\\r\\n phrase = phrase[1:-1]\\r\\n return parse(phrase)\\r\\n elif phrase in self.operations:\\r\\n return phrase\\r\\n elif self.current_register.contains(phrase):\\r\\n # for variables and constants\\r\\n return self.current_register.get(phrase)\\r\\n elif contains_comp(phrase) and '(' not in phrase and ')' not in phrase:\\r\\n return calc.computer.get(phrase)\\r\\n elif phrase and phrase[0]=='@' and phrase[-1]=='@':\\r\\n # to retrieve values from the log \\r\\n index = int(parse(phrase[1:-1]))\\r\\n if 0<= index <= len(self.lines):\\r\\n return self.lines[index][0]\\r\\n else:\\r\\n \\r\\n phrase = list(phrase)\\r\\n #phrase is converted to a list to allowing indexical assignments\\r\\n operation_sequence = []\\r\\n level = 0\\r\\n inquotes = False\\r\\n quote_form = ''\\r\\n for counter, x in enumerate(phrase):\\r\\n\\r\\n # Search for operators that are not enclosed in parantheses\\r\\n\\r\\n if not inquotes and x in ['\\\"',\\\"'\\\"]:\\r\\n inquotes = True\\r\\n quote_form = x\\r\\n elif inquotes and x == quote_form:\\r\\n if counter < len(phrase)-1:\\r\\n if phrase[counter+1] in ['+']:\\r\\n phrase[counter+1] = '#+#'\\r\\n\\r\\n if x == '(':\\r\\n level +=1\\r\\n\\r\\n if x == ')':\\r\\n level -=1\\r\\n if level == 0:\\r\\n if counter<len(phrase)-1:\\r\\n if phrase[counter+1] in self.operations:\\r\\n # If an operator is found, surround it with pound signs\\r\\n phrase[counter+1] = '#'+phrase[counter+1]+'#'\\r\\n if phrase[counter+2] in self.operations:\\r\\n phrase[counter+2] = '~'\\r\\n # For a minus sign that is not an operator\\r\\n\\r\\n \\r\\n phrase = ''.join(phrase).replace('~','-').split('#')\\r\\n # Split the phrase into expressions linked by operators \\r\\n newphrase = []\\r\\n for x in phrase:\\r\\n # a clumsy way to distinction between numerical values, and string operators\\r\\n try:\\r\\n newphrase.append(float(x))\\r\\n except:\\r\\n newphrase.append(x)\\r\\n phrase = newphrase\\r\\n\\r\\n return parse(phrase)\\r\\n \\r\\n \\r\\n\\r\\n if isinstance(phrase,list):\\r\\n # If the phrase has already been parsed into a list \\r\\n if len(phrase) == 1:\\r\\n return (parse(phrase[0]))\\r\\n if all_simple(phrase):\\r\\n # If every value in the phrase list has been reduced to\\r\\n # a numerical value or an operator\\r\\n \\r\\n\\r\\n for operation in self.operations:\\r\\n\\r\\n #In order to preserve the correct order of operations,\\r\\n #the operations are analyzed in succession\\r\\n\\r\\n while operation in phrase:\\r\\n\\r\\n #This repeat as long as the operation is in the phrase,\\r\\n #since with each pass it only \\\"reduced\\\"\\r\\n #expression/operator/expression triplet\\r\\n \\r\\n\\r\\n newlist = [] # For the result of each pass through the list.\\r\\n lastvalue = None\\r\\n counter = 0\\r\\n stop = False\\r\\n while counter < len(phrase) and not stop:\\r\\n \\r\\n \\r\\n if counter < len(phrase)-2:\\r\\n a = phrase[counter]\\r\\n op = phrase[counter+1]\\r\\n b = phrase[counter+2]\\r\\n #take a triplet of values from the list\\r\\n\\r\\n if op == operation:\\r\\n # if an operator is found, reduced the triplet, and\\r\\n # then add the reduced value, together with the rest\\r\\n # of the list to the \\r\\n if operation == '*':\\r\\n c = a*b\\r\\n elif operation == '+':\\r\\n if isinstance(a,str) and isinstance(b,str):\\r\\n c = a[0:-1]+b[1:]\\r\\n else:\\r\\n c = a+b\\r\\n elif operation == '/':\\r\\n c = a/b\\r\\n elif operation == '^':\\r\\n c = a**b\\r\\n elif operation == '%':\\r\\n c = a % b\\r\\n elif operation == '-':\\r\\n c = a - b\\r\\n newlist.append(c)\\r\\n newlist += phrase[counter+3:] \\r\\n stop = True\\r\\n else:\\r\\n newlist.append(a)\\r\\n else:\\r\\n # otherwise, just add the text value to the new list\\r\\n newlist.append(phrase[counter])\\r\\n counter +=1 \\r\\n \\r\\n \\r\\n phrase = newlist\\r\\n\\r\\n \\r\\n else:\\r\\n # if the list is not yet simple, return a new list after parsing each element.\\r\\n phrase = [parse(x) for x in phrase]\\r\\n return parse(phrase)\\r\\n\\r\\n if isinstance(phrase,(int,float,type(ListType()),bool)):\\r\\n # if a numerical value, stop the recursion\\r\\n \\r\\n return phrase \\r\\n\\r\\n return parse(phrase)\",\n \"def cosh(self):\\n return type(self)(self.parent(),\\n self._simplify(self._express.cosh()))\",\n \"def visit_Compound(self, node):\\n for child in node.children:\\n self.visit(child)\",\n \"def get_nested_sum():\\n l_int = [1,2,[], 3,[4,[], 5,[6]],[7],[8,9], 10,[[],11]]\\n print 'Sum:', nested_sum(l_int) \\n return\",\n \"def _calc_C(self, lambdify=True):\\n\\n C = None\\n C_func = None\\n # check to see if we have our term saved in file\\n C, C_func = self._load_from_file('C', lambdify)\\n\\n if C is None and C_func is None:\\n # if no saved file was loaded, generate function\\n print('Generating centrifugal and Coriolis compensation function')\\n\\n # first get the inertia matrix\\n M = self._calc_M(lambdify=False)\\n\\n # C_{kj} = sum_i c_{ijk}(q) \\\\dot{q}_i\\n # c_{ijk} = 1/2 * sum_i (\\\\frac{\\\\partial M_{kj}}{\\\\partial q_j} +\\n # \\\\frac{\\\\partial M_{ki}}{\\\\partial q_j} - \\\\frac{\\\\partial M_{ij}}\\n # {\\\\partial q_k})\\n C = sp.zeros(self.N_JOINTS, self.N_JOINTS)\\n for kk in range(self.N_JOINTS):\\n for jj in range(self.N_JOINTS):\\n for ii in range(self.N_JOINTS):\\n dMkjdqi = M[kk, jj].diff(self.q[ii])\\n dMkidqj = M[kk, ii].diff(self.q[jj])\\n dMijdqk = M[ii, jj].diff(self.q[kk])\\n C[kk, jj] += .5 * (dMkjdqi + dMkidqj - dMijdqk) * self.dq[ii]\\n C[kk, jj] = C[kk, jj]\\n C = sp.Matrix(C)\\n\\n # save to file\\n abr_control.utils.os_utils.makedirs(\\n '%s/C' % self.config_folder)\\n cloudpickle.dump(C, open(\\n '%s/C/C' % self.config_folder, 'wb'))\\n\\n if lambdify is False:\\n # if should return expression not function\\n return C\\n\\n if C_func is None:\\n C_func = self._generate_and_save_function(\\n filename='C', expression=C,\\n parameters=self.q+self.dq)\\n return C_func\",\n \"def complexity(text:str) -> float:\\n words = text.split(' ')\\n freqs = [frequency(w) for w in words]\\n return sum(freqs) / (len(frequency_list) - freqs.count(0)) #sum of the frequencies / all the words that were in the list\",\n \"def get_circuit_size(self, circuit: ACircuit, recursive: bool = False) -> Tuple[int, int]:\",\n \"def combine_expression(self, connector, sub_expressions):\\n lhs, rhs = sub_expressions\\n if connector == '%%':\\n return 'MOD(%s)' % ','.join(sub_expressions)\\n elif connector == '&':\\n return 'BAND(%s)' % ','.join(sub_expressions)\\n elif connector == '|':\\n return 'BOR(%s)' % ','.join(sub_expressions)\\n elif connector == '^':\\n return 'POWER(%s)' % ','.join(sub_expressions)\\n elif connector == '<<':\\n return '(%(lhs)s * POWER(2, %(rhs)s))' % {'lhs': lhs, 'rhs': rhs}\\n elif connector == '>>':\\n return 'FLOOR(%(lhs)s / POWER(2, %(rhs)s))' % {'lhs': lhs, 'rhs': rhs}\\n return super().combine_expression(connector, sub_expressions)\",\n \"def custom_quadratic(n_particles, coefficients, is_bosonic):\\n if is_bosonic:\\n op = bosonic_op if n_particles == 2 else bosonic_op_3\\n else:\\n op = fermionic_op if n_particles == 2 else fermionic_op_3\\n\\n if n_particles == 2:\\n (J_11, J_22), (J_12,) = coefficients\\n return J_11 * op[\\\"a1^dag a1\\\"] + J_12 * (op[\\\"a1^dag a2\\\"] + op[\\\"a2^dag a1\\\"]) + J_22 * op[\\\"a2^dag a2\\\"]\\n\\n elif n_particles == 3:\\n (J_11, J_22, J_33), (J_12, J_13, J_23) = coefficients\\n return (\\n J_11 * op[\\\"a1^dag a1\\\"]\\n + J_12 * (op[\\\"a1^dag a2\\\"] + op[\\\"a2^dag a1\\\"])\\n + J_13 * (op[\\\"a1^dag a3\\\"] + op[\\\"a3^dag a1\\\"])\\n + J_22 * op[\\\"a2^dag a2\\\"]\\n + J_23 * (op[\\\"a2^dag a3\\\"] + op[\\\"a3^dag a2\\\"])\\n + J_33 * op[\\\"a3^dag a3\\\"]\\n )\",\n \"def _nt_sum(cobj, prop, theta):\\n # Build sum term\\n i = 1\\n s = 0\\n while True:\\n try:\\n ni = getattr(cobj, f\\\"{prop}_coeff_n{i}\\\")\\n ti = getattr(cobj, f\\\"{prop}_coeff_t{i}\\\")\\n s += ni * theta**ti\\n i += 1\\n except AttributeError:\\n break\\n return s\",\n \"def dfs(self, nums, cur_sum, S):\\n ways = 0\\n nums_length = len(nums)\\n if nums_length == 0:\\n if cur_sum == S:\\n return 1\\n return 0\\n\\n multiple = [1, -1]\\n for value in multiple:\\n new_num = nums[nums_length - 1]\\n new_nums = nums[0:nums_length - 1]\\n new_sum = cur_sum + new_num * value\\n ways = ways + self.dfs(new_nums, new_sum, S)\\n\\n return ways\",\n \"def associativity(ob):\\n return 0\",\n \"def conjugation(conj_id, present_base, perfect_base, present_ending, participle_base, infinitive):\\n\\t\\n\\t#TODO: Rewrite the following with attribute calls:\\n \\n tense = {}\\n #Tenses, aspects and moods in Latin:\\n tense[\\\"ind_a_pr\\\"] = conj_ind_a_pr(conj_id, present_base)\\n tense[\\\"ind_a_im\\\"] = conj_ind_a_im(conj_id, present_base)\\n tense[\\\"ind_a_fu\\\"] = conj_ind_a_fu(conj_id, present_base)\\n tense[\\\"ind_a_pe\\\"] = conj_ind_a_pe(conj_id, perfect_base)\\n tense[\\\"ind_a_pl\\\"] = conj_ind_a_pl(conj_id, perfect_base)\\n tense[\\\"ind_a_fp\\\"] = conj_ind_a_fp(conj_id, perfect_base)\\n tense[\\\"imp_a_pr\\\"] = conj_imp_a_pr(conj_id, present_base)\\n tense[\\\"imp_p_pr\\\"] = conj_imp_p_pr(conj_id, infinitive, present_base) # c\\n tense[\\\"imp_p_fu\\\"] = conj_imp_p_fu(conj_id, present_base)\\n tense[\\\"imp_a_fu\\\"] = conj_imp_a_fu(conj_id, present_base)\\n tense[\\\"ind_p_pr\\\"] = conj_ind_p_pr(conj_id, present_base, present_ending)\\n tense[\\\"ind_p_im\\\"] = conj_ind_p_im(conj_id, present_base)\\n tense[\\\"ind_p_fu\\\"] = conj_ind_p_fu(conj_id, present_base, present_ending)\\n tense[\\\"sub_a_pr\\\"] = conj_sub_a_pr(conj_id, present_base)\\n tense[\\\"sub_p_pr\\\"] = conj_sub_p_pr(conj_id, present_base)\\n tense[\\\"sub_a_im\\\"] = conj_sub_a_im(infinitive)\\n tense[\\\"sub_p_im\\\"] = conj_sub_p_im(infinitive)\\n tense[\\\"sub_a_pe\\\"] = conj_sub_a_pe(perfect_base)\\n tense[\\\"sub_a_pl\\\"] = conj_sub_a_pl(perfect_base)\\n \\n #TODO: Put the above in dictionary as objects?\\n #\\n tense[\\\"ind_p_pe\\\"] = (Esse.ipra, participle_parpp(participle_base))\\n tense[\\\"ind_p_pl\\\"] = (Esse.iima, participle_parpp(participle_base))\\n tense[\\\"sub_p_pe\\\"] = (Esse.sub_pr, participle_parpp(participle_base))\\n tense[\\\"sub_p_pl\\\"] = (Esse.sub_im, participle_parpp(participle_base))\\n tense[\\\"ind_p_fp\\\"] = (Esse.ind_fu, participle_parpp(participle_base))\\n \\n return tense\",\n \"def __init__(self, children):\\n super().__init__('complex', children, None)\\n self.real = children[0].real\\n self.imag = children[1].imag\\n self.complex = self.real + self.imag*1j\",\n \"def encode_compound(db, tree):\\n length = 0\\n data = 0\\n sf = 0\\n subfields = []\\n for cn in tree.childNodes:\\n l = 0\\n if cn.nodeName == 'Variable':\\n l, v = encode_variable(db, cn)\\n else:\\n if cn.nodeName == 'Fixed':\\n l, v = encode_fixed(db, cn)\\n else:\\n if cn.nodeName == 'Repetitive':\\n l, v = encode_repetitive(db, cn)\\n else:\\n if cn.nodeName == 'Variable':\\n l, v = encode_variable(db, cn)\\n else:\\n if cn.nodeName == 'Compound':\\n l, v = encode_compound(db, cn)\\n\\n if l > 0:\\n subfields.append(sf)\\n length += l\\n data <<= (8 * l)\\n data += v\\n\\n sf += 1\\n\\n n_octets = max(subfields) / 7 + 1\\n primary_subfield = 0\\n for i in sorted(subfields): # subfields\\n primary_subfield += (1 << (8 * (i / 7) + (8 - (i % 7))))\\n for i in range(n_octets - 1): # FX\\n primary_subfield += (1 << 8 * (i + 1))\\n\\n data += (primary_subfield << (8 * length))\\n\\n return length + n_octets, data\",\n \"def _cmplx_div_ ( s , o ) :\\n return ( 1.0 / o ) * complex ( s )\",\n \"def get_covered_terms(self):\\n base = 0\\n x_index = [index for index, item in enumerate(self.bin_str[::-1]) if item == '-']\\n\\n for index, item in enumerate(self.bin_str[::-1]):\\n if item == '1':\\n base += 2 ** index\\n\\n yield base\\n\\n for i in range(len(x_index)):\\n for items in itertools.combinations(x_index, i + 1):\\n accumulator = 0\\n for index in items:\\n accumulator += 2 ** index\\n yield base + accumulator\",\n \"def Cprimebound(relatorlist,Lambda=1):\\n F,rels=fg.parseinputwords(relatorlist)\\n if not all(r==F.cyclic_reduce(r) for r in rels):\\n raise ValueError(\\\"Relators are not cyclically reduced.\\\")\\n biggestratio=Fraction(1,min(len(r) for r in rels))\\n if biggestratio>=Fraction(1,Lambda):\\n return 1\\n rels.sort(key=len) # sort list of relators with shortest first\\n irels=[rel for rel in itertools.chain.from_iterable(zip([w() for w in rels],[(w**(-1))() for w in rels]))] # arrange relators and inverses in a list of the form relator1, inverse of relator1, relator2, inverse of relator2,...\\n drels=[x+x for x in irels] # double the relators to look for pieces that would have wrapped\\n for relatorindex in range(len(rels)):\\n relator=irels[2*relatorindex]\\n foundbiggest=False\\n for L in range(len(relator),int(biggestratio*len(relator)),-1):# only check subwords of length L that would give biggest ratio if they were a piece\\n for startingindex in range(len(relator)):\\n p=(relator+relator)[startingindex:startingindex+L] # the subword of length L starting at index i in relator as a cyclic word\\n # now we need to check if p is a piece\\n # we do not need to check lower relatorindices, because we already scanned those relators for pieces\\n if any(p in x for x in [(relator+relator)[startingindex+1:len(relator)+startingindex+L-1]]+[drels[i] for i in range(2*relatorindex+1,len(drels))]):# look in this (doubled) relator at higher starting indices, and in all later relators, for other copies of p. If found a matching subword, p is a piece.\\n biggestratio=Fraction(len(p),len(relator))\\n foundbiggest=True # we search pieces by decreasing length, so first one we find is longest\\n if biggestratio>=Fraction(1,Lambda):\\n return 1\\n break\\n if foundbiggest: # if we found the biggest piece in this relator we can move on to the next relator. \\n break\\n return biggestratio\",\n \"def _compile(self, expression):\\n t = re.split(r'\\\\s+(\\\\+|-)\\\\s+', expression)\\n ocomps = t[::2] # output component sub-expressions\\n signs = [1.] # implied + in front of expression\\n signs.extend(1. if s == '+' else -1 for s in t[1::2]) \\n factors = [(1., 1) for i in ocomps]\\n for i, s in enumerate(ocomps):\\n tt = re.split(r'\\\\s+(\\\\*|/)\\\\s+', s) # split on */ operator\\n lval = self._lval(tt[0])\\n if len(tt) > 1:\\n factors[i] = self._rval(tt[2]), 1 if tt[1] == '*' else -1\\n if not isinstance(lval, Output): \\n if len(ocomps) == 1: # simple basic output (special case)\\n self.is_basic = True\\n self._factor = factors[0]\\n self._compile_basic(lval)\\n return\\n else: # compound basic output\\n ocomps[i] = Output(parent=self.parent,\\n expression=lval,\\n factor=factors[i],\\n is_basic=True)\\n else: # summary output\\n ocomps[i] = lval #self.parent.outputs[lval]\\n self._ocomps = ocomps\\n self._signs = signs\\n self._factors = factors\",\n \"def Mol_SO(Nat, multip, charge, sym, SO_3rdrow_mols_val): # number of atoms, multiplicity, charge, array of atoms in molecule, value of SO_3rdrow_mols (from orca.inp file)\\n\\n Mol_SO = 0\\n \\n # Special Case - Acetleyne - S\\n if Nat == 4 and multip == 2 and charge == 1:\\n countH_temp =0\\n countC_temp =0\\n for tmp in range(len(sym)):\\n if sym[tmp] == \\\"H\\\":\\n countH_temp= countH_temp +1\\n if sym[tmp] == \\\"C\\\":\\n countC_temp = countC_temp +1\\n if countH_temp == 2 and countC_temp == 2:\\n Mol_SO = -0.07 #-0.07d0\\n \\n with open(\\\"Thermochemistry.out\\\", \\\"a\\\") as ther_chem:\\n ther_chem.write(\\\"DETECTED A C2H2+ SYSTEM: Using SO parameters for acetylene cation\\\\n\\\")\\n ther_chem.write(\\\"Ref: JCP 114, 9287, 2001\\\\n\\\\n\\\")\\n # Special Case - Acetleyne - E\\n \\n # For diatomics with multip = 2\\n if Nat == 2 and multip == 2 :\\n sort_sym = sorted(sym, reverse=True)\\n if SO_3rdrow_mols_val == \\\"true\\\": # for 3rd_row elements\\n \\n if charge == 0:\\n if sort_sym[0] == 'O' and sort_sym[1] == 'Br': Mol_SO=-2.20\\n \\n # COMMMENT: paper has it for cation, but it looks like it is for neutral\\n if sort_sym[0] == 'Se' and sort_sym[1] == 'H': Mol_SO=-4.21\\n \\n if charge == +1: ### RECHECK what the values of charge is!!!!!!!!!!!!!!!!!!!!!IMPORTANT\\n if sort_sym[0] == 'K' and sort_sym[1] == 'Br': Mol_SO=-2.99\\n if sort_sym[0] == 'H' and sort_sym[1] == 'As': Mol_SO=-3.54\\n if sort_sym[0] == 'H' and sort_sym[1] == 'Br': Mol_SO=-6.26\\n if sort_sym[0] == 'F' and sort_sym[1] == 'Br': Mol_SO=-6.10\\n if sort_sym[0] == 'Na' and sort_sym[1] == 'Br': Mol_SO=-3.93\\n if sort_sym[0] == 'Br' and sort_sym[1] == 'Br': Mol_SO=-6.55\\n \\n else: # for non 3rd row elements, first and second rows\\n if charge == 0:\\n if sort_sym[0] == 'H' and sort_sym[1] == 'C': Mol_SO=-0.07\\n if sort_sym[0] == 'O' and sort_sym[1] == 'H': Mol_SO=-0.30\\n if sort_sym[0] == 'O' and sort_sym[1] == 'N': Mol_SO=-0.27\\n if sort_sym[0] == 'O' and sort_sym[1] == 'Cl': Mol_SO=-0.61\\n if sort_sym[0] == 'S' and sort_sym[1] == 'H': Mol_SO=-1.01\\n if sort_sym[0] == 'P' and sort_sym[1] == 'O': Mol_SO=-0.53\\n if sort_sym[0] == 'Si' and sort_sym[1] == 'H': Mol_SO=-0.34\\n \\n if charge == -1:\\n if sort_sym[0] == 'N' and sort_sym[1] == 'H': Mol_SO=-0.12\\n if sort_sym[0] == 'P' and sort_sym[1] == 'H': Mol_SO=-0.45\\n if sort_sym[0] == 'O' and sort_sym[1] == 'O': Mol_SO=-0.34\\n if sort_sym[0] == 'S' and sort_sym[1] == 'S': Mol_SO=-1.12\\n \\n if charge == +1:\\n if sort_sym[0] == 'H' and sort_sym[1] == 'F': Mol_SO=-0.62\\n if sort_sym[0] == 'P' and sort_sym[1] == 'H': Mol_SO=-0.67\\n if sort_sym[0] == 'H' and sort_sym[1] == 'Cl': Mol_SO=-1.60\\n if sort_sym[0] == 'N' and sort_sym[1] == 'N': Mol_SO=-0.17\\n if sort_sym[0] == 'O' and sort_sym[1] == 'O': Mol_SO=-0.43\\n if sort_sym[0] == 'P' and sort_sym[1] == 'P': Mol_SO=-0.57\\n if sort_sym[0] == 'S' and sort_sym[1] == 'S': Mol_SO=-1.25\\n if sort_sym[0] == 'Cl' and sort_sym[1] == 'Cl': Mol_SO=-1.77\\n if sort_sym[0] == 'F' and sort_sym[1] == 'Cl': Mol_SO=-1.60\\n \\n return(Mol_SO)\",\n \"def visit_Compound(self, node):\\n for statement in node.statements:\\n self.visit(statement)\",\n \"def length(cont):\\r\\n\\r\\n mySum = 0\\r\\n\\r\\n if cont == \\\"\\\":\\r\\n return 0\\r\\n else:\\r\\n mySum += 1 + length(cont[1:])\\r\\n return mySum\",\n \"def calculate(self) -> complex128:\\n\\n if not self.__can_calculation_be_performed():\\n raise AttributeError\\n\\n v_vectors = self.__calculate_v_vectors()\\n\\n permanent = 0\\n for v_vector in v_vectors:\\n v_sum = sum(v_vector)\\n addend = pow(-1, v_sum)\\n # Binomials calculation\\n for i in range(len(v_vector)):\\n addend *= binom(self.__input_state[i], v_vector[i])\\n\\n # Product calculation\\n product = 1\\n for j in range(len(self.__input_state)):\\n if self.__output_state[j] == 0: # There's no reason to calculate the sum if t_j = 0\\n continue\\n # Otherwise we calculate the sum\\n product_part = 0\\n for i in range(len(self.__input_state)):\\n product_part += (self.__input_state[i] - 2 * v_vector[i]) * self.__matrix[j][i]\\n product_part = pow(product_part, self.__output_state[j])\\n product *= product_part\\n addend *= product\\n permanent += addend\\n\\n permanent /= pow(2, sum(self.__input_state))\\n\\n return permanent\",\n \"def get_complexes(self):\\n q_cmplx = prefixes + \\\"\\\"\\\"\\n SELECT ?complexTerm ?childName ?child ?stmt\\n WHERE {\\n {\\n {?stmt belvoc:hasSubject ?complexTerm}\\n UNION\\n {?stmt belvoc:hasObject ?complexTerm .}\\n UNION\\n {?stmt belvoc:hasSubject ?term .\\n ?term belvoc:hasChild ?complexTerm .}\\n UNION\\n {?stmt belvoc:hasObject ?term .\\n ?term belvoc:hasChild ?complexTerm .}\\n }\\n ?complexTerm a belvoc:Term .\\n ?complexTerm a belvoc:ComplexAbundance .\\n ?complexTerm belvoc:hasChild ?child .\\n ?child belvoc:hasConcept ?childName .\\n }\\n \\\"\\\"\\\"\\n # Run the query\\n res_cmplx = self.g.query(q_cmplx)\\n\\n # Store the members of each complex in a dict of lists, keyed by the\\n # term for the complex\\n cmplx_dict = collections.defaultdict(list)\\n cmplx_ev = {}\\n for stmt in res_cmplx:\\n stmt_uri = stmt[3]\\n ev = self._get_evidence(stmt_uri)\\n for e in ev:\\n e.epistemics['direct'] = True\\n cmplx_name = term_from_uri(stmt[0])\\n cmplx_id = stmt_uri + '#' + cmplx_name\\n child = self._get_agent(stmt[1], stmt[2])\\n cmplx_dict[cmplx_id].append(child)\\n # This might be written multiple times but with the same\\n # evidence\\n cmplx_ev[cmplx_id] = ev\\n # Now iterate over the stored complex information and create binding\\n # statements\\n for cmplx_id, cmplx_list in cmplx_dict.items():\\n if len(cmplx_list) < 2:\\n msg = 'Complex %s has less than 2 members! Skipping.' % \\\\\\n cmplx_name\\n logger.warning(msg)\\n else:\\n self.statements.append(Complex(cmplx_list,\\n evidence=cmplx_ev[cmplx_id]))\",\n \"def get_number_operators(self) -> int:\\n if self.sons:\\n return 1 + sum([son.get_number_operators() for son in self.sons])\\n return 0\",\n \"def collect_nested(expr, aggressive=False):\\n\\n def run(expr):\\n # Return semantic (rebuilt expression, factorization candidates)\\n\\n if expr.is_Number or expr.is_Symbol:\\n return expr, [expr]\\n elif expr.is_Indexed or expr.is_Atom:\\n return expr, []\\n elif expr.is_Add:\\n rebuilt, candidates = zip(*[run(arg) for arg in expr.args])\\n\\n w_numbers = [i for i in rebuilt if any(j.is_Number for j in i.args)]\\n wo_numbers = [i for i in rebuilt if i not in w_numbers]\\n\\n w_numbers = collect_const(expr.func(*w_numbers))\\n wo_numbers = expr.func(*wo_numbers)\\n\\n if aggressive is True and wo_numbers:\\n for i in flatten(candidates):\\n wo_numbers = collect(wo_numbers, i)\\n\\n rebuilt = expr.func(w_numbers, wo_numbers)\\n return rebuilt, []\\n elif expr.is_Mul:\\n rebuilt, candidates = zip(*[run(arg) for arg in expr.args])\\n rebuilt = collect_const(expr.func(*rebuilt))\\n return rebuilt, flatten(candidates)\\n elif expr.is_Equality:\\n rebuilt, candidates = zip(*[run(expr.lhs), run(expr.rhs)])\\n return expr.func(*rebuilt, evaluate=False), flatten(candidates)\\n else:\\n rebuilt, candidates = zip(*[run(arg) for arg in expr.args])\\n return expr.func(*rebuilt), flatten(candidates)\\n\\n return run(expr)[0]\",\n \"def process():\\r\\n\\t### INPUT ####\\r\\n\\tpq = eat(str)\\r\\n\\tp, q = map(int, pq.split('/'))\\r\\n\\t\\r\\n\\t### COMPUT ####\\r\\n\\td = gcd(p, q)\\r\\n\\tp, q = p//d, q//d\\r\\n\\teprint(bin(q), bin(p))\\r\\n\\tif len(bin(q).strip('0')) != 2:\\r\\n\\t\\treturn IMPOSSIBLE\\r\\n\\t#length of p\\r\\n\\tbinp = bin(p)\\r\\n\\tbinq = bin(q)\\r\\n\\treturn len(binq) - len(binp)\\r\\n\\t\\r\\n\\t### OUTPUT ####\\r\\n\\treturn solve()\",\n \"def convex_conj(self):\\n convex_conjs = [func.convex_conj for func in self.functionals]\\n return SeparableSum(*convex_conjs)\",\n \"def __add__(self, other):\\n self.sum_complex_num = Complex((self.real + other.real), (self.imaginary + other.imaginary))\\n return self.sum_complex_num\",\n \"def radical_c2(self, atoms):\\n\\n c1, c2 = atoms.keys()\\n c1_ndx, c2_ndx = atoms.values()\\n\\n chain1, chain2 = self.determine_chains([c1, c2])\\n\\n # to get indexing right\\n c1_ndx -= self.monomer.indices[chain1]['C1']\\n c2_ndx -= self.monomer.indices[chain2]['C2']\\n\\n # types after reaction\\n types = {'chain1': {'C1': 'c3', 'C2': 'c2', 'C3': 'c2', 'C4': 'c2', 'H1': 'hc', 'H2': 'hc', 'H3': 'ha',\\n 'H4': 'ha', 'H5': 'ha'}, # chain1 contains c1\\n 'chain2': {'C1': 'c3', 'C2': 'c3', 'C3': 'c2', 'C4': 'c2', 'H1': 'hc', 'H2': 'hc', 'H3': 'hc',\\n 'H4': 'ha', 'H5': 'ha'}} # chain2 contains c2 radical\\n\\n # update types\\n reacted_types = {'chain1': {c1_ndx + self.monomer.indices[chain1][a]: types['chain1'][a]\\n for a in types['chain1'].keys()},\\n 'chain2': {c2_ndx + self.monomer.indices[chain2][a]: types['chain2'][a]\\n for a in types['chain2'].keys()}}\\n\\n # new bonds\\n bonds = [[c1_ndx + self.monomer.indices[chain1]['C1'], c2_ndx + self.monomer.indices[chain2]['C2'], 'carbon']]\\n\\n # no dummy bonds to add\\n\\n # define indices of left-over radicals\\n radicals = [c1_ndx + self.monomer.indices[chain1]['C2']]\\n\\n chain1_impropers = ['C1'] # [1]\\n chain2_impropers = ['C2'] # [2]\\n rm_improper = []\\n for c in chain1_impropers:\\n rm_improper.append([c1_ndx + self.monomer.indices[chain1][x] for x in self.monomer.impropers[chain1][c]])\\n for c in chain2_impropers:\\n rm_improper.append([c2_ndx + self.monomer.indices[chain2][x] for x in self.monomer.impropers[chain2][c]])\\n\\n # define terminated atoms\\n terminated = [c1_ndx + self.monomer.indices[chain1]['C1'], c2_ndx + self.monomer.indices[chain2]['C2']]\\n\\n return reacted_types, bonds, radicals, rm_improper, terminated\",\n \"def qed_cc( s, m, r):\\n\\n l1_t2 = s + m\\n l2 = r + s\\n\\n if l1_t2 % 2 != 0:\\n return 0\\n\\n denom = factorial(s) * factorial(m) * factorial(r)**2\\n nom = double_factorial( l1_t2 - 1 ) * factorial( l2 )\\n\\n return Fraction( nom, denom )\",\n \"def RyserFormula(num_coincidence: int, U_st: numpy.ndarray) -> complex:\\n\\n value_perm = 0\\n set = CreateSubset(num_coincidence)\\n\\n for subset in set:\\n num_elements = len(subset)\\n value_times = 1\\n for i in range(num_coincidence):\\n value_sum = 0\\n for j in subset:\\n value_sum += U_st[i, j]\\n value_times *= value_sum\\n value_perm += value_times * (-1) ** num_elements\\n value_perm *= (-1) ** num_coincidence\\n return value_perm\",\n \"def test_complexity():\\n file_paths = glob.iglob('*/*.py')\\n for file_path in file_paths:\\n with open(file_path, 'r') as file_obj:\\n blocks = radon.cc_visit(file_obj.read())\\n for block in blocks:\\n fail_msg = '{} ({}) has a cyclomatic complexity of {}'.format(\\n block.name, file_path, block.complexity)\\n yield case.assertLessEqual, block.complexity, 10, fail_msg\",\n \"def simplify (self):\\n if (self.debug): print(f'enter fraction.simplify')\\n hcf = find_hcf(self.value[0], self.value[1])\\n self.value = (self.value[0] // hcf.product(), self.value[1] // hcf.product())\\n return\",\n \"def solve_equation_addition_precendence(eq, verbose=False):\\n tokens = tokenize(eq)\\n if verbose:\\n print(f\\\"eq: {tokens}\\\")\\n\\n stack = []\\n ops = {\\n None: do_push,\\n \\\"(\\\": do_push,\\n \\\")\\\": do_parenthesis,\\n \\\"+\\\": do_addition,\\n \\\"*\\\": do_push,\\n }\\n\\n for t in tokens:\\n if isinstance(t, int):\\n op = stack[-1] if len(stack) else None\\n ops[op](stack, t)\\n elif t == \\\"+\\\" or t == \\\"*\\\" or t == \\\"(\\\":\\n stack.append(t)\\n elif t == \\\")\\\":\\n ops[\\\")\\\"](stack, t)\\n # solve preparenthesis addition\\n if len(stack) > 2:\\n v = stack.pop()\\n assert isinstance(v, int)\\n ops[stack[-1]](stack, v)\\n else:\\n assert False, f\\\"fail token: {t}\\\"\\n\\n if verbose:\\n print(f\\\"stack: {stack}\\\")\\n\\n # solve multiplications\\n while len(stack) > 1:\\n rhs = stack.pop()\\n assert isinstance(rhs, int)\\n op = stack.pop()\\n if op == \\\"*\\\":\\n lhs = stack.pop()\\n assert isinstance(lhs, int)\\n stack.append(lhs * rhs)\\n else:\\n assert False, f\\\"invalid operator (not *): {op}\\\"\\n\\n assert len(stack) == 1\\n return stack[0]\",\n \"def sum_proper_divisors(n):\\r\\n return sum(proper_divisors(n))\",\n \"def tree_string(self):\\n if self.body is None:\\n return 0\\n if self.left is None and self.right is None:\\n return self.body\\n left_sum = self.left.tree_string()\\n right_sum = self.right.tree_string()\\n if self.body == add:\\n return str(left_sum) + '+' + str(right_sum)\\n elif self.body == sub:\\n return str(left_sum) + '-' + str(right_sum)\\n elif self.body == mul:\\n return str(left_sum) + '*' + str(right_sum)\\n else:\\n return str(left_sum) + '/' + str(right_sum)\",\n \"def score( canvas ):\\n\\n score = 0\\n\\n score += length_score(canvas)\\n score += angle_score(canvas)\\n\\n # 1. Chainbreaks for all junction loops.\\n\\n # 2. Nucleotides should be at least 15 from ALL other nts. Don't double-count.\\n for seqpos1, nt1 in canvas.nucleotides.iteritems():\\n for seqpos2, nt2 in canvas.nucleotides.iteritems():\\n if seqpos1 >= seqpos2: continue\\n #if distance( nt1, nt2 ) < 15: score += 100\\n # Don't do a square root you don't have to\\n if distance_squared( nt1, nt2 ) < 225: score += 100\\n\\n\\n # 2b. Depending on base pair width, it's possible that the 'best' orientation for two stacks is\\n # for them to be overlapping...\\n # nt --- nt\\n # | nt |-- nt\\n # nt -|- nt |\\n # | nt |-- nt\\n # so, penalize this ( 'between two bp'ed nts' penalized like hitting a nt )\\n for seqpos, nt in canvas.nucleotides.iteritems():\\n for stem in canvas.stems:\\n for bp in stem.base_pairs:\\n if nt == bp.nt1 or nt == bp.nt2:\\n continue\\n # if nt in question is 'in between' nt1 and nt2. how to judge?\\n if nt.x > bp.nt1.x and nt.x < bp.nt2.x \\\\\\n and closer_than( nt.y, bp.nt1.y, canvas.bp_offset_height*0.8 ):\\n score += 100\\n\\n # Look at pairs of adjacent nts in stem\\n for seqpos1, nt1 in stem.nucleotides.iteritems():\\n if seqpos1 + 1 in stem.nucleotides.keys():\\n nt2 = stem.nucleotides[ seqpos1 + 1 ]\\n if nt.y > nt1.y and nt.y < nt2.y \\\\\\n and closer_than( nt.x, nt1.x, canvas.bp_offset_width*0.8 ):\\n score += 100\\n\\n # 3. Stems should be straight and vertical.\\n ### Resolved via kinematics?\\n\\n # 4. Coaxial stacks, where known, should be colinear.\\n for idx1, idx2 in canvas.list_of_coaxialities:\\n # idx1 and idx2 are coaxial stems.\\n # Any two BPs from these stems should do, but -- because I have no idea\\n # how we intend to handle 'alternate-order' stacks (where the first nt in a bp\\n # is stacked on the second nt in another), compare either direction.\\n bp1 = canvas.stems[idx1].base_pairs[0]\\n bp2 = canvas.stems[idx2].base_pairs[0]\\n penalty1 = harmonic_penalty( bp1.nt1.x - bp2.nt1.x, 0, 1 ) + harmonic_penalty( bp1.nt2.x - bp2.nt2.x, 0, 1 )\\n penalty2 = harmonic_penalty( bp1.nt1.x - bp2.nt2.x, 0, 1 ) + harmonic_penalty( bp1.nt2.x - bp2.nt1.x, 0, 1 )\\n score += min( penalty1, penalty2 )\\n\\n\\n # 5. Apical loops should be symmetrical and near a circular path.\\n for loop in canvas.loops:\\n for seqpos in loop.nucleotides.keys():\\n pass\\n\\n return score\",\n \"def n_complex_components(self):\\n return self.n_components // 2 + (self.n_components % 2)\",\n \"def problem9_complex(n):\\n # Start with 1 to avoid triples with zero.\\n for u in range(1, n):\\n for v in range(u, n):\\n # When u == v one of the a, b becomes 0\\n if u != v:\\n\\n # The following two blocks do the same thing.\\n # First one uses complex numbers.\\n # Second one uses generalised formulas.\\n\\n # comp = complex(u, v) ** 2\\n # a = abs(comp.real)\\n # b = abs(comp.imag)\\n # c = sqrt(a ** 2 + b ** 2)\\n\\n a = abs(u ** 2 - v ** 2)\\n b = abs(2 * u * v)\\n c = abs(u ** 2 + v ** 2)\\n\\n if a + b + c == n:\\n return a * b * c\\n return None\",\n \"def visit_term(self, node, children):\\n if self.debug:\\n print(\\\"Term {}\\\".format(children))\\n term = children[0]\\n for i in range(2, len(children), 2):\\n if children[i-1] == \\\"*\\\":\\n term *= children[i]\\n else:\\n term /= children[i]\\n if self.debug:\\n print(\\\"Term = {}\\\".format(term))\\n return term\",\n \"def length(formula):\\n if isinstance(formula, Atom):\\n return 1\\n if isinstance(formula, Not):\\n return length(formula.inner) + 1\\n if isinstance(formula, Implies) or isinstance(formula, And) or isinstance(formula, Or):\\n return length(formula.left) + length(formula.right) + 1\",\n \"def check_rec(eqparams, tracecombo=(dict(), 0, set(range(10))), p=0):\\n # Basic parameters of the equation,\\n # maximal digit rank\\n # characters with multipliers by rank\\n # unique non-zero characters by rank\\n # unique zero-allowed characters by rank\\n # all unique characters by rank\\n maxp, tchars, unzchars, uokzchars, uchars = eqparams\\n # recursion cumulative parameters\\n # established characters with digits\\n # carry-over from the previous level\\n # remaining unassigned digits\\n prevdict, cover, remdigs = tracecombo\\n # the maximal 10-power (beyond the maximal rank)\\n # is reached\\n if p == maxp:\\n # Carry-over is zero, meaning solution is found\\n if cover == 0:\\n return prevdict\\n else:\\n # Otherwise the solution in this branch is not found\\n # return empty\\n return dict()\\n diglets = uchars[p] # all new unique letters from the current level\\n partsum = cover # Carry over from lower level\\n remexp = [] # TBD letters\\n # Break down the current level letter into what can be\\n # calculated in the partial sum and remaining TBD letter-digits\\n for c, v in tchars[p]:\\n if c in prevdict:\\n partsum += v * prevdict[c]\\n else:\\n remexp.append((c, v))\\n # Generate permutations for the remaining digits and currecnt level\\n # non-zero letters and zero-allowed letters\\n for newdigs in digPerms(remdigs, unzchars[p], uokzchars[p]):\\n # build the dictionary for the new letters and this level\\n newdict = dict(zip(diglets, newdigs))\\n # complete the partial sum into test sum using the current permutation\\n testsum = partsum + sum([newdict[c] * v\\n for c, v in remexp])\\n # check if the sum is divisible by 10\\n d, r = divmod(testsum, 10)\\n if r == 0:\\n # if divisible, update the dictionary to all established\\n newdict.update(prevdict)\\n # proceed to the next level of recursion with\\n # the same eqparams, but updated digit dictionary,\\n # new carry over and remaining digits to assign\\n rectest = check_rec(eqparams,\\n (newdict, d, remdigs - set(newdigs)),\\n p + 1)\\n # if the recursive call returned a non-empty dictionary\\n # this means the recursion has found a solution\\n # otherwise, proceed to the new permutation\\n if rectest and len(rectest) > 0:\\n return rectest\\n # if no permutations are avaialble or no\\n # permutation gave the result return None\\n return None\",\n \"def test_ccsd_doubles_a_terms(parthole_drudge):\\n\\n dr = parthole_drudge\\n p = dr.names\\n\\n a, b, c, d = p.V_dumms[:4]\\n i, j, k, l = p.O_dumms[:4]\\n u = dr.two_body\\n t = IndexedBase('t')\\n dr.set_dbbar_base(t, 2)\\n\\n tau = dr.define_einst(\\n IndexedBase('tau')[a, b, i, j],\\n Rational(1, 2) * t[a, b, i, j] + t[a, i] * t[b, j]\\n )\\n\\n a_i = dr.define_einst(\\n IndexedBase('ai')[k, l, i, j], u[i, c, k, l] * t[c, j]\\n )\\n\\n a_ = dr.define(\\n IndexedBase('a')[k, l, i, j],\\n u[k, l, i, j] +\\n a_i[k, l, i, j] - a_i[k, l, j, i]\\n + u[k, l, c, d] * tau[c, d, i, j]\\n )\\n\\n tensor = dr.define_einst(\\n IndexedBase('r')[a, b, i, j],\\n a_[k, l, i, j] * tau[a, b, k, l]\\n )\\n targets = [tensor]\\n\\n eval_seq = optimize(\\n targets, substs={p.nv: p.no * 10}, strategy=Strategy.ALL | Strategy.SUM\\n )\\n assert verify_eval_seq(eval_seq, targets)\\n # Here we just assert that the final step is a simple product.\\n assert len(eval_seq[-1].rhs_terms) == 1\",\n \"def test_simple_cc():\\n hs_c = LocalSpace('c', dimension=3)\\n hs_q = LocalSpace('q1', basis=('g', 'e'))\\n Delta_1 = Symbol('Delta_1')\\n Omega_1 = Symbol('Omega_1')\\n g_1 = Symbol('g_1')\\n a = Destroy(hs=hs_c)\\n a_dag = Create(hs=hs_c)\\n sig_p = LocalSigma('e', 'g', hs=hs_q)\\n sig_m = LocalSigma('g', 'e', hs=hs_q)\\n coeff = (-I / 2) * (Omega_1 * g_1 / Delta_1)\\n jc_expr = coeff * (a * sig_p - a_dag * sig_m)\\n\\n simplified = rewrite_with_operator_pm_cc(jc_expr)\\n assert simplified == coeff * OperatorPlusMinusCC(a * sig_p, sign=-1)\\n assert (\\n srepr(simplified.term)\\n == \\\"OperatorPlusMinusCC(OperatorTimes(Destroy(hs=LocalSpace('c', \\\"\\n \\\"dimension=3)), LocalSigma('e', 'g', hs=LocalSpace('q1', \\\"\\n \\\"basis=('g', 'e')))), sign=-1)\\\"\\n )\\n expanded = simplified.doit()\\n assert expanded == jc_expr\",\n \"def normal(e, **kw_args):\\n\\n if not e:\\n return S.Zero\\n\\n opts = {\\n 'simplify_kronecker_deltas': False,\\n 'expand': True,\\n 'simplify_dummies': False,\\n 'keep_only_fully_contracted': False,\\n 'lam': 1\\n }\\n opts.update(kw_args)\\n\\n # break up any NO-objects, and evaluate commutators\\n e = e.doit(wicks=True)\\n\\n # make sure we have only one term to consider\\n e = e.expand()\\n if isinstance(e, Add):\\n return Add(*[ normal(term, **kw_args) for term in e.args])\\n\\n # For Mul-objects we can actually do something\\n if isinstance(e, Mul):\\n\\n # we don't want to mess around with commuting part of Mul\\n # so we factorize it out before starting recursion\\n c_part = []\\n string1 = []\\n for factor in e.args:\\n if factor.is_commutative:\\n c_part.append(factor)\\n else:\\n string1.append(factor)\\n n = len(string1)\\n\\n # catch trivial cases\\n if n == 0:\\n result = e\\n elif n == 1:\\n result = e\\n else: # non-trivial\\n if n > 2:\\n # recursive step\\n if isinstance(string1[0], CreateBoson) \\\\\\n or (string1[0].is_Pow and \\\\\\n isinstance(string1[0].args[0], CreateBoson)):\\n # if the first term is ad^m\\n result = string1[0] * normal(Mul(*string1[1:]), **kw_args)\\n else:\\n # if the first term is a^m,\\n # bring the first two terms to normal order first\\n result = normal(normal(Mul(*string1[:2]), **kw_args)*Mul(*string1[2:]), **kw_args)\\n else: # n = 2,\\n result = _normal(string1, opts['lam'])\\n result = Mul(*c_part)*result\\n\\n if opts['expand']:\\n result = result.expand()\\n # if opts['simplify_kronecker_deltas']:\\n # result = evaluate_deltas(result)\\n\\n return result\\n\\n # there was nothing to do\\n return e\",\n \"def degree_on_basis(self, b):\\n return sum(b)\",\n \"def connectors_calc(level):\\n global connectors\\n connectors = level*(level+1)/2\\n return connectors\",\n \"def C(relatorlist,quit_at=float('inf')):\\n F,rels=fg.parseinputwords(relatorlist)\\n if not all(r==F.cyclic_reduce(r) for r in rels):\\n raise ValueError(\\\"Relators are not cyclically reduced.\\\")\\n thepieces=pieces(rels)\\n minnumberpieces=quit_at\\n def min_string_piece_expression(whatsleft,thepieces,quit_at):\\n # recursively determine the minimal expression of the string whatsleft as a concatenation of elements of thepieces, or stop once it is determined that any such expression requires at least quit_at many pieces\\n # find a piece that agrees with a prefix of whatsleft and the recurse on the suffix\\n if not whatsleft:\\n return 0\\n minexp=quit_at\\n for p in thepieces:\\n if p!=whatsleft[:len(p)]:\\n continue\\n else:\\n minexp=min(minexp,1+min_string_piece_expression(whatsleft[len(p):],thepieces,minexp-1))\\n return minexp\\n def min_relator_piece_expression(relator,thepieces,quit_at):\\n # This is first step in recursive search. Here we want to find a piece p such that for relator r we can write p=xy and r=yzx, with y nontrivial. That is, in this step only we think of r as cyclic word and allow first piece that wraps.\\n r=relator()\\n minexp=quit_at\\n for p in thepieces:\\n if len(p)>len(r):\\n continue\\n possiblestartingindices=[] # for given p there may be different possible choices of y\\n for startingindex in range(len(r)-len(p)+1,len(r)+1):\\n if p==(r+r)[startingindex:startingindex+len(p)]:\\n possiblestartingindices.append(startingindex)\\n if not possiblestartingindices:\\n continue\\n for startingindex in possiblestartingindices:\\n # found a way to fit p into r spanning the beginning of r. This accounts for x and y part of r. Now recursively find shortest expression of z=whatsleft as a concatenation of pieces.\\n whatsleft=(r+r)[startingindex+len(p):startingindex+len(r)]\\n if not whatsleft:\\n return 1\\n else:\\n minexp=min(minexp,1+min_string_piece_expression(whatsleft,thepieces,minexp-1))\\n return minexp\\n for thisrelator in rels:\\n minnumberpieces=min(minnumberpieces,min_relator_piece_expression(thisrelator,thepieces,minnumberpieces))\\n return minnumberpieces\",\n \"def CalcSingleCompoundDescriptor(compos, argVect, atomDict, propDict):\\n try:\\n atomVarNames = argVect[0]\\n compositionVarNames = argVect[1]\\n formula = argVect[2]\\n formula = _SubForCompoundDescriptors(formula, compositionVarNames, 'propDict')\\n formula = _SubForAtomicVars(formula, atomVarNames, 'atomDict')\\n evalTarget = _SubMethodArgs(formula, knownMethods)\\n except Exception:\\n if __DEBUG:\\n import traceback\\n print('Sub Failure!')\\n traceback.print_exc()\\n print(evalTarget)\\n print(propDict)\\n raise RuntimeError('Failure 1')\\n else:\\n return -666\\n\\n try:\\n v = eval(evalTarget)\\n except Exception:\\n if __DEBUG:\\n import traceback\\n outF = open(RDConfig.RDCodeDir + '/ml/descriptors/log.txt', 'a+')\\n outF.write('#------------------------------\\\\n')\\n outF.write('formula: %s\\\\n' % repr(formula))\\n outF.write('target: %s\\\\n' % repr(evalTarget))\\n outF.write('propDict: %s\\\\n' % (repr(propDict)))\\n\\n outF.write('keys: %s\\\\n' % (repr(sorted(atomDict))))\\n outF.close()\\n print('ick!')\\n print('formula:', formula)\\n print('target:', evalTarget)\\n print('propDict:', propDict)\\n print('keys:', atomDict.keys())\\n traceback.print_exc()\\n raise RuntimeError('Failure 2')\\n else:\\n v = -666\\n return v\",\n \"def lucas_recur(n):\\n if n == 0:\\n return 2\\n elif n == 1:\\n return 1\\n return lucas_recur(n - 1) + lucas_recur(n - 2)\",\n \"def all_change(cur: Currency, r: float, max_permutation=1000, only_cents=True) -> List[Union[int, List]]:\\n\\n # sub problem: combinations to return n < r with a set of coins s' subset of s\\n # base case: combinations to return 0 = 1: empty list\\n # characteristic equation: sum of combinations using that coin with combinations without using that coin.\\n\\n # introducing convenient notation working in cents\\n m = cur.num_denominations()\\n S = [_ for _ in cur.iter_denominations()] if only_cents else [_float2int(x) for x in cur.iter_denominations()]\\n n = _float2int(r) if not only_cents else r\\n\\n # Construct table\\n T = [[[0, []] for _ in range(m)] for _ in range(n + 1)]\\n\\n # Base case (value zero has just one solution: empty list)\\n for i in range(m):\\n T[0][i] = [1, [[0 for _ in range(m)]]]\\n\\n # Fill rest of the table entries\\n for i in range(1, n + 1):\\n for j in range(m):\\n # Count of solutions including S[j]\\n x = T[i - S[j]][j][0] if i - S[j] >= 0 else 0\\n\\n # get max_permutation permutation value\\n if x > 0:\\n k = 0\\n while len(T[i][j][1]) < max_permutation and k < len(T[i - S[j]][j][1]):\\n sol = T[i - S[j]][j][1][k]\\n T[i][j][1].append(sol[:])\\n T[i][j][1][-1][j] += 1\\n k += 1\\n\\n # Count of solutions excluding S[j]\\n y = T[i][j - 1][0] if j >= 1 else 0\\n\\n # get max_permutation permutation value\\n if y > 0:\\n k = 0\\n while len(T[i][j][1]) < max_permutation and k < len(T[i][j - 1][1]):\\n sol = T[i][j - 1][1][k]\\n T[i][j][1].append(sol[:])\\n k += 1\\n\\n # total count\\n T[i][j][0] = x + y\\n\\n return T[-1][-1]\",\n \"def computeList(Code):\\r\\n \\r\\n l = len(Code);\\r\\n # Make sure number of left brackets still == no of right brackets\\r\\n checkBrackets(Code);\\r\\n \\r\\n if l == 0:\\r\\n return None\\r\\n \\r\\n # Base case: Code = ['T'] or ['F'] or has brackets.\\r\\n if l == 1:\\r\\n \\r\\n C = Code[0].strip('( )');\\r\\n \\r\\n if C in constants: return C;\\r\\n \\r\\n else: return Exception(\\\"output is neither true nor false.\\\");\\r\\n \\r\\n \\r\\n # Secondary case: No brackets remaining.\\r\\n elif not containsBrackets(Code):\\r\\n \\r\\n sub = {}; # records reduced indices in list, as a result of computation\\r\\n \\r\\n order = tuple();\\r\\n for prec in precedence:\\r\\n order += orderOfComputation(Code, prec); # Order of looking at the computation\\r\\n \\r\\n for i in order:\\r\\n \\r\\n s = total_sub(sub, i); # Computes the total to be subtracted from index.\\r\\n j = i-s; item = Code[j];\\r\\n \\r\\n # Negation case.\\r\\n if inputs[item] == 1:\\r\\n f = interpret[item]; inp = interpret[Code[j+1]];\\r\\n result = f(inp); string = inverse[result];\\r\\n Code = Code[:j] + [string] + Code[j+2:];\\r\\n \\r\\n # Update sub\\r\\n if not i in sub:\\r\\n sub[i] = 1;\\r\\n \\r\\n else:\\r\\n sub[i] += 1;\\r\\n \\r\\n # Binary Relation case.\\r\\n elif inputs[item] == 2:\\r\\n f = interpret[item]; \\r\\n inp = (interpret[Code[j-1]], interpret[Code[j+1]]);\\r\\n result = f(*inp); string = inverse[result];\\r\\n Code = Code[:j-1] + [string] + Code[j+2:];\\r\\n \\r\\n # Update sub\\r\\n if not i in sub:\\r\\n sub[i] = 2;\\r\\n \\r\\n else:\\r\\n sub[i] += 2;\\r\\n \\r\\n else:\\r\\n raise Exception('incomplete inputs set.')\\r\\n \\r\\n \\r\\n # Tertiary case: brackets left inside to compute.\\r\\n else: # Here, deal with brackets to make sure no brackets are contained in between.\\r\\n \\r\\n # Remove the same total number of brackets from each end.\\r\\n if not hasMidBrackets(Code):\\r\\n endB = endBrackets(Code); first = endB[0]; last = endB[1];\\r\\n Code = Code[first+1: last]; \\r\\n \\r\\n return computeList(Code);\\r\\n \\r\\n # Keep going until right bracket\\r\\n j = 0;\\r\\n while not \\\")\\\" in Code[j]: j += 1;\\r\\n \\r\\n # Go back for left bracket.\\r\\n i = j-1;\\r\\n while not \\\"(\\\" in Code[i] or i < 0: i -= 1;\\r\\n \\r\\n if i < 0: raise Exception(\\\"improper use of brackets.\\\");\\r\\n \\r\\n Code = Code[:i] + [ computeList(Code[i+1:j]) ] + Code[j+1:];\\r\\n \\r\\n return computeList(Code);\",\n \"def complex(real, imag):\",\n \"def theta(conc, S, educts):\\n\\n educts_per_reaction = educts.T\\n\\n # in every reaction j row, element at pos (column, species) i equals conc_i^educt_{ij}\\n # educt_{ij} - how many units of i are educts in reaction j\\n multiplicative_term_rows = np.power(conc, educts_per_reaction)\\n\\n # concentrations to educt product ----> product_{i=1}^{n_s}(conc_i^{educt_{ij}}\\n concentration_product = np.prod(multiplicative_term_rows, axis=1)\\n\\n # returns one row with #reactions elements -> fluxes\\n return concentration_product * S\",\n \"def number_of_extensions(M, root=None):\\n\\n sp_order_formula = [i for i in M.series_partial_order_representation(root) if\\n (i.__contains__('series') or i.__contains__('parallel'))]\\n\\n while sp_order_formula:\\n\\n # Extend the children of the current operator\\n operator = sp_order_formula.pop()\\n left, right = M.tree.successors(operator)\\n\\n for child in [left, right]:\\n\\n # Recursion if the child is a operator (also known as a sub-tree in Binary Construction Tree).\\n if M.tree.node[child]['num_extension'] == 0:\\n if child.__contains__('series') or child.__contains__('parallel'):\\n M.tree.node[child]['num_extension'] = number_of_extensions(M, child)\\n else:\\n M.tree.node[child]['num_extension'] = 1\\n\\n # Employ the property of series-parallel partial order to calculate the number of extension\\n if operator.__contains__('series'):\\n num_extension = (M.tree.node[left]['num_extension']) * (M.tree.node[right]['num_extension'])\\n M.tree.node[operator]['num_extension'] = num_extension\\n\\n if operator.__contains__('parallel'):\\n # n1, n2 is the number of events (labels) on a partial order, we need to store the previous result.\\n n1 = len([i for i in M.series_partial_order_representation(left) if\\n not (i.__contains__('series') or i.__contains__('parallel'))])\\n n2 = len([i for i in M.series_partial_order_representation(right) if\\n not (i.__contains__('series') or i.__contains__('parallel'))])\\n\\n num_extension = (math.factorial(n1 + n2) / (math.factorial(n1) * (math.factorial(n2)))) * (\\n M.tree.node[left]['num_extension']) * (M.tree.node[right]['num_extension'])\\n\\n M.tree.node[operator]['num_extension'] = num_extension\\n #\\n # # When series structure\\n # if operator.__contains__('series') or operator.__contains__('parallel'):\\n # try:\\n # # Employ the property of series-parallel partial order to calculate the number of extension\\n # if operator.__contains__('series'):\\n # num_extension = (M.tree.node[left]['num_extension']) * (M.tree.node[right]['num_extension'])\\n # M.tree.node[operator]['num_extension'] = num_extension\\n #\\n # if operator.__contains__('parallel'):\\n # # n1, n2 is the number of events (labels) on a partial order, we need to store the previous result.\\n # n1 = len(M.series_partial_order_representation(left))\\n # n2 = len(M.series_partial_order_representation(right))\\n #\\n # num_extension = (math.factorial(n1 + n2) / (math.factorial(n1) * (math.factorial(n2)))) * (\\n # M.tree.node[left]['num_extension']) * (M.tree.node[right]['num_extension'])\\n #\\n # M.tree.node[operator]['num_extension'] = num_extension\\n #\\n # print \\\"{}:{}\\\".format(operator, num_extension)\\n # sp_order_formula.append(operator)\\n # except Exception:\\n # raise Exception\\n #\\n # # When parallel structure\\n # else:\\n # if len(temp_stack) > 0:\\n # temp_left = temp_stack.pop()\\n #\\n # # When they share the same parent then push the temp_left to sp_order_formula\\n # if M.tree.predecessors(temp_left)[0] == M.tree.predecessors(left)[0]:\\n # sp_order_formula.append(operator)\\n # sp_order_formula.append(right)\\n # sp_order_formula.append(left)\\n # sp_order_formula.append(temp_left)\\n # # otherwise, keep pushing the new operator(parent) to temp_stack\\n # else:\\n # temp_stack.append(left)\\n # sp_order_formula.append(operator)\\n # sp_order_formula.append(right)\\n #\\n # result = sp_order_formula.pop()\\n return M.tree.node[root]['num_extension']\",\n \"def complex_value(self) -> global___Expression.ComplexValue:\",\n \"def get_contributions(codings, sorted_factors):\\n if codings:\\n formulae = []\\n for prod_of_factors in codings:\\n cur_formula = I\\n for n, c in codings[prod_of_factors]:\\n if c == 'indicator':\\n cur_formula = cur_formula * sorted_factors[n].formula\\n else:\\n cur_formula = cur_formula * sorted_factors[n].drop_first\\n formulae.append((cur_formula, ':'.join(prod_of_factors)))\\n else:\\n formulae = [(Formula([1]),'1')]\\n return formulae\",\n \"def solve_part1(input, verbose=False):\\n equations = parse(input)\\n\\n result = []\\n for eq in equations:\\n result.append(solve_equation_same_precedence(eq, verbose))\\n\\n if verbose:\\n print(f\\\"results: {result}\\\")\\n\\n return sum(result)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.79503584","0.58502394","0.5840956","0.5799161","0.57101554","0.569104","0.56670165","0.55476683","0.54750997","0.544209","0.53206456","0.5311971","0.5299383","0.5250163","0.51982045","0.51967955","0.51698494","0.5137146","0.50471324","0.50033426","0.49329937","0.49004316","0.48654592","0.48601094","0.48238572","0.48012418","0.4754823","0.47547796","0.4743248","0.47121105","0.47078234","0.4702022","0.4697557","0.4696608","0.46909478","0.46797","0.46602824","0.4657357","0.46516857","0.46408752","0.4637249","0.46331063","0.46317464","0.4614736","0.46101165","0.46059644","0.46044236","0.4595421","0.4590876","0.45885912","0.45876238","0.45836395","0.45830646","0.45805165","0.4567208","0.45621842","0.45621333","0.45573825","0.45490426","0.4541108","0.45366964","0.45347673","0.4534677","0.45336044","0.4531057","0.45309442","0.45295677","0.45278174","0.4522221","0.4516021","0.45112547","0.44941744","0.44939193","0.44938508","0.44900665","0.44882357","0.44847864","0.44843003","0.44770375","0.44764385","0.4474233","0.4474028","0.4473557","0.44727746","0.44727725","0.446245","0.44614175","0.44572163","0.44548512","0.44513315","0.44505763","0.4447418","0.4447154","0.44462883","0.44452775","0.44429868","0.44429246","0.44421282","0.44319916","0.44214827"],"string":"[\n \"0.79503584\",\n \"0.58502394\",\n \"0.5840956\",\n \"0.5799161\",\n \"0.57101554\",\n \"0.569104\",\n \"0.56670165\",\n \"0.55476683\",\n \"0.54750997\",\n \"0.544209\",\n \"0.53206456\",\n \"0.5311971\",\n \"0.5299383\",\n \"0.5250163\",\n \"0.51982045\",\n \"0.51967955\",\n \"0.51698494\",\n \"0.5137146\",\n \"0.50471324\",\n \"0.50033426\",\n \"0.49329937\",\n \"0.49004316\",\n \"0.48654592\",\n \"0.48601094\",\n \"0.48238572\",\n \"0.48012418\",\n \"0.4754823\",\n \"0.47547796\",\n \"0.4743248\",\n \"0.47121105\",\n \"0.47078234\",\n \"0.4702022\",\n \"0.4697557\",\n \"0.4696608\",\n \"0.46909478\",\n \"0.46797\",\n \"0.46602824\",\n \"0.4657357\",\n \"0.46516857\",\n \"0.46408752\",\n \"0.4637249\",\n \"0.46331063\",\n \"0.46317464\",\n \"0.4614736\",\n \"0.46101165\",\n \"0.46059644\",\n \"0.46044236\",\n \"0.4595421\",\n \"0.4590876\",\n \"0.45885912\",\n \"0.45876238\",\n \"0.45836395\",\n \"0.45830646\",\n \"0.45805165\",\n \"0.4567208\",\n \"0.45621842\",\n \"0.45621333\",\n \"0.45573825\",\n \"0.45490426\",\n \"0.4541108\",\n \"0.45366964\",\n \"0.45347673\",\n \"0.4534677\",\n \"0.45336044\",\n \"0.4531057\",\n \"0.45309442\",\n \"0.45295677\",\n \"0.45278174\",\n \"0.4522221\",\n \"0.4516021\",\n \"0.45112547\",\n \"0.44941744\",\n \"0.44939193\",\n \"0.44938508\",\n \"0.44900665\",\n \"0.44882357\",\n \"0.44847864\",\n \"0.44843003\",\n \"0.44770375\",\n \"0.44764385\",\n \"0.4474233\",\n \"0.4474028\",\n \"0.4473557\",\n \"0.44727746\",\n \"0.44727725\",\n \"0.446245\",\n \"0.44614175\",\n \"0.44572163\",\n \"0.44548512\",\n \"0.44513315\",\n \"0.44505763\",\n \"0.4447418\",\n \"0.4447154\",\n \"0.44462883\",\n \"0.44452775\",\n \"0.44429868\",\n \"0.44429246\",\n \"0.44421282\",\n \"0.44319916\",\n \"0.44214827\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7616813"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":79093,"cells":{"query":{"kind":"string","value":"Returns the term's string with intervals."},"document":{"kind":"string","value":"def _create_formatted_string_with_interval(self):\n if isinstance(self.get_subject_term(),StatementTerm) or isinstance(self.get_subject_term(),CompoundTerm):\n string = NALSyntax.StatementSyntax.Start.value + \\\n self.get_subject_term().get_formatted_string_with_interval()\n else:\n string = NALSyntax.StatementSyntax.Start.value + \\\n self.get_subject_term().get_formatted_string()\n\n if not self.is_first_order() and self.interval > 0:\n string = string[:-1] + \\\n NALSyntax.StatementSyntax.TermDivider.value + \\\n str(self.interval) + \\\n string[-1]\n\n string += \" \" + self.get_copula_string() + \" \"\n\n string += self.get_predicate_term().get_formatted_string() + \\\n NALSyntax.StatementSyntax.End.value\n\n return string"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __str__(self):\n value = []\n for term in self.terms:\n value += [term.termname]\n return '<formula: %s>' % ' + '.join(value)","def __str__(self):\n value = []\n for term in self.terms:\n value += [term.termname]\n return '<formula: %s>' % ' + '.join(value)","def __str__(self) -> str:\n\n return str(tstack([self._domain, self._range]))","def __repr__(self):\n s = \"{}, {}\".format(self.left_endpoint, self.right_endpoint)\n if self.left_closed:\n left_bracket = '['\n else:\n left_bracket = '('\n\n if self.right_closed:\n right_bracket = ']'\n else:\n right_bracket = ')'\n interval_string = left_bracket + s + right_bracket\n return 'Interval({})'.format(interval_string)","def interval_substitution(self):\n return self.right_composition(self._parent.edge_to_interval_substitution)","def __str__(self):\n return INTERVALS[self.semitone_interval]","def format_term(term: Union[BNode, Literal, URIRef, Variable]) -> str:\n if isinstance(term, URIRef):\n return str(term)\n elif isinstance(term, BNode):\n return '?v_' + str(term)\n elif isinstance(term, Literal):\n return format_literal(term)\n else:\n return term.n3()","def __repr__(self):\n if isinstance(self.begin, Number):\n s_begin = str(self.begin)\n s_end = str(self.end)\n else:\n s_begin = repr(self.begin)\n s_end = repr(self.end)\n if self.data is None:\n return \"Interval({0}, {1})\".format(s_begin, s_end)\n else:\n return \"Interval({0}, {1}, {2})\".format(s_begin, s_end, repr(self.data))","def getComboTerms(tuples):\t\t\t\n\t\t\t#return \"[{0}]\".format('; '.join([\"({0})\".format(','.join([text[indices[0]:indices[1]], str(indices[0])])) for indices in tuples]))\n\t\t\treturn \"{0}\".format('; '.join((\"{0}\".format(text[indices[0]:indices[1]]) for indices in tuples)))","def _create_formatted_string(self):\n string = NALSyntax.StatementSyntax.Start.value + \\\n self.get_subject_term().get_formatted_string()\n\n string += \" \" + self.get_copula_string() + \" \"\n\n string += self.get_predicate_term().get_formatted_string() + \\\n NALSyntax.StatementSyntax.End.value\n\n return string","def text(self) -> str:\n text = []\n\n if self.min is not None:\n text.append(str(self.min))\n if self.include_min:\n text.append(\"<=\")\n else:\n text.append(\"<\")\n\n if self.min is not None or self.max is not None:\n text.append(\"value\")\n\n if self.max is not None:\n if self.include_max:\n text.append(\"<=\")\n else:\n text.append(\"<\")\n text.append(str(self.max))\n\n if self.step is not None:\n if self.min is not None or self.max is not None:\n text.append(\"and\")\n text.extend([\"value %\", str(self.step), \"==\"])\n if self.min is None:\n text.append(\"0\")\n else:\n text.append(str(self.min % self.step))\n\n return \" \".join(text)","def __repr__(self):\n\n return \"<Terms term=%s>\" % (self.word)","def expand_range(txt, range_operator='~'):\n if range_operator not in txt:\n return txt\n\n result = []\n index_pattern = r'(\\D*)(\\d+)'\n pair = txt.split(range_operator)\n result.append(pair[0])\n\n # Find start/end points\n match1 = re.search(index_pattern, pair[0])\n match2 = re.search(index_pattern, pair[1])\n start = int(match1.group(2))\n end = int(match2.group(2))\n label = match1.group(1) if match1.group(1) != match1.group(2) else ''\n result.extend([str(label) + str(i) for i in range(start + 1, end + 1)])\n return result","def __str__(self):\n termStrings = []\n for term in self.LHS:\n coefficient = term[0]\n unknownSet = term[1]\n\n termString = str(coefficient) + ' * '\n unknownStrings = []\n for unknown in unknownSet:\n unknownString = unknown[0].__class__.__name__ + '@' + str(id(unknown[0]))[-4:] + '.' + unknown[1] # last 4 digits of variable ID . attribute name\n unknownStrings.append(unknownString)\n termString += str.join(' * ', unknownStrings)\n termStrings.append(termString)\n\n termStrings = str.join(' + ', termStrings)\n return termStrings + ' = ' + str(self.RHS)","def __str__(self):\n return \"%s %d\" % (dict(self.TERM_CHOICES)[self.term], self.year)","def __str__( self ) :\n\n return( ' '.join( [ \"%g\" % c_l for c_l in self.coefficients ] ) )","def __getitem__(self, interval):\n l = [s for i, s in self.timesteps if i == interval]\n if len(l) == 1:\n return l[0]\n\n return ''","def format_subrange(start, end, step):\n \n if start == end:\n return str(start)\n elif step == 1:\n return \"%d-%d\" % (start, end)\n else:\n return \"%d-%dx%d\" % (start, end, step)","def __str__(self):\n lstr = \"\"\n\n # String for x term\n if self.a != 0:\n if self.a == 1:\n lstr += \"x\"\n elif self.a == -1:\n lstr += \"-x\"\n else:\n lstr += str(self.a) + \"x\"\n\n # String for y term\n if lstr != \"\": # This means that the x-coefficient is not 0\n if self.b > 0:\n if self.b == 1:\n lstr += \" + y\"\n else:\n lstr += \" + \" + str(abs(self.b)) + \"y\"\n elif self.b < 0:\n if self.b == -1:\n lstr += \" - y\"\n else:\n lstr += \" - \" + str(abs(self.b)) + \"y\"\n else:\n if self.b == 1:\n lstr += \"y\"\n elif self.b == -1:\n lstr += \"-y\"\n else:\n lstr += str(self.b) + \"y\"\n\n # String for constant term\n lstr += \" = \" + str(self.c)\n\n return lstr","def substitute(self):\n\n n_chars = len(self.literal)\n term = ['' for i in range(n_chars)]\n\n for i in range(n_chars):\n if self.literal[i] in self.bindings:\n term[i] = self.bindings[self.literal[i]]\n else:\n term[i] = self.literal[i]\n\n return (''.join(term))","def to_string(self) -> str:\n template = '(' if self.left_boundary['open'] else '['\n template += '{},{}'\n template += ')' if self.right_boundary['open'] else ']'\n return template.format(\n self.left_boundary['value'],\n self.right_boundary['value']\n )","def __str__(self):\n\t\treturn \"{min} ~ {max}\".format(min=str(self.min), max=str(self.max))","def get_str(nr_rational):\n return f'{get_numarator(nr_rational)} / {get_numitor(nr_rational)}'","def __str__(self):\n\n return \"%s:\\n%s\" % (self.name, self.top_terms_tuples(25))","def _repr_(self):\n ending = \"\"\n if str(self.t)!='t':\n ending = ' with t=%s'%(self.t)\n return \"%s-Bounded Quotient of Symmetric Functions over %s\"%(self.k, self.base_ring())+ending","def get_basis(n):\n\treturn ' '.join('e{}'.format(i) for i in range(n))","def irchain_str(self):\n s = []\n if self.irlen_before:\n s.append('%d' % self.irlen_before)\n s.append('(%d)' % self.irlen)\n if self.irlen_after:\n s.append('%d' % self.irlen_after)\n return ','.join(s)","def __str__(self):\n\n # This appears at the end of the fed method line\n strme = \"{} {} {} {}\"\\\n .format(self.n_itr, self.i_beg, self.i_end, self.omega)\n\n return strme","def _term_name(self):\n \n year = self.term[0:3]\n season = self.term[4:]\n if season == self.TERMNUM[1]:\n result = \"{}{}\".format(year, self.TERM[0])\n \n elif season == self.TERMNUM[2]:\n result = \"{}{}\".format(year, self.TERM[1])\n \n else:\n result = \"{}{}\".format(year, self.TERM[2])\n \n return result","def _repr_term(self, c):\n return self.prefix()+str(c)","def __str__(self):\n s = \"\"\n for i in self.__buckets:\n temp =\"\"\n while len(temp) + len(str(self.__buckets.index(i))) < 5:\n temp += \"_\" \n s += \"[{}{}]{}\\n\".format(temp, self.__buckets.index(i), str(i))\n return s","def _range_expression(self):\n # using filter expression to define the time range of the query\n # In influx2, range query is in the format\n # range(start:2018-05-22T23:30:00Z, stop: 2018-05-23T00:00:00Z) or\n # range(start: -12h, stop: -15m)\n # with stop parameter being optional\n if self.filter is None:\n return u''\n exp = (self._sql_where_expression(self.filter)).replace('AND',',').split(',')\n return u'|> range({})'.format(u' , '.join([(i.replace('\"','').replace(\"'\",'')) for i in exp if \"start\" in i or \"stop\" in i]))","def __repr__(self):\n s = \"{}, {}\".format(self.left_endpoint, self.right_endpoint)\n if self.left_closed:\n left_bracket = '['\n else:\n left_bracket = '('\n\n if self.right_closed:\n right_bracket = ']'\n else:\n right_bracket = ')'\n interval_string = left_bracket + s + right_bracket\n return 'TreeNode({})'.format(interval_string)","def term_to_tsquery_string(term):\n\n def cleanup(word, whitelist_chars=',.-_'):\n result = ''.join(\n (c for c in word if c.isalnum() or c in whitelist_chars)\n )\n return f'{result}:*' if word.endswith('*') else result\n\n parts = (cleanup(part) for part in (term or '').split())\n return ' <-> '.join(tuple(part for part in parts if part))","def __str__(self):\r\n return '[t1=%.1fs, t2=%.1fs, tmax=%.1fs, Lmax=%.1fs]' % (self.t1, self.t2, self.tmax, self.Lmax)","def __str__(self):\n [r,c],f = self.D, self.F\n lmax = len(str(max(iter(self)))) + 1\n s = '\\n'.join( (' '.join('{0:{l}G}'.format(f(i,j),l=lmax) if isinstance(f(i,j), int) or isinstance(f(i,j), float) else str(f(i,j)) for j in range(c))) for i in range(r))\n return s","def substitute_with_bindings(self,bindings):\n\n n_chars = len(self.literal)\n term = ['' for i in range(n_chars)]\n\n for i in range(n_chars):\n if self.literal[i] in bindings:\n term[i] = bindings[self.literal[i]]\n else:\n term[i] = self.literal[i]\n\n return (''.join(term))","def make_range(_num_list):\n if len(_num_list) == 1:\n out_str = str(_num_list[0])\n\n elif len(_num_list) == 2:\n out_str = str(_num_list[0]) + ', ' + str(_num_list[1])\n\n else:\n out_str = str(_num_list[0]) + '-' + str(_num_list[-1])\n\n return out_str","def srt(self):\n return '{} --> {}\\n{}\\n'.format(self.start.srt(), self.end.srt(), self.word)","def range(self) -> str:\n return f\"{self.name}!A:F\"","def __str__(self) -> str:\n mapping_str = ', '.join(\n f'{variable!s} -> {term!s}'\n for (variable, term) in self.mapping.items()\n )\n return f'{{{mapping_str}}}'","def __str__(self):\n return f\"Era '{self.text}' starting at {self.start}, ending at {self.end}\"","def __str__(self):\n\t\tself.__normalize()\n\t\tmyStr ='# min = %lf\\n'%(float(self._min))\n\t\tmyStr+='# max = %lf\\n'%(float(self._max))\n\t\tmyStr+='# dx = %lf\\n'%(float(self._dx))\n\t\tmyStr+='# av = %lf (sErr = %lf)\\n'%(self.av,self.sErr)\n\t\tmyStr+='# sDev = %lf\\n'%(self.sDev)\n\t\tmyStr+='# xLow xHigh p(xLow <= x < xHigh) Gaussian_error\\n'\n\t\tfor bin in range(self._nBins): \n\t\t\tlow,up=self.__bdry(bin)\n\t\t\tmyStr+='%lf %lf %lf %lf\\n'%(low,up,self._norm[bin], self.__GErr(bin))\n\t\treturn myStr","def _repr_latex_(self):\n reprlatex = \"\"\n if not self._terms:\n reprlatex += \"0\"\n else:\n for term in self:\n termlatex = term._reprlatex\n if not reprlatex:\n # Adding the first term. No leading +.\n reprlatex += termlatex\n else:\n if not termlatex.startswith(\"-\"):\n # Is it the first term added to the sum? No leading +.\n reprlatex += f\"+ {termlatex}\"\n else:\n reprlatex += termlatex\n\n return f\"${reprlatex}$\"","def get_temprange_stringlist(self):\n return text_temprange","def __str__(self):\n return \"(%s)\" % ' '.join(map(str, self.__subrules))","def __str__(self):\n\n rep = 'Generalized Syllogism:\\n'\n rep += '\\ttask: {}\\n'.format(self.task)\n rep += '\\tencoded_task: {}\\n'.format(self.encoded_task)\n rep += '\\tp1: {}\\n'.format(self.p1)\n rep += '\\tp2: {}\\n'.format(self.p2)\n rep += '\\tquantifier_p1: {}\\n'.format(self.quantifier_p1)\n rep += '\\tquantifier_p2: {}\\n'.format(self.quantifier_p2)\n rep += '\\tfigure: {}\\n'.format(self.figure)\n rep += '\\tTerms:\\n'\n rep += '\\t\\tA: {}\\n'.format(self.A)\n rep += '\\t\\tB: {}\\n'.format(self.B)\n rep += '\\t\\tC: {}\\n'.format(self.C)\n return rep","def get_string(self):\n return (self.loop_level+1) * ' ' + ','.join(map(str, self.get_list()))","def generate_cut_strings(var, bin_edges, bottom_inclusive=True):\n incl = '=' if bottom_inclusive else ''\n return ['{var} >{incl} {low:g} && {var} < {high:g}'.format(var=var, low=bin_low,\n high=bin_high, incl=incl)\n for (bin_low, bin_high) in bin_edges]","def _get_term(self):\n return self.__term","def _get_term(self):\n return self.__term","def _get_term(self):\n return self.__term","def _get_term(self):\n return self.__term","def _get_term(self):\n return self.__term","def _get_term(self):\n return self.__term","def _get_term(self):\n return self.__term","def _get_term(self):\n return self.__term","def _get_term(self):\n return self.__term","def __str__(self):\n string = ''\n for degree, coef in enumerate(self.coefs, 1):\n degree = degree - 1\n string += str(coef)+'x^' + str(degree) + ' + '\n string = string[0:-3] # remove the last ' + '\n return string","def str2(self):\n signs = [ ('+' if f >= 0 else '-') for f in self.mVector ]\n vals = [ abs(f) for f in self.mVector ]\n\n return '%s %s %si %s %sj %s %sk' % (self.mScalar, \n signs[0],\n vals[0],\n signs[1],\n vals[1],\n signs[2],\n vals[2])","def _build_range(self) -> str:\n return build_sequence(filter(None, (self.uids, self.sequence)))","def to_right_boundary(self) -> str:\n return '{}{}'.format(self.value, ']' if self.is_closed else ')')","def __repr__(self):\n return str(self.start) + ' \\t' + str(self.end)","def Rstr(self):\n\n results = []\n for expr in self.graded_dict:\n _expr = str(expr).replace(\"*\", \":\")\n if _expr != '1':\n for order in self.graded_dict[expr]:\n for factors in self.graded_dict[expr][order]:\n results.append(':'.join([_expr] + [f.name for f in factors]))\n else:\n for order in self.graded_dict[expr]:\n for factors in self.graded_dict[expr][order]:\n if factors:\n results.append(':'.join([f.name for f in factors]))\n else:\n results.append('1')\n return \"+\".join(results)","def t_STR_LITER(t):\n return t","def region_str(self):\n return \"%s:%s-%s\" % (self.seqid, self.start, self.end)","def range_collapse(begin, end, algorithm='chicago'):\n if algorithm == 'chicago':\n if begin > 100 and mod(begin, 100) and idiv(begin, 100) == idiv(end, 100):\n return(str(begin) + '–' + str(mod(end, 100)))\n elif begin >= 10000:\n return(str(begin) + '–' + str(mod(end, 1000)))\n else:\n return(str(begin) + '–' + str(end))","def r_style_interval(from_tuple, end_tuple, frequency):\n from_year, from_seg = from_tuple\n end_year, end_seg = end_tuple\n n = (end_year - from_year + 1) * frequency\n full_range = np.linspace(from_year, end_year + 1, num=n, endpoint=False)\n real_range = full_range[(from_seg - 1):n - (frequency - end_seg)]\n return real_range","def label(self):\r\n if isinstance(self.Lbeta, str):\r\n result = self.Lbeta\r\n else:\r\n result = 'T%.2d' % int(round(self.Lbeta))\r\n result += 'E%.2d' % int(round(self.E))\r\n result += 'G%.2d' % int(round(self.minTauG))\r\n result += self.insulation\r\n return result","def intervals(parser, token ):\n try:\n tag_name, arg = token.contents.split(None, 1)\n except ValueError:\n raise template.TemplateSyntaxError, \"%r needs arguments\" % token.contents.split()[0]\n m = re.search(r'(.+) as (.+)', arg)\n if not m:\n raise template.TemplateSyntaxError, \"You need to specify 'as' variable \"\n arguments, asname = m.groups()\n if not '=' in arguments:\n return intervals_args(parser, token )\n return IntervalNode( arguments, asname )","def range_to_label(arange):\r\n # pass\r\n C = arange.size - 1\r\n label = np.ones((arange[-1], ), dtype=np.int)\r\n for i in xrange(1, C):\r\n label[arange[i]: arange[i+1]] *= (i+1)\r\n return label","def __str__(self):\n \n return '{{ {:.5g} {:.5g} {:.5g}; {:.5g} {:.5g} {:.5g}}}'.format(*list(self.vec))","def buildString( lsys, iter ):\n\tnstring = getBase(lsys)\n\trule = getRule(lsys, 0)\n\tsymbol = rule[0]\n\treplacement = rule[1]\n\tfor i in range(iter):\n\t\tnstring = nstring.replace( symbol, replacement )\n\treturn nstring","def __str__(self):\n\t\tif self.code == Const.NEWLINE:\n\t\t\treturn \"[newline]\"\n\t\t\n\t\tname = \"[\" + self.code\n\t\tif self.code in (Const.numericalLiteral, Const.ID, Const.UET):\n\t\t\tname += \"(\" + self.value + \")\"\n\t\tname += \"]\"\n\t\treturn name","def interval(entry):\n string = entry.lower()\n number1 = ''\n number2 = ''\n second = False\n for c in entry:\n if c.isdigit() or c == '.':\n if second == False:\n number1 += c\n else:\n number2 += c\n elif not c.isdigit() and len(number1) > 0:\n second = True\n if number1 and number2:\n leftover = re.sub(number1, '', string).strip().replace(\" \", \"\")\n leftover = re.sub(number2, '', leftover).strip().replace(\" \", \"\")\n numbers = (number1, number2)\n if leftover:\n op = leftover\n else:\n op = None\n\n if op:\n if op == '--':\n ops = (OPERATORS['>='], OPERATORS['<='])\n else:\n ops = (OPERATORS['>'], OPERATORS['<'])\n return ops, numbers\n return (None, None), (None, None)","def return_string(self):\n\n if self.__numerator * self.__denominator < 0:\n sign = \"-\"\n else:\n sign = \"\"\n return \"{:s}{:d}/{:d}\".format(sign, abs(self.__numerator), abs(self.__denominator))","def format_substitutions(subs: Union[SubstituteTerm, List[SubstituteTerm]]):\n text = \"\"\n if isinstance(subs, SubstituteTerm):\n term_str = str(subs)\n for line in term_str.split('\\n'):\n text += Markup.escape(line) + Markup('<br />')\n text += Markup('<br />')\n return text\n for term in subs:\n term_str = str(term)\n for line in term_str.split('\\n'):\n text += Markup.escape(line) + Markup('<br />')\n text += Markup('<br />')\n return text","def __str__(self):\n self.vals.sort()\n result = ''\n for e in self.vals:\n result = result + str(e) + ','\n return '{' + result[:-1] + '}'","def __repr__(self):\n return f\"Era '{self.text}' starting at {self.start}, ending at {self.end}\"","def __str__(self):\n # special cases\n if self.is_nan() :\n return \"nan\"\n elif self.coeff == 1 :\n if self.expt == 1 :\n return \"x\"\n else :\n return \"x^\" + str(self.expt)\n elif self.coeff == -1 :\n if self.expt == 1 :\n return \"-x\"\n else :\n return \"-x^\" + str(self.expt)\n \n # str_builder\n if self.expt == 0 :\n if self.coeff.denominator == 1 :\n return str(self.coeff.nominator)\n else :\n return \"{}/{}\".format(str(self.coeff.nominator), str(self.coeff.denominator))\n elif self.expt == 1 :\n if self.coeff.denominator == 1 :\n return str(self.coeff.nominator) + \"*x\"\n else :\n return \"{}/{}\".format(str(self.coeff.nominator), str(self.coeff.denominator)) + \"*x\"\n else :\n if self.coeff.denominator == 1 :\n return str(self.coeff.nominator) + \"*x^\" + str(self.expt)\n else :\n return \"{}/{}\".format(str(self.coeff.nominator), str(self.coeff.denominator)) + \"*x^\" + str(self.expt)","def get_completion_terms(self):\n return # osid.search.terms.DecimalRangeTerm","def getConstantSentenceForms(self):","def between(minl:int, maxl:int) -> str:\n return f\"{{{minl},{maxl}}}\"","def __str__(self):\n if not self.has_converged or self.parameters is None:\n log.warning(\"The fit has not converged. Try again!\")\n return ''\n\n result = []\n for parameter in self.parameters.keys():\n if parameter in self.fit_for:\n parameter_string = self.get_parameter_string(parameter)\n if parameter_string is not None:\n result.append(parameter_string)\n\n rms = self.get_parameter_format('kelvin') % self.rms\n result.append(f\"[{rms} K rms]\")\n return '\\n'.join(result)","def getUniStr(self):\n return(\"%s.%s.%s-%s\"%(self.getPrefix,self.getSentenceId,\n self.offset_bgn,self.offset_end))","def __str__(self) -> str:\n out = ''\n for i in range(self.buckets.length()):\n list = self.buckets.get_at_index(i)\n out += str(i) + ': ' + str(list) + '\\n'\n return out","def __str__(self):\n # on trie la liste de valeurs par ordre croissant\n self.vals.sort()\n return '{' + ','.join([str(e) for e in self.vals]) + '}'","def __str__(self):\n template = ('Bounds: minx={f}, miny={f}, minz={f}\\n '\n 'maxx={f}, maxy={f}, maxz={f}'.format(f=self._format))\n # Formatter must be recreated each time to reset value counter\n return NoneFormatter().format(template, *self)","def __str__(self):\n return f\"min={self.min} max={self.max}\"","def base40_to_interval_name(base40):\n direction = '-' if base40 < 0 else '+'\n octave, interval = divmod(abs(base40), 40)\n names = [\n 'P1', 'A1', None, None,\n 'd2', 'm2', 'M2', 'A2', None, None,\n 'd3', 'm3', 'M3', 'A3', None, None,\n 'd4', 'P4', 'A4', None, None, None,\n 'd5', 'P5', 'A5', None, None,\n 'd6', 'm6', 'M6', 'A6', None, None,\n 'd7', 'm7', 'M7', 'A7', None, None,\n 'd8', 'P8',\n ]\n name = names[interval]\n if octave:\n name = name.replace(name[1], str(octave * 8 + int(name[1]) - 1))\n return ''.join([direction, name])","def getLatexIntervalFromNll( self, minX, up=0.5, xRange=None, steps=1000, digits=2 ):\n \n mInterval = self.getFirstIntersectionsWithValue( up, xCenter=minX, xRange=xRange, steps=steps )\n fF = \"%.\"+str(digits)+\"f\" # float Format\n return ( (fF+\"^{+\"+fF+\"}_{\"+fF+\"}\") % (minX,mInterval[1]-minX,mInterval[0]-minX) )","def sr(self):\n return ''.join([str(seg) for seg in self.segments])","def __str__(self):\n # TODO check the terminal width and adjust the presentation\n # only use for 1D, fall back to repr for ND\n if self._hist.rank() == 1:\n s = str(self._hist)\n # get rid of first line and last character\n s = s[s.index(\"\\n\") + 1 : -1]\n else:\n s = repr(self)\n return s","def table(self, L, R, n):\n s = \"\"\n import numpy as np\n for x in np.linspace(L, R, n):\n y = self(x)\n s += \"%12g %12g\\n\" %(x,y)\n return s","def valueToString():","def __str__(self):\n string = ''\n\n # gets the nodes at each level and puts the values into a string\n for i in range(self.get_height()+1):\n nodes = self.get_nodes_on_level(i)\n level = [str(node.value) if node else '-' for node in nodes]\n string += '{}\\n'.format(' '.join(level))\n\n return string","def table(self, L, R, n):\n s = \"\"\n for x in np.linspace(L, R, n):\n y = self(x)\n s += \"%12g %12g\\n\" % (x, y)\n return s","def getUniStr(self):\n return('-'.join([\"%s-%s\"%(x.id,(x.id in self.special))\n for x in self.getNested()]))","def __repr__( self ):\r\n\t\treturn ( \"%s/%s\" % ( self.numerator, self.denominator ) )","def sInterval(self, val):\n\n # NB: the support attribute has been added by precomputing __levels__\n if val in self.support:\n return self.support[val]\n else:\n return ()"],"string":"[\n \"def __str__(self):\\n value = []\\n for term in self.terms:\\n value += [term.termname]\\n return '<formula: %s>' % ' + '.join(value)\",\n \"def __str__(self):\\n value = []\\n for term in self.terms:\\n value += [term.termname]\\n return '<formula: %s>' % ' + '.join(value)\",\n \"def __str__(self) -> str:\\n\\n return str(tstack([self._domain, self._range]))\",\n \"def __repr__(self):\\n s = \\\"{}, {}\\\".format(self.left_endpoint, self.right_endpoint)\\n if self.left_closed:\\n left_bracket = '['\\n else:\\n left_bracket = '('\\n\\n if self.right_closed:\\n right_bracket = ']'\\n else:\\n right_bracket = ')'\\n interval_string = left_bracket + s + right_bracket\\n return 'Interval({})'.format(interval_string)\",\n \"def interval_substitution(self):\\n return self.right_composition(self._parent.edge_to_interval_substitution)\",\n \"def __str__(self):\\n return INTERVALS[self.semitone_interval]\",\n \"def format_term(term: Union[BNode, Literal, URIRef, Variable]) -> str:\\n if isinstance(term, URIRef):\\n return str(term)\\n elif isinstance(term, BNode):\\n return '?v_' + str(term)\\n elif isinstance(term, Literal):\\n return format_literal(term)\\n else:\\n return term.n3()\",\n \"def __repr__(self):\\n if isinstance(self.begin, Number):\\n s_begin = str(self.begin)\\n s_end = str(self.end)\\n else:\\n s_begin = repr(self.begin)\\n s_end = repr(self.end)\\n if self.data is None:\\n return \\\"Interval({0}, {1})\\\".format(s_begin, s_end)\\n else:\\n return \\\"Interval({0}, {1}, {2})\\\".format(s_begin, s_end, repr(self.data))\",\n \"def getComboTerms(tuples):\\t\\t\\t\\n\\t\\t\\t#return \\\"[{0}]\\\".format('; '.join([\\\"({0})\\\".format(','.join([text[indices[0]:indices[1]], str(indices[0])])) for indices in tuples]))\\n\\t\\t\\treturn \\\"{0}\\\".format('; '.join((\\\"{0}\\\".format(text[indices[0]:indices[1]]) for indices in tuples)))\",\n \"def _create_formatted_string(self):\\n string = NALSyntax.StatementSyntax.Start.value + \\\\\\n self.get_subject_term().get_formatted_string()\\n\\n string += \\\" \\\" + self.get_copula_string() + \\\" \\\"\\n\\n string += self.get_predicate_term().get_formatted_string() + \\\\\\n NALSyntax.StatementSyntax.End.value\\n\\n return string\",\n \"def text(self) -> str:\\n text = []\\n\\n if self.min is not None:\\n text.append(str(self.min))\\n if self.include_min:\\n text.append(\\\"<=\\\")\\n else:\\n text.append(\\\"<\\\")\\n\\n if self.min is not None or self.max is not None:\\n text.append(\\\"value\\\")\\n\\n if self.max is not None:\\n if self.include_max:\\n text.append(\\\"<=\\\")\\n else:\\n text.append(\\\"<\\\")\\n text.append(str(self.max))\\n\\n if self.step is not None:\\n if self.min is not None or self.max is not None:\\n text.append(\\\"and\\\")\\n text.extend([\\\"value %\\\", str(self.step), \\\"==\\\"])\\n if self.min is None:\\n text.append(\\\"0\\\")\\n else:\\n text.append(str(self.min % self.step))\\n\\n return \\\" \\\".join(text)\",\n \"def __repr__(self):\\n\\n return \\\"<Terms term=%s>\\\" % (self.word)\",\n \"def expand_range(txt, range_operator='~'):\\n if range_operator not in txt:\\n return txt\\n\\n result = []\\n index_pattern = r'(\\\\D*)(\\\\d+)'\\n pair = txt.split(range_operator)\\n result.append(pair[0])\\n\\n # Find start/end points\\n match1 = re.search(index_pattern, pair[0])\\n match2 = re.search(index_pattern, pair[1])\\n start = int(match1.group(2))\\n end = int(match2.group(2))\\n label = match1.group(1) if match1.group(1) != match1.group(2) else ''\\n result.extend([str(label) + str(i) for i in range(start + 1, end + 1)])\\n return result\",\n \"def __str__(self):\\n termStrings = []\\n for term in self.LHS:\\n coefficient = term[0]\\n unknownSet = term[1]\\n\\n termString = str(coefficient) + ' * '\\n unknownStrings = []\\n for unknown in unknownSet:\\n unknownString = unknown[0].__class__.__name__ + '@' + str(id(unknown[0]))[-4:] + '.' + unknown[1] # last 4 digits of variable ID . attribute name\\n unknownStrings.append(unknownString)\\n termString += str.join(' * ', unknownStrings)\\n termStrings.append(termString)\\n\\n termStrings = str.join(' + ', termStrings)\\n return termStrings + ' = ' + str(self.RHS)\",\n \"def __str__(self):\\n return \\\"%s %d\\\" % (dict(self.TERM_CHOICES)[self.term], self.year)\",\n \"def __str__( self ) :\\n\\n return( ' '.join( [ \\\"%g\\\" % c_l for c_l in self.coefficients ] ) )\",\n \"def __getitem__(self, interval):\\n l = [s for i, s in self.timesteps if i == interval]\\n if len(l) == 1:\\n return l[0]\\n\\n return ''\",\n \"def format_subrange(start, end, step):\\n \\n if start == end:\\n return str(start)\\n elif step == 1:\\n return \\\"%d-%d\\\" % (start, end)\\n else:\\n return \\\"%d-%dx%d\\\" % (start, end, step)\",\n \"def __str__(self):\\n lstr = \\\"\\\"\\n\\n # String for x term\\n if self.a != 0:\\n if self.a == 1:\\n lstr += \\\"x\\\"\\n elif self.a == -1:\\n lstr += \\\"-x\\\"\\n else:\\n lstr += str(self.a) + \\\"x\\\"\\n\\n # String for y term\\n if lstr != \\\"\\\": # This means that the x-coefficient is not 0\\n if self.b > 0:\\n if self.b == 1:\\n lstr += \\\" + y\\\"\\n else:\\n lstr += \\\" + \\\" + str(abs(self.b)) + \\\"y\\\"\\n elif self.b < 0:\\n if self.b == -1:\\n lstr += \\\" - y\\\"\\n else:\\n lstr += \\\" - \\\" + str(abs(self.b)) + \\\"y\\\"\\n else:\\n if self.b == 1:\\n lstr += \\\"y\\\"\\n elif self.b == -1:\\n lstr += \\\"-y\\\"\\n else:\\n lstr += str(self.b) + \\\"y\\\"\\n\\n # String for constant term\\n lstr += \\\" = \\\" + str(self.c)\\n\\n return lstr\",\n \"def substitute(self):\\n\\n n_chars = len(self.literal)\\n term = ['' for i in range(n_chars)]\\n\\n for i in range(n_chars):\\n if self.literal[i] in self.bindings:\\n term[i] = self.bindings[self.literal[i]]\\n else:\\n term[i] = self.literal[i]\\n\\n return (''.join(term))\",\n \"def to_string(self) -> str:\\n template = '(' if self.left_boundary['open'] else '['\\n template += '{},{}'\\n template += ')' if self.right_boundary['open'] else ']'\\n return template.format(\\n self.left_boundary['value'],\\n self.right_boundary['value']\\n )\",\n \"def __str__(self):\\n\\t\\treturn \\\"{min} ~ {max}\\\".format(min=str(self.min), max=str(self.max))\",\n \"def get_str(nr_rational):\\n return f'{get_numarator(nr_rational)} / {get_numitor(nr_rational)}'\",\n \"def __str__(self):\\n\\n return \\\"%s:\\\\n%s\\\" % (self.name, self.top_terms_tuples(25))\",\n \"def _repr_(self):\\n ending = \\\"\\\"\\n if str(self.t)!='t':\\n ending = ' with t=%s'%(self.t)\\n return \\\"%s-Bounded Quotient of Symmetric Functions over %s\\\"%(self.k, self.base_ring())+ending\",\n \"def get_basis(n):\\n\\treturn ' '.join('e{}'.format(i) for i in range(n))\",\n \"def irchain_str(self):\\n s = []\\n if self.irlen_before:\\n s.append('%d' % self.irlen_before)\\n s.append('(%d)' % self.irlen)\\n if self.irlen_after:\\n s.append('%d' % self.irlen_after)\\n return ','.join(s)\",\n \"def __str__(self):\\n\\n # This appears at the end of the fed method line\\n strme = \\\"{} {} {} {}\\\"\\\\\\n .format(self.n_itr, self.i_beg, self.i_end, self.omega)\\n\\n return strme\",\n \"def _term_name(self):\\n \\n year = self.term[0:3]\\n season = self.term[4:]\\n if season == self.TERMNUM[1]:\\n result = \\\"{}{}\\\".format(year, self.TERM[0])\\n \\n elif season == self.TERMNUM[2]:\\n result = \\\"{}{}\\\".format(year, self.TERM[1])\\n \\n else:\\n result = \\\"{}{}\\\".format(year, self.TERM[2])\\n \\n return result\",\n \"def _repr_term(self, c):\\n return self.prefix()+str(c)\",\n \"def __str__(self):\\n s = \\\"\\\"\\n for i in self.__buckets:\\n temp =\\\"\\\"\\n while len(temp) + len(str(self.__buckets.index(i))) < 5:\\n temp += \\\"_\\\" \\n s += \\\"[{}{}]{}\\\\n\\\".format(temp, self.__buckets.index(i), str(i))\\n return s\",\n \"def _range_expression(self):\\n # using filter expression to define the time range of the query\\n # In influx2, range query is in the format\\n # range(start:2018-05-22T23:30:00Z, stop: 2018-05-23T00:00:00Z) or\\n # range(start: -12h, stop: -15m)\\n # with stop parameter being optional\\n if self.filter is None:\\n return u''\\n exp = (self._sql_where_expression(self.filter)).replace('AND',',').split(',')\\n return u'|> range({})'.format(u' , '.join([(i.replace('\\\"','').replace(\\\"'\\\",'')) for i in exp if \\\"start\\\" in i or \\\"stop\\\" in i]))\",\n \"def __repr__(self):\\n s = \\\"{}, {}\\\".format(self.left_endpoint, self.right_endpoint)\\n if self.left_closed:\\n left_bracket = '['\\n else:\\n left_bracket = '('\\n\\n if self.right_closed:\\n right_bracket = ']'\\n else:\\n right_bracket = ')'\\n interval_string = left_bracket + s + right_bracket\\n return 'TreeNode({})'.format(interval_string)\",\n \"def term_to_tsquery_string(term):\\n\\n def cleanup(word, whitelist_chars=',.-_'):\\n result = ''.join(\\n (c for c in word if c.isalnum() or c in whitelist_chars)\\n )\\n return f'{result}:*' if word.endswith('*') else result\\n\\n parts = (cleanup(part) for part in (term or '').split())\\n return ' <-> '.join(tuple(part for part in parts if part))\",\n \"def __str__(self):\\r\\n return '[t1=%.1fs, t2=%.1fs, tmax=%.1fs, Lmax=%.1fs]' % (self.t1, self.t2, self.tmax, self.Lmax)\",\n \"def __str__(self):\\n [r,c],f = self.D, self.F\\n lmax = len(str(max(iter(self)))) + 1\\n s = '\\\\n'.join( (' '.join('{0:{l}G}'.format(f(i,j),l=lmax) if isinstance(f(i,j), int) or isinstance(f(i,j), float) else str(f(i,j)) for j in range(c))) for i in range(r))\\n return s\",\n \"def substitute_with_bindings(self,bindings):\\n\\n n_chars = len(self.literal)\\n term = ['' for i in range(n_chars)]\\n\\n for i in range(n_chars):\\n if self.literal[i] in bindings:\\n term[i] = bindings[self.literal[i]]\\n else:\\n term[i] = self.literal[i]\\n\\n return (''.join(term))\",\n \"def make_range(_num_list):\\n if len(_num_list) == 1:\\n out_str = str(_num_list[0])\\n\\n elif len(_num_list) == 2:\\n out_str = str(_num_list[0]) + ', ' + str(_num_list[1])\\n\\n else:\\n out_str = str(_num_list[0]) + '-' + str(_num_list[-1])\\n\\n return out_str\",\n \"def srt(self):\\n return '{} --> {}\\\\n{}\\\\n'.format(self.start.srt(), self.end.srt(), self.word)\",\n \"def range(self) -> str:\\n return f\\\"{self.name}!A:F\\\"\",\n \"def __str__(self) -> str:\\n mapping_str = ', '.join(\\n f'{variable!s} -> {term!s}'\\n for (variable, term) in self.mapping.items()\\n )\\n return f'{{{mapping_str}}}'\",\n \"def __str__(self):\\n return f\\\"Era '{self.text}' starting at {self.start}, ending at {self.end}\\\"\",\n \"def __str__(self):\\n\\t\\tself.__normalize()\\n\\t\\tmyStr ='# min = %lf\\\\n'%(float(self._min))\\n\\t\\tmyStr+='# max = %lf\\\\n'%(float(self._max))\\n\\t\\tmyStr+='# dx = %lf\\\\n'%(float(self._dx))\\n\\t\\tmyStr+='# av = %lf (sErr = %lf)\\\\n'%(self.av,self.sErr)\\n\\t\\tmyStr+='# sDev = %lf\\\\n'%(self.sDev)\\n\\t\\tmyStr+='# xLow xHigh p(xLow <= x < xHigh) Gaussian_error\\\\n'\\n\\t\\tfor bin in range(self._nBins): \\n\\t\\t\\tlow,up=self.__bdry(bin)\\n\\t\\t\\tmyStr+='%lf %lf %lf %lf\\\\n'%(low,up,self._norm[bin], self.__GErr(bin))\\n\\t\\treturn myStr\",\n \"def _repr_latex_(self):\\n reprlatex = \\\"\\\"\\n if not self._terms:\\n reprlatex += \\\"0\\\"\\n else:\\n for term in self:\\n termlatex = term._reprlatex\\n if not reprlatex:\\n # Adding the first term. No leading +.\\n reprlatex += termlatex\\n else:\\n if not termlatex.startswith(\\\"-\\\"):\\n # Is it the first term added to the sum? No leading +.\\n reprlatex += f\\\"+ {termlatex}\\\"\\n else:\\n reprlatex += termlatex\\n\\n return f\\\"${reprlatex}$\\\"\",\n \"def get_temprange_stringlist(self):\\n return text_temprange\",\n \"def __str__(self):\\n return \\\"(%s)\\\" % ' '.join(map(str, self.__subrules))\",\n \"def __str__(self):\\n\\n rep = 'Generalized Syllogism:\\\\n'\\n rep += '\\\\ttask: {}\\\\n'.format(self.task)\\n rep += '\\\\tencoded_task: {}\\\\n'.format(self.encoded_task)\\n rep += '\\\\tp1: {}\\\\n'.format(self.p1)\\n rep += '\\\\tp2: {}\\\\n'.format(self.p2)\\n rep += '\\\\tquantifier_p1: {}\\\\n'.format(self.quantifier_p1)\\n rep += '\\\\tquantifier_p2: {}\\\\n'.format(self.quantifier_p2)\\n rep += '\\\\tfigure: {}\\\\n'.format(self.figure)\\n rep += '\\\\tTerms:\\\\n'\\n rep += '\\\\t\\\\tA: {}\\\\n'.format(self.A)\\n rep += '\\\\t\\\\tB: {}\\\\n'.format(self.B)\\n rep += '\\\\t\\\\tC: {}\\\\n'.format(self.C)\\n return rep\",\n \"def get_string(self):\\n return (self.loop_level+1) * ' ' + ','.join(map(str, self.get_list()))\",\n \"def generate_cut_strings(var, bin_edges, bottom_inclusive=True):\\n incl = '=' if bottom_inclusive else ''\\n return ['{var} >{incl} {low:g} && {var} < {high:g}'.format(var=var, low=bin_low,\\n high=bin_high, incl=incl)\\n for (bin_low, bin_high) in bin_edges]\",\n \"def _get_term(self):\\n return self.__term\",\n \"def _get_term(self):\\n return self.__term\",\n \"def _get_term(self):\\n return self.__term\",\n \"def _get_term(self):\\n return self.__term\",\n \"def _get_term(self):\\n return self.__term\",\n \"def _get_term(self):\\n return self.__term\",\n \"def _get_term(self):\\n return self.__term\",\n \"def _get_term(self):\\n return self.__term\",\n \"def _get_term(self):\\n return self.__term\",\n \"def __str__(self):\\n string = ''\\n for degree, coef in enumerate(self.coefs, 1):\\n degree = degree - 1\\n string += str(coef)+'x^' + str(degree) + ' + '\\n string = string[0:-3] # remove the last ' + '\\n return string\",\n \"def str2(self):\\n signs = [ ('+' if f >= 0 else '-') for f in self.mVector ]\\n vals = [ abs(f) for f in self.mVector ]\\n\\n return '%s %s %si %s %sj %s %sk' % (self.mScalar, \\n signs[0],\\n vals[0],\\n signs[1],\\n vals[1],\\n signs[2],\\n vals[2])\",\n \"def _build_range(self) -> str:\\n return build_sequence(filter(None, (self.uids, self.sequence)))\",\n \"def to_right_boundary(self) -> str:\\n return '{}{}'.format(self.value, ']' if self.is_closed else ')')\",\n \"def __repr__(self):\\n return str(self.start) + ' \\\\t' + str(self.end)\",\n \"def Rstr(self):\\n\\n results = []\\n for expr in self.graded_dict:\\n _expr = str(expr).replace(\\\"*\\\", \\\":\\\")\\n if _expr != '1':\\n for order in self.graded_dict[expr]:\\n for factors in self.graded_dict[expr][order]:\\n results.append(':'.join([_expr] + [f.name for f in factors]))\\n else:\\n for order in self.graded_dict[expr]:\\n for factors in self.graded_dict[expr][order]:\\n if factors:\\n results.append(':'.join([f.name for f in factors]))\\n else:\\n results.append('1')\\n return \\\"+\\\".join(results)\",\n \"def t_STR_LITER(t):\\n return t\",\n \"def region_str(self):\\n return \\\"%s:%s-%s\\\" % (self.seqid, self.start, self.end)\",\n \"def range_collapse(begin, end, algorithm='chicago'):\\n if algorithm == 'chicago':\\n if begin > 100 and mod(begin, 100) and idiv(begin, 100) == idiv(end, 100):\\n return(str(begin) + '–' + str(mod(end, 100)))\\n elif begin >= 10000:\\n return(str(begin) + '–' + str(mod(end, 1000)))\\n else:\\n return(str(begin) + '–' + str(end))\",\n \"def r_style_interval(from_tuple, end_tuple, frequency):\\n from_year, from_seg = from_tuple\\n end_year, end_seg = end_tuple\\n n = (end_year - from_year + 1) * frequency\\n full_range = np.linspace(from_year, end_year + 1, num=n, endpoint=False)\\n real_range = full_range[(from_seg - 1):n - (frequency - end_seg)]\\n return real_range\",\n \"def label(self):\\r\\n if isinstance(self.Lbeta, str):\\r\\n result = self.Lbeta\\r\\n else:\\r\\n result = 'T%.2d' % int(round(self.Lbeta))\\r\\n result += 'E%.2d' % int(round(self.E))\\r\\n result += 'G%.2d' % int(round(self.minTauG))\\r\\n result += self.insulation\\r\\n return result\",\n \"def intervals(parser, token ):\\n try:\\n tag_name, arg = token.contents.split(None, 1)\\n except ValueError:\\n raise template.TemplateSyntaxError, \\\"%r needs arguments\\\" % token.contents.split()[0]\\n m = re.search(r'(.+) as (.+)', arg)\\n if not m:\\n raise template.TemplateSyntaxError, \\\"You need to specify 'as' variable \\\"\\n arguments, asname = m.groups()\\n if not '=' in arguments:\\n return intervals_args(parser, token )\\n return IntervalNode( arguments, asname )\",\n \"def range_to_label(arange):\\r\\n # pass\\r\\n C = arange.size - 1\\r\\n label = np.ones((arange[-1], ), dtype=np.int)\\r\\n for i in xrange(1, C):\\r\\n label[arange[i]: arange[i+1]] *= (i+1)\\r\\n return label\",\n \"def __str__(self):\\n \\n return '{{ {:.5g} {:.5g} {:.5g}; {:.5g} {:.5g} {:.5g}}}'.format(*list(self.vec))\",\n \"def buildString( lsys, iter ):\\n\\tnstring = getBase(lsys)\\n\\trule = getRule(lsys, 0)\\n\\tsymbol = rule[0]\\n\\treplacement = rule[1]\\n\\tfor i in range(iter):\\n\\t\\tnstring = nstring.replace( symbol, replacement )\\n\\treturn nstring\",\n \"def __str__(self):\\n\\t\\tif self.code == Const.NEWLINE:\\n\\t\\t\\treturn \\\"[newline]\\\"\\n\\t\\t\\n\\t\\tname = \\\"[\\\" + self.code\\n\\t\\tif self.code in (Const.numericalLiteral, Const.ID, Const.UET):\\n\\t\\t\\tname += \\\"(\\\" + self.value + \\\")\\\"\\n\\t\\tname += \\\"]\\\"\\n\\t\\treturn name\",\n \"def interval(entry):\\n string = entry.lower()\\n number1 = ''\\n number2 = ''\\n second = False\\n for c in entry:\\n if c.isdigit() or c == '.':\\n if second == False:\\n number1 += c\\n else:\\n number2 += c\\n elif not c.isdigit() and len(number1) > 0:\\n second = True\\n if number1 and number2:\\n leftover = re.sub(number1, '', string).strip().replace(\\\" \\\", \\\"\\\")\\n leftover = re.sub(number2, '', leftover).strip().replace(\\\" \\\", \\\"\\\")\\n numbers = (number1, number2)\\n if leftover:\\n op = leftover\\n else:\\n op = None\\n\\n if op:\\n if op == '--':\\n ops = (OPERATORS['>='], OPERATORS['<='])\\n else:\\n ops = (OPERATORS['>'], OPERATORS['<'])\\n return ops, numbers\\n return (None, None), (None, None)\",\n \"def return_string(self):\\n\\n if self.__numerator * self.__denominator < 0:\\n sign = \\\"-\\\"\\n else:\\n sign = \\\"\\\"\\n return \\\"{:s}{:d}/{:d}\\\".format(sign, abs(self.__numerator), abs(self.__denominator))\",\n \"def format_substitutions(subs: Union[SubstituteTerm, List[SubstituteTerm]]):\\n text = \\\"\\\"\\n if isinstance(subs, SubstituteTerm):\\n term_str = str(subs)\\n for line in term_str.split('\\\\n'):\\n text += Markup.escape(line) + Markup('<br />')\\n text += Markup('<br />')\\n return text\\n for term in subs:\\n term_str = str(term)\\n for line in term_str.split('\\\\n'):\\n text += Markup.escape(line) + Markup('<br />')\\n text += Markup('<br />')\\n return text\",\n \"def __str__(self):\\n self.vals.sort()\\n result = ''\\n for e in self.vals:\\n result = result + str(e) + ','\\n return '{' + result[:-1] + '}'\",\n \"def __repr__(self):\\n return f\\\"Era '{self.text}' starting at {self.start}, ending at {self.end}\\\"\",\n \"def __str__(self):\\n # special cases\\n if self.is_nan() :\\n return \\\"nan\\\"\\n elif self.coeff == 1 :\\n if self.expt == 1 :\\n return \\\"x\\\"\\n else :\\n return \\\"x^\\\" + str(self.expt)\\n elif self.coeff == -1 :\\n if self.expt == 1 :\\n return \\\"-x\\\"\\n else :\\n return \\\"-x^\\\" + str(self.expt)\\n \\n # str_builder\\n if self.expt == 0 :\\n if self.coeff.denominator == 1 :\\n return str(self.coeff.nominator)\\n else :\\n return \\\"{}/{}\\\".format(str(self.coeff.nominator), str(self.coeff.denominator))\\n elif self.expt == 1 :\\n if self.coeff.denominator == 1 :\\n return str(self.coeff.nominator) + \\\"*x\\\"\\n else :\\n return \\\"{}/{}\\\".format(str(self.coeff.nominator), str(self.coeff.denominator)) + \\\"*x\\\"\\n else :\\n if self.coeff.denominator == 1 :\\n return str(self.coeff.nominator) + \\\"*x^\\\" + str(self.expt)\\n else :\\n return \\\"{}/{}\\\".format(str(self.coeff.nominator), str(self.coeff.denominator)) + \\\"*x^\\\" + str(self.expt)\",\n \"def get_completion_terms(self):\\n return # osid.search.terms.DecimalRangeTerm\",\n \"def getConstantSentenceForms(self):\",\n \"def between(minl:int, maxl:int) -> str:\\n return f\\\"{{{minl},{maxl}}}\\\"\",\n \"def __str__(self):\\n if not self.has_converged or self.parameters is None:\\n log.warning(\\\"The fit has not converged. Try again!\\\")\\n return ''\\n\\n result = []\\n for parameter in self.parameters.keys():\\n if parameter in self.fit_for:\\n parameter_string = self.get_parameter_string(parameter)\\n if parameter_string is not None:\\n result.append(parameter_string)\\n\\n rms = self.get_parameter_format('kelvin') % self.rms\\n result.append(f\\\"[{rms} K rms]\\\")\\n return '\\\\n'.join(result)\",\n \"def getUniStr(self):\\n return(\\\"%s.%s.%s-%s\\\"%(self.getPrefix,self.getSentenceId,\\n self.offset_bgn,self.offset_end))\",\n \"def __str__(self) -> str:\\n out = ''\\n for i in range(self.buckets.length()):\\n list = self.buckets.get_at_index(i)\\n out += str(i) + ': ' + str(list) + '\\\\n'\\n return out\",\n \"def __str__(self):\\n # on trie la liste de valeurs par ordre croissant\\n self.vals.sort()\\n return '{' + ','.join([str(e) for e in self.vals]) + '}'\",\n \"def __str__(self):\\n template = ('Bounds: minx={f}, miny={f}, minz={f}\\\\n '\\n 'maxx={f}, maxy={f}, maxz={f}'.format(f=self._format))\\n # Formatter must be recreated each time to reset value counter\\n return NoneFormatter().format(template, *self)\",\n \"def __str__(self):\\n return f\\\"min={self.min} max={self.max}\\\"\",\n \"def base40_to_interval_name(base40):\\n direction = '-' if base40 < 0 else '+'\\n octave, interval = divmod(abs(base40), 40)\\n names = [\\n 'P1', 'A1', None, None,\\n 'd2', 'm2', 'M2', 'A2', None, None,\\n 'd3', 'm3', 'M3', 'A3', None, None,\\n 'd4', 'P4', 'A4', None, None, None,\\n 'd5', 'P5', 'A5', None, None,\\n 'd6', 'm6', 'M6', 'A6', None, None,\\n 'd7', 'm7', 'M7', 'A7', None, None,\\n 'd8', 'P8',\\n ]\\n name = names[interval]\\n if octave:\\n name = name.replace(name[1], str(octave * 8 + int(name[1]) - 1))\\n return ''.join([direction, name])\",\n \"def getLatexIntervalFromNll( self, minX, up=0.5, xRange=None, steps=1000, digits=2 ):\\n \\n mInterval = self.getFirstIntersectionsWithValue( up, xCenter=minX, xRange=xRange, steps=steps )\\n fF = \\\"%.\\\"+str(digits)+\\\"f\\\" # float Format\\n return ( (fF+\\\"^{+\\\"+fF+\\\"}_{\\\"+fF+\\\"}\\\") % (minX,mInterval[1]-minX,mInterval[0]-minX) )\",\n \"def sr(self):\\n return ''.join([str(seg) for seg in self.segments])\",\n \"def __str__(self):\\n # TODO check the terminal width and adjust the presentation\\n # only use for 1D, fall back to repr for ND\\n if self._hist.rank() == 1:\\n s = str(self._hist)\\n # get rid of first line and last character\\n s = s[s.index(\\\"\\\\n\\\") + 1 : -1]\\n else:\\n s = repr(self)\\n return s\",\n \"def table(self, L, R, n):\\n s = \\\"\\\"\\n import numpy as np\\n for x in np.linspace(L, R, n):\\n y = self(x)\\n s += \\\"%12g %12g\\\\n\\\" %(x,y)\\n return s\",\n \"def valueToString():\",\n \"def __str__(self):\\n string = ''\\n\\n # gets the nodes at each level and puts the values into a string\\n for i in range(self.get_height()+1):\\n nodes = self.get_nodes_on_level(i)\\n level = [str(node.value) if node else '-' for node in nodes]\\n string += '{}\\\\n'.format(' '.join(level))\\n\\n return string\",\n \"def table(self, L, R, n):\\n s = \\\"\\\"\\n for x in np.linspace(L, R, n):\\n y = self(x)\\n s += \\\"%12g %12g\\\\n\\\" % (x, y)\\n return s\",\n \"def getUniStr(self):\\n return('-'.join([\\\"%s-%s\\\"%(x.id,(x.id in self.special))\\n for x in self.getNested()]))\",\n \"def __repr__( self ):\\r\\n\\t\\treturn ( \\\"%s/%s\\\" % ( self.numerator, self.denominator ) )\",\n \"def sInterval(self, val):\\n\\n # NB: the support attribute has been added by precomputing __levels__\\n if val in self.support:\\n return self.support[val]\\n else:\\n return ()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63082343","0.63082343","0.6038259","0.5892248","0.57218105","0.5709738","0.5613051","0.5574001","0.5551552","0.55436116","0.54802537","0.5458659","0.5458","0.54380184","0.54280454","0.5421883","0.5411787","0.53858435","0.53813004","0.53752476","0.5359934","0.5342259","0.52882296","0.5285582","0.5277044","0.52763593","0.52576","0.52323025","0.5218882","0.521567","0.5179799","0.5168713","0.5142933","0.5142119","0.5134965","0.51326954","0.51009154","0.50811684","0.508071","0.5080599","0.50790966","0.50680625","0.5066485","0.5027366","0.50265384","0.5026028","0.5007482","0.5004157","0.5000055","0.49924377","0.49924377","0.49924377","0.49924377","0.49924377","0.49924377","0.49924377","0.49924377","0.49924377","0.49920183","0.49886996","0.49680826","0.49628258","0.4958507","0.4957543","0.4953007","0.49445924","0.4935547","0.49331754","0.49270463","0.49245694","0.49180093","0.49173647","0.49109313","0.4906084","0.49026516","0.48994285","0.4893893","0.48921457","0.48891822","0.48866776","0.4869956","0.48650032","0.4864409","0.48616207","0.48585108","0.48571935","0.48560137","0.48558015","0.4855142","0.4854806","0.48540995","0.48540503","0.4853801","0.48515266","0.48515093","0.48484564","0.48478612","0.48459136","0.4843036","0.4841854"],"string":"[\n \"0.63082343\",\n \"0.63082343\",\n \"0.6038259\",\n \"0.5892248\",\n \"0.57218105\",\n \"0.5709738\",\n \"0.5613051\",\n \"0.5574001\",\n \"0.5551552\",\n \"0.55436116\",\n \"0.54802537\",\n \"0.5458659\",\n \"0.5458\",\n \"0.54380184\",\n \"0.54280454\",\n \"0.5421883\",\n \"0.5411787\",\n \"0.53858435\",\n \"0.53813004\",\n \"0.53752476\",\n \"0.5359934\",\n \"0.5342259\",\n \"0.52882296\",\n \"0.5285582\",\n \"0.5277044\",\n \"0.52763593\",\n \"0.52576\",\n \"0.52323025\",\n \"0.5218882\",\n \"0.521567\",\n \"0.5179799\",\n \"0.5168713\",\n \"0.5142933\",\n \"0.5142119\",\n \"0.5134965\",\n \"0.51326954\",\n \"0.51009154\",\n \"0.50811684\",\n \"0.508071\",\n \"0.5080599\",\n \"0.50790966\",\n \"0.50680625\",\n \"0.5066485\",\n \"0.5027366\",\n \"0.50265384\",\n \"0.5026028\",\n \"0.5007482\",\n \"0.5004157\",\n \"0.5000055\",\n \"0.49924377\",\n \"0.49924377\",\n \"0.49924377\",\n \"0.49924377\",\n \"0.49924377\",\n \"0.49924377\",\n \"0.49924377\",\n \"0.49924377\",\n \"0.49924377\",\n \"0.49920183\",\n \"0.49886996\",\n \"0.49680826\",\n \"0.49628258\",\n \"0.4958507\",\n \"0.4957543\",\n \"0.4953007\",\n \"0.49445924\",\n \"0.4935547\",\n \"0.49331754\",\n \"0.49270463\",\n \"0.49245694\",\n \"0.49180093\",\n \"0.49173647\",\n \"0.49109313\",\n \"0.4906084\",\n \"0.49026516\",\n \"0.48994285\",\n \"0.4893893\",\n \"0.48921457\",\n \"0.48891822\",\n \"0.48866776\",\n \"0.4869956\",\n \"0.48650032\",\n \"0.4864409\",\n \"0.48616207\",\n \"0.48585108\",\n \"0.48571935\",\n \"0.48560137\",\n \"0.48558015\",\n \"0.4855142\",\n \"0.4854806\",\n \"0.48540995\",\n \"0.48540503\",\n \"0.4853801\",\n \"0.48515266\",\n \"0.48515093\",\n \"0.48484564\",\n \"0.48478612\",\n \"0.48459136\",\n \"0.4843036\",\n \"0.4841854\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71998906"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":79094,"cells":{"query":{"kind":"string","value":"Returns the term's string. This is very important, because terms are compared for equality using this string."},"document":{"kind":"string","value":"def _create_formatted_string(self):\n string = NALSyntax.StatementSyntax.Start.value + \\\n self.get_subject_term().get_formatted_string()\n\n string += \" \" + self.get_copula_string() + \" \"\n\n string += self.get_predicate_term().get_formatted_string() + \\\n NALSyntax.StatementSyntax.End.value\n\n return string"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __repr__(self):\n\n return \"<Terms term=%s>\" % (self.word)","def __str__(self):\n value = []\n for term in self.terms:\n value += [term.termname]\n return '<formula: %s>' % ' + '.join(value)","def __str__(self):\n value = []\n for term in self.terms:\n value += [term.termname]\n return '<formula: %s>' % ' + '.join(value)","def _term_name(self):\n \n year = self.term[0:3]\n season = self.term[4:]\n if season == self.TERMNUM[1]:\n result = \"{}{}\".format(year, self.TERM[0])\n \n elif season == self.TERMNUM[2]:\n result = \"{}{}\".format(year, self.TERM[1])\n \n else:\n result = \"{}{}\".format(year, self.TERM[2])\n \n return result","def _get_term(self):\n return self.__term","def _get_term(self):\n return self.__term","def _get_term(self):\n return self.__term","def _get_term(self):\n return self.__term","def _get_term(self):\n return self.__term","def _get_term(self):\n return self.__term","def _get_term(self):\n return self.__term","def _get_term(self):\n return self.__term","def _get_term(self):\n return self.__term","def format_term(term: Union[BNode, Literal, URIRef, Variable]) -> str:\n if isinstance(term, URIRef):\n return str(term)\n elif isinstance(term, BNode):\n return '?v_' + str(term)\n elif isinstance(term, Literal):\n return format_literal(term)\n else:\n return term.n3()","def __str__(self):\n \n string = \"{}: {} ({}) - {}\".format(self.code, self.title, self.credit, self._term_name())\n return string","def __str__(self):\n return \"{}\".format(self.word)","def __str__(self):\n\n return \"%s:\\n%s\" % (self.name, self.top_terms_tuples(25))","def __str__(self):\n termStrings = []\n for term in self.LHS:\n coefficient = term[0]\n unknownSet = term[1]\n\n termString = str(coefficient) + ' * '\n unknownStrings = []\n for unknown in unknownSet:\n unknownString = unknown[0].__class__.__name__ + '@' + str(id(unknown[0]))[-4:] + '.' + unknown[1] # last 4 digits of variable ID . attribute name\n unknownStrings.append(unknownString)\n termString += str.join(' * ', unknownStrings)\n termStrings.append(termString)\n\n termStrings = str.join(' + ', termStrings)\n return termStrings + ' = ' + str(self.RHS)","def __str__(self):\n s = 'word chain: ' + '\\n'\n for word in self._used_words[:-1]:\n s += word + ' -> '\n s += self._used_words[-1] + '\\ntarget word: ' + self._target\n return s","def __str__(self):\n return f'{f\"The {self.word} \" if self.word.strip() != \"\" else \"\"}{self.name if self.name.strip() != \"\" else self.__class__.__name__}'","def __str__(self):\n return self._from_word","def _repr_term(self, c):\n return self.prefix()+str(c)","def search_term(self) -> str:\n return self._search_term","def get_word(naf: KafNafParser, term: Cterm) -> str:\n tokenids = naf.get_dict_tokens_for_termid(term.get_id())\n tokens = sort_tokens(naf.get_token(tid) for tid in tokenids)\n return \" \".join(t.get_text() for t in tokens)","def __str__(self):\n return \"%s %d\" % (dict(self.TERM_CHOICES)[self.term], self.year)","def Term(self, default=None):\n return self.data.get('term', default)","def getSearchString(self):\n return str(self)","def __str__(self):\n lstr = \"\"\n\n # String for x term\n if self.a != 0:\n if self.a == 1:\n lstr += \"x\"\n elif self.a == -1:\n lstr += \"-x\"\n else:\n lstr += str(self.a) + \"x\"\n\n # String for y term\n if lstr != \"\": # This means that the x-coefficient is not 0\n if self.b > 0:\n if self.b == 1:\n lstr += \" + y\"\n else:\n lstr += \" + \" + str(abs(self.b)) + \"y\"\n elif self.b < 0:\n if self.b == -1:\n lstr += \" - y\"\n else:\n lstr += \" - \" + str(abs(self.b)) + \"y\"\n else:\n if self.b == 1:\n lstr += \"y\"\n elif self.b == -1:\n lstr += \"-y\"\n else:\n lstr += str(self.b) + \"y\"\n\n # String for constant term\n lstr += \" = \" + str(self.c)\n\n return lstr","def __str__(self):\n return self.word","def __str__(self):\n\n return '{0} {1} {2}'.format(self.feat, '==' if self.pos else '!=',\n self.val)","def get(self) -> str:\n\n return self.word","def get_string(self):\n return self.__str","def expression_term(self):\n return self._expression_term","def __str__(self):\n if self._tokens == '*' or self._tokens == '':\n return self._tokens\n self.compact()\n return \"\".join(str(s[0])+s[1] for s in self._tokens)","def term_unit(self) -> Optional[str]:\n return pulumi.get(self, \"term_unit\")","def term_unit(self) -> Optional[str]:\n return pulumi.get(self, \"term_unit\")","def term_unit(self) -> Optional[str]:\n return pulumi.get(self, \"term_unit\")","def terms(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"terms\")","def GetQueryString(self):\n \n rdict = {-1: [], 1: []}\n for c_w_coeff in self.reactants:\n c = numpy.abs(c_w_coeff.coeff)\n s = numpy.sign(c_w_coeff.coeff)\n if s == 0:\n continue\n if c == 1:\n rdict[s].append(c_w_coeff.GetName())\n else:\n rdict[s].append('%g %s' % (c, c_w_coeff.GetName()))\n \n return '%s = %s' % (' + '.join(rdict[-1]), ' + '.join(rdict[1]))","def fold_term(self, term):\n if isinstance(term, Var):\n return self.var(term.name)\n elif isinstance(term, Const):\n return self.const(term.name)\n elif isinstance(term, Dist):\n return self.dist(term.name)\n elif isinstance(term, Func):\n return self.func(\n term.funcname,\n tuple( self.fold_term(x)\n for x in term.args ))\n elif isinstance(term, Eq):\n return self.encode_eq(term)\n elif isinstance(term, Disj):\n return self.encode_disj(term)\n elif isinstance(term, Conj):\n return self.encode_conj(term)\n raise RuntimeError('Invalid term {}'.format(term))","def __repr__(self):\n if len(self) == 0:\n return f\"{self.__class__.__name__}()\"\n else:\n return \" + \".join([repr(term) for term in self])","def __str__(self):\n return str(self.__token)","def __str__(self):\n return self.underscoreSentence.get().__str__()","def term_id(self) -> Optional[str]:\n return pulumi.get(self, \"term_id\")","def string_val(self) -> str:\n return self.current_token","def term_to_tsquery_string(term):\n\n def cleanup(word, whitelist_chars=',.-_'):\n result = ''.join(\n (c for c in word if c.isalnum() or c in whitelist_chars)\n )\n return f'{result}:*' if word.endswith('*') else result\n\n parts = (cleanup(part) for part in (term or '').split())\n return ' <-> '.join(tuple(part for part in parts if part))","def str_attr(self):\n return str(self.operator)","def potential_string(self):\n return_str = 'pair_coeff {} {} {:6.4f} {:6.4f} {:6.4f}'.format(self.atype_index[0],\n self.atype_index[1],\n self.a.value,\n self.rho.value,\n self.c.value)\n return return_str","def __str__(self):\n\n\t\tterms = \\\n\t\t[{att:self.att[att]} for att in self.att if type(self.att[att])==bool]\n\n\t\treturn ''.join([str(int(t.values()[0])) for t in terms])","def __get_term_bigram(self, indeks_token_pertama:int, tokens:list):\n term1 = tokens[indeks_token_pertama]\n term2 = tokens[indeks_token_pertama + 1]\n return ' '.join([term1, term2])","def term_to_URI(self, term) :\n\t\tif len(term) == 0 : return None\n\n\t\tif termname.match(term) :\n\t\t\t# It is a valid NCNAME\n\n\t\t\t# First of all, a @vocab nukes everything. That has to be done first...\n\t\t\tif self.default_term_uri != None :\n\t\t\t\treturn URIRef(self.default_term_uri + term)\n\n\t\t\t# For default terms, the algorithm is (see 7.4.3 of the document): first make a case sensitive match;\n\t\t\t# if that fails than make a case insensive one\n\t\t\t# 1. simple, case sensitive test:\n\t\t\tif term in self.terms :\n\t\t\t\t# yep, term is a valid key as is\n\t\t\t\t# lazy binding of the xhv prefix for terms...\n\t\t\t\tself.graph.bind(XHTML_PREFIX, XHTML_URI)\n\t\t\t\treturn self.terms[term]\n\n\t\t\t# 2. case insensitive test\n\t\t\tfor defined_term in self.terms :\n\t\t\t\tif term.lower() == defined_term.lower() :\n\t\t\t\t\t# lazy binding of the xhv prefix for terms...\n\t\t\t\t\tself.graph.bind(XHTML_PREFIX, XHTML_URI)\n\t\t\t\t\treturn self.terms[defined_term]\n\n\t\t# If it got here, it is all wrong...\n\t\treturn None","def __repr__(self):\n\n return \"<StudyTerm word=%s pmid=%d frequency=%f>\" % (\n self.word, self.pmid, self.frequency)","def get_term(self, idx):\n try:\n return self.id2term[idx]\n except KeyError:\n return self.unk_term","def __str__(self):\n if not self.b:\n return str(self.a)\n elif self.b==1:\n if not self.a:\n return 'sqrt(%s)' % (self.r)\n else:\n return '(%s + sqrt(%s))' % (self.a, self.r)\n else:\n if not self.a:\n return '(%s * sqrt(%s))' % (self.b, self.r)\n str_b = str(self.b)\n if str_b == '-1':\n str_b = ' - '\n elif str_b.startswith('-'):\n str_b = '- ' + str_b[1:] + ' *'\n else:\n str_b = '+ ' + str_b + ' *'\n return '(%s %s sqrt(%s))' % (self.a, str_b, self.r)","def __str__(self):\n # special cases\n if self.is_nan() :\n return \"nan\"\n elif self.coeff == 1 :\n if self.expt == 1 :\n return \"x\"\n else :\n return \"x^\" + str(self.expt)\n elif self.coeff == -1 :\n if self.expt == 1 :\n return \"-x\"\n else :\n return \"-x^\" + str(self.expt)\n \n # str_builder\n if self.expt == 0 :\n if self.coeff.denominator == 1 :\n return str(self.coeff.nominator)\n else :\n return \"{}/{}\".format(str(self.coeff.nominator), str(self.coeff.denominator))\n elif self.expt == 1 :\n if self.coeff.denominator == 1 :\n return str(self.coeff.nominator) + \"*x\"\n else :\n return \"{}/{}\".format(str(self.coeff.nominator), str(self.coeff.denominator)) + \"*x\"\n else :\n if self.coeff.denominator == 1 :\n return str(self.coeff.nominator) + \"*x^\" + str(self.expt)\n else :\n return \"{}/{}\".format(str(self.coeff.nominator), str(self.coeff.denominator)) + \"*x^\" + str(self.expt)","def __str__(self):\n\n return '{0} == {1}'.format(self.feat, self.val)","def __str__(self):\n result = \"\"\n if self.operator is not None:\n result = \"Operator: \" + self.operator + \"\\n\"\n result += self.dictkey() + \"\\n\"\n return result","def toString(self):\n \n if not self.coeff_map:\n raise Exception('no coeffs in constrain %s'%self.name)\n \n if self.result is None:\n raise Exception('result of this constrain is unknown!')\n \n if self.name is None:\n res=\"\"\n else:\n res=self.name+\": \"\n \n res+=coeff_sum(self.coeff_map) \n \n res+=self.op\n res+=\" \"+str(self.result)\n \n return res;","def __str__(self):\n return self.get_equation()","def _repr_latex_(self):\n reprlatex = \"\"\n if not self._terms:\n reprlatex += \"0\"\n else:\n for term in self:\n termlatex = term._reprlatex\n if not reprlatex:\n # Adding the first term. No leading +.\n reprlatex += termlatex\n else:\n if not termlatex.startswith(\"-\"):\n # Is it the first term added to the sum? No leading +.\n reprlatex += f\"+ {termlatex}\"\n else:\n reprlatex += termlatex\n\n return f\"${reprlatex}$\"","def __str__(self):\n return \"chi1=%e chi2=%e m1=%e m2=%e distance=%e thetaJ=%e alpha0=%e chip=%e phic=%e fref=%e mode=%d freqs=[%e...%e]\" % (\n self.chi1, self.chi2, self.m1 / lal.lal.MSUN_SI, self.m2 / lal.lal.MSUN_SI, self.distance / (lal.lal.PC_SI * 100 * 1e6), self.thetaJ, self.alpha0, self.chip, self.phic, self.fref, self.mode, self.freqs[0], self.freqs[-1])","def __str__(self):\n\n rep = 'Generalized Syllogism:\\n'\n rep += '\\ttask: {}\\n'.format(self.task)\n rep += '\\tencoded_task: {}\\n'.format(self.encoded_task)\n rep += '\\tp1: {}\\n'.format(self.p1)\n rep += '\\tp2: {}\\n'.format(self.p2)\n rep += '\\tquantifier_p1: {}\\n'.format(self.quantifier_p1)\n rep += '\\tquantifier_p2: {}\\n'.format(self.quantifier_p2)\n rep += '\\tfigure: {}\\n'.format(self.figure)\n rep += '\\tTerms:\\n'\n rep += '\\t\\tA: {}\\n'.format(self.A)\n rep += '\\t\\tB: {}\\n'.format(self.B)\n rep += '\\t\\tC: {}\\n'.format(self.C)\n return rep","def __str__(self):\n # TODO check the terminal width and adjust the presentation\n # only use for 1D, fall back to repr for ND\n if self._hist.rank() == 1:\n s = str(self._hist)\n # get rid of first line and last character\n s = s[s.index(\"\\n\") + 1 : -1]\n else:\n s = repr(self)\n return s","def toString(self):\n return self.tokens.toString()","def __str__ ( self ):\n return self.get_label()","def get_search_term(self) -> str:\n search_term = self.args.get(\"q\", None)\n if search_term is None:\n logger.error(self.request_id, \"Search term not specified\", extra={\"status\": 400})\n raise InvalidUsage(\"Search term not specified\")\n return search_term","def __str__(self):\n return \"{} != {} ({})\".format(self.var1.name,\n self.var2.name,\n self.satisfied())","def __str__(self):\n\n if self._s == '':\n return ''\n\n if len(self.quote) == 1:\n s = self.to_short()\n else:\n s = self.to_long()\n\n try:\n eval(self.quote + s + self.quote)\n except UnicodeDecodeError:\n if self._safe_mode:\n raise\n\n self._safe_mode = True\n\n assert eval(self.quote + s + self.quote) == self._s\n\n return s","def get_str ( self ):\n value = self.value\n def gen_words():\n if value == self.OV_NONE:\n yield \"none\"\n else:\n if value & self.OV_SYM_EXIST:\n if value & self.OV_SYM_DEAD:\n yield \"symlinks\"\n else:\n yield \"symlinks to existing files\"\n elif value & self.OV_SYM_DEAD:\n yield \"broken symlinks\"\n\n if value & self.OV_FILE:\n yield \"files\"\n # --- end of gen_words (...) ---\n\n return ', '.join ( gen_words() ) + \" (0x{:x})\".format ( value )","def get_content_as_string(self):\n return \" \".join([token.word for token in self.tokens])","def text(self):\n if self.is_root:\n return ''\n elif self.is_comment:\n return self.__value\n elif self.is_flag:\n if self.__value:\n return '[{0}]'.format(self.name)\n else:\n return '!{0}!'.format(self.name)\n else:\n return '[{0}:{1}]'.format(self.name, self.value)","def __str__(self):\n s = \"\"\n s += self.synset.name + \"\\t\"\n s += \"PosScore: %s\\t\" % self.pos_score\n s += \"NegScore: %s\" % self.neg_score\n return s","def __str__(self):\n return 'Tokenizer({type}, {value})'.format(\n type=self.type,\n value=repr(self.value)\n )","def __str__(self):\n\n if self._b == b'':\n return ''\n\n if len(self.quote) == 1:\n s = self.to_short()\n else:\n s = self.to_long()\n\n assert eval('b' + self.quote + s + self.quote) == self._b\n\n return s","def getUniStr(self):\n return(\"%s/%s\"%(Entity.getUniStr(self),self.semanticId))","def _repr_(self):\n ending = \"\"\n if str(self.t)!='t':\n ending = ' with t=%s'%(self.t)\n return \"%s-Bounded Quotient of Symmetric Functions over %s\"%(self.k, self.base_ring())+ending","def get_feature_string_by_document(self, _set, document):\n label = self.sets[_set][document]['label']\n line = \"{} \".format(label)\n for word in self.sets[_set][document]['words']:\n line += \"{}:{} \".format(self.dictionary[word]['id'],tfidf.tfidf(word, document, self))\n line += \"\\n\"\n return line","def __str__(self):\n return self.get_ascii_trunk() + self.get_ascii_leaves()","def to_string(self):\n return \" \".join(self._words)","def __str__(self):\n # Use 'Unknown' if the course instance does not have a term\n if self.course_instance.term:\n term = self.course_instance.term.verbose_name()\n else:\n term = 'Unknown'\n\n exam_unicode = '{term} {number} {type} for {course}'.format(\n term=term,\n number=self.get_exam_number_display(),\n type=self.get_exam_type_display(),\n course=self.course_instance.course)\n if self.instructors:\n instructors = ', '.join([i.last_name for i in self.instructors])\n return '{}, taught by {}'.format(exam_unicode, instructors)\n else:\n return '{} (Instructors Unknown)'.format(exam_unicode)","def term(self) -> Optional['outputs.SaasPropertiesResponseTerm']:\n return pulumi.get(self, \"term\")","def __str__(self):\n return str(self._value) + ' ' + str(self.unit.get_symbol())","def __str__(self):\n if self.reference is None:\n return '%s - %s - %s' % (self.name, self.qualifier, self.location)\n else:\n return '%s - %s - %s - %s' % (self.name, self.qualifier, self.location, self.reference)","def full_string(self):\n return \"{}: {}\".format(str(self.word), \" \".join([str(adj) for adj in self.adjectives]))","def toString():","def string(self):\n return self._my_string","def __str__(self):\n return str(self.tag)","def word(self):\n return str(self.name.names[-1])","def optstr(self) -> str:\n typestr: str = (\n self.typestr().upper() if self.type_frozen else self.typestr()\n )\n if not self.ns_param or not self.argname_shorten:\n # * makes sure it's not wrapped\n return (\n self.namestr()\n if self.is_help\n else f\"{self.namestr()}*<{typestr}>\"\n )\n\n ret: List[str] = []\n for term in sorted(self.terminals, key=len):\n ret.append(f\"~<ns>.{term}\")\n return \", \".join(ret) + f\"*<{typestr}>\"","def visit_StringNode(self, node: StringNode, symbol_table: SymbolTable) -> String:\n return String(node.tok.value)","def get_text( self, ):\n a_string = self.a_string_var.get( )\n return a_string","def get_text( self, ):\n a_string = self.a_string_var.get( )\n return a_string","def __str__(self):\n\t\tif self.code == Const.NEWLINE:\n\t\t\treturn \"[newline]\"\n\t\t\n\t\tname = \"[\" + self.code\n\t\tif self.code in (Const.numericalLiteral, Const.ID, Const.UET):\n\t\t\tname += \"(\" + self.value + \")\"\n\t\tname += \"]\"\n\t\treturn name","def __str__(self):\n assert not hasattr(self, \"value\")\n if self.is_set:\n return \"%s \" % self.names[0]\n else:\n return \"\"","def __repr__(self) -> str:\n return f\"{self.text}\"","def get_british_term_definition(word: str) -> str:\n word = process_word(word)\n return BRITISH_ENGLISH_ONLY_TERMS[word]","def __str__( self ) :\n\n return( ' '.join( [ \"%g\" % c_l for c_l in self.coefficients ] ) )","def as_string (self) :\n\n if self.is_machinetag() :\n return \"%s:%s=%s\" % (self.namespace(), self.predicate(), self.value())","def GetSynonymTerm(con, cur, synonym):\n err, termid = GetSynonymTermId(con, cur, synonym)\n if err:\n debug(2, 'ontology term %s is not a synonym' % synonym)\n return err, str(termid)\n err, term = dbidval.GetDescriptionFromId(con, cur, 'ontologyTable', termid)\n if err:\n debug(3, 'ontology term not found for termid %d (synonym %s)' % (termid, synonym))\n return err, term\n return '', term","def literal_to_string(self, literal):\n s = '!' if is_negated(literal) else ''\n return s + self.variables[literal >> 1]"],"string":"[\n \"def __repr__(self):\\n\\n return \\\"<Terms term=%s>\\\" % (self.word)\",\n \"def __str__(self):\\n value = []\\n for term in self.terms:\\n value += [term.termname]\\n return '<formula: %s>' % ' + '.join(value)\",\n \"def __str__(self):\\n value = []\\n for term in self.terms:\\n value += [term.termname]\\n return '<formula: %s>' % ' + '.join(value)\",\n \"def _term_name(self):\\n \\n year = self.term[0:3]\\n season = self.term[4:]\\n if season == self.TERMNUM[1]:\\n result = \\\"{}{}\\\".format(year, self.TERM[0])\\n \\n elif season == self.TERMNUM[2]:\\n result = \\\"{}{}\\\".format(year, self.TERM[1])\\n \\n else:\\n result = \\\"{}{}\\\".format(year, self.TERM[2])\\n \\n return result\",\n \"def _get_term(self):\\n return self.__term\",\n \"def _get_term(self):\\n return self.__term\",\n \"def _get_term(self):\\n return self.__term\",\n \"def _get_term(self):\\n return self.__term\",\n \"def _get_term(self):\\n return self.__term\",\n \"def _get_term(self):\\n return self.__term\",\n \"def _get_term(self):\\n return self.__term\",\n \"def _get_term(self):\\n return self.__term\",\n \"def _get_term(self):\\n return self.__term\",\n \"def format_term(term: Union[BNode, Literal, URIRef, Variable]) -> str:\\n if isinstance(term, URIRef):\\n return str(term)\\n elif isinstance(term, BNode):\\n return '?v_' + str(term)\\n elif isinstance(term, Literal):\\n return format_literal(term)\\n else:\\n return term.n3()\",\n \"def __str__(self):\\n \\n string = \\\"{}: {} ({}) - {}\\\".format(self.code, self.title, self.credit, self._term_name())\\n return string\",\n \"def __str__(self):\\n return \\\"{}\\\".format(self.word)\",\n \"def __str__(self):\\n\\n return \\\"%s:\\\\n%s\\\" % (self.name, self.top_terms_tuples(25))\",\n \"def __str__(self):\\n termStrings = []\\n for term in self.LHS:\\n coefficient = term[0]\\n unknownSet = term[1]\\n\\n termString = str(coefficient) + ' * '\\n unknownStrings = []\\n for unknown in unknownSet:\\n unknownString = unknown[0].__class__.__name__ + '@' + str(id(unknown[0]))[-4:] + '.' + unknown[1] # last 4 digits of variable ID . attribute name\\n unknownStrings.append(unknownString)\\n termString += str.join(' * ', unknownStrings)\\n termStrings.append(termString)\\n\\n termStrings = str.join(' + ', termStrings)\\n return termStrings + ' = ' + str(self.RHS)\",\n \"def __str__(self):\\n s = 'word chain: ' + '\\\\n'\\n for word in self._used_words[:-1]:\\n s += word + ' -> '\\n s += self._used_words[-1] + '\\\\ntarget word: ' + self._target\\n return s\",\n \"def __str__(self):\\n return f'{f\\\"The {self.word} \\\" if self.word.strip() != \\\"\\\" else \\\"\\\"}{self.name if self.name.strip() != \\\"\\\" else self.__class__.__name__}'\",\n \"def __str__(self):\\n return self._from_word\",\n \"def _repr_term(self, c):\\n return self.prefix()+str(c)\",\n \"def search_term(self) -> str:\\n return self._search_term\",\n \"def get_word(naf: KafNafParser, term: Cterm) -> str:\\n tokenids = naf.get_dict_tokens_for_termid(term.get_id())\\n tokens = sort_tokens(naf.get_token(tid) for tid in tokenids)\\n return \\\" \\\".join(t.get_text() for t in tokens)\",\n \"def __str__(self):\\n return \\\"%s %d\\\" % (dict(self.TERM_CHOICES)[self.term], self.year)\",\n \"def Term(self, default=None):\\n return self.data.get('term', default)\",\n \"def getSearchString(self):\\n return str(self)\",\n \"def __str__(self):\\n lstr = \\\"\\\"\\n\\n # String for x term\\n if self.a != 0:\\n if self.a == 1:\\n lstr += \\\"x\\\"\\n elif self.a == -1:\\n lstr += \\\"-x\\\"\\n else:\\n lstr += str(self.a) + \\\"x\\\"\\n\\n # String for y term\\n if lstr != \\\"\\\": # This means that the x-coefficient is not 0\\n if self.b > 0:\\n if self.b == 1:\\n lstr += \\\" + y\\\"\\n else:\\n lstr += \\\" + \\\" + str(abs(self.b)) + \\\"y\\\"\\n elif self.b < 0:\\n if self.b == -1:\\n lstr += \\\" - y\\\"\\n else:\\n lstr += \\\" - \\\" + str(abs(self.b)) + \\\"y\\\"\\n else:\\n if self.b == 1:\\n lstr += \\\"y\\\"\\n elif self.b == -1:\\n lstr += \\\"-y\\\"\\n else:\\n lstr += str(self.b) + \\\"y\\\"\\n\\n # String for constant term\\n lstr += \\\" = \\\" + str(self.c)\\n\\n return lstr\",\n \"def __str__(self):\\n return self.word\",\n \"def __str__(self):\\n\\n return '{0} {1} {2}'.format(self.feat, '==' if self.pos else '!=',\\n self.val)\",\n \"def get(self) -> str:\\n\\n return self.word\",\n \"def get_string(self):\\n return self.__str\",\n \"def expression_term(self):\\n return self._expression_term\",\n \"def __str__(self):\\n if self._tokens == '*' or self._tokens == '':\\n return self._tokens\\n self.compact()\\n return \\\"\\\".join(str(s[0])+s[1] for s in self._tokens)\",\n \"def term_unit(self) -> Optional[str]:\\n return pulumi.get(self, \\\"term_unit\\\")\",\n \"def term_unit(self) -> Optional[str]:\\n return pulumi.get(self, \\\"term_unit\\\")\",\n \"def term_unit(self) -> Optional[str]:\\n return pulumi.get(self, \\\"term_unit\\\")\",\n \"def terms(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"terms\\\")\",\n \"def GetQueryString(self):\\n \\n rdict = {-1: [], 1: []}\\n for c_w_coeff in self.reactants:\\n c = numpy.abs(c_w_coeff.coeff)\\n s = numpy.sign(c_w_coeff.coeff)\\n if s == 0:\\n continue\\n if c == 1:\\n rdict[s].append(c_w_coeff.GetName())\\n else:\\n rdict[s].append('%g %s' % (c, c_w_coeff.GetName()))\\n \\n return '%s = %s' % (' + '.join(rdict[-1]), ' + '.join(rdict[1]))\",\n \"def fold_term(self, term):\\n if isinstance(term, Var):\\n return self.var(term.name)\\n elif isinstance(term, Const):\\n return self.const(term.name)\\n elif isinstance(term, Dist):\\n return self.dist(term.name)\\n elif isinstance(term, Func):\\n return self.func(\\n term.funcname,\\n tuple( self.fold_term(x)\\n for x in term.args ))\\n elif isinstance(term, Eq):\\n return self.encode_eq(term)\\n elif isinstance(term, Disj):\\n return self.encode_disj(term)\\n elif isinstance(term, Conj):\\n return self.encode_conj(term)\\n raise RuntimeError('Invalid term {}'.format(term))\",\n \"def __repr__(self):\\n if len(self) == 0:\\n return f\\\"{self.__class__.__name__}()\\\"\\n else:\\n return \\\" + \\\".join([repr(term) for term in self])\",\n \"def __str__(self):\\n return str(self.__token)\",\n \"def __str__(self):\\n return self.underscoreSentence.get().__str__()\",\n \"def term_id(self) -> Optional[str]:\\n return pulumi.get(self, \\\"term_id\\\")\",\n \"def string_val(self) -> str:\\n return self.current_token\",\n \"def term_to_tsquery_string(term):\\n\\n def cleanup(word, whitelist_chars=',.-_'):\\n result = ''.join(\\n (c for c in word if c.isalnum() or c in whitelist_chars)\\n )\\n return f'{result}:*' if word.endswith('*') else result\\n\\n parts = (cleanup(part) for part in (term or '').split())\\n return ' <-> '.join(tuple(part for part in parts if part))\",\n \"def str_attr(self):\\n return str(self.operator)\",\n \"def potential_string(self):\\n return_str = 'pair_coeff {} {} {:6.4f} {:6.4f} {:6.4f}'.format(self.atype_index[0],\\n self.atype_index[1],\\n self.a.value,\\n self.rho.value,\\n self.c.value)\\n return return_str\",\n \"def __str__(self):\\n\\n\\t\\tterms = \\\\\\n\\t\\t[{att:self.att[att]} for att in self.att if type(self.att[att])==bool]\\n\\n\\t\\treturn ''.join([str(int(t.values()[0])) for t in terms])\",\n \"def __get_term_bigram(self, indeks_token_pertama:int, tokens:list):\\n term1 = tokens[indeks_token_pertama]\\n term2 = tokens[indeks_token_pertama + 1]\\n return ' '.join([term1, term2])\",\n \"def term_to_URI(self, term) :\\n\\t\\tif len(term) == 0 : return None\\n\\n\\t\\tif termname.match(term) :\\n\\t\\t\\t# It is a valid NCNAME\\n\\n\\t\\t\\t# First of all, a @vocab nukes everything. That has to be done first...\\n\\t\\t\\tif self.default_term_uri != None :\\n\\t\\t\\t\\treturn URIRef(self.default_term_uri + term)\\n\\n\\t\\t\\t# For default terms, the algorithm is (see 7.4.3 of the document): first make a case sensitive match;\\n\\t\\t\\t# if that fails than make a case insensive one\\n\\t\\t\\t# 1. simple, case sensitive test:\\n\\t\\t\\tif term in self.terms :\\n\\t\\t\\t\\t# yep, term is a valid key as is\\n\\t\\t\\t\\t# lazy binding of the xhv prefix for terms...\\n\\t\\t\\t\\tself.graph.bind(XHTML_PREFIX, XHTML_URI)\\n\\t\\t\\t\\treturn self.terms[term]\\n\\n\\t\\t\\t# 2. case insensitive test\\n\\t\\t\\tfor defined_term in self.terms :\\n\\t\\t\\t\\tif term.lower() == defined_term.lower() :\\n\\t\\t\\t\\t\\t# lazy binding of the xhv prefix for terms...\\n\\t\\t\\t\\t\\tself.graph.bind(XHTML_PREFIX, XHTML_URI)\\n\\t\\t\\t\\t\\treturn self.terms[defined_term]\\n\\n\\t\\t# If it got here, it is all wrong...\\n\\t\\treturn None\",\n \"def __repr__(self):\\n\\n return \\\"<StudyTerm word=%s pmid=%d frequency=%f>\\\" % (\\n self.word, self.pmid, self.frequency)\",\n \"def get_term(self, idx):\\n try:\\n return self.id2term[idx]\\n except KeyError:\\n return self.unk_term\",\n \"def __str__(self):\\n if not self.b:\\n return str(self.a)\\n elif self.b==1:\\n if not self.a:\\n return 'sqrt(%s)' % (self.r)\\n else:\\n return '(%s + sqrt(%s))' % (self.a, self.r)\\n else:\\n if not self.a:\\n return '(%s * sqrt(%s))' % (self.b, self.r)\\n str_b = str(self.b)\\n if str_b == '-1':\\n str_b = ' - '\\n elif str_b.startswith('-'):\\n str_b = '- ' + str_b[1:] + ' *'\\n else:\\n str_b = '+ ' + str_b + ' *'\\n return '(%s %s sqrt(%s))' % (self.a, str_b, self.r)\",\n \"def __str__(self):\\n # special cases\\n if self.is_nan() :\\n return \\\"nan\\\"\\n elif self.coeff == 1 :\\n if self.expt == 1 :\\n return \\\"x\\\"\\n else :\\n return \\\"x^\\\" + str(self.expt)\\n elif self.coeff == -1 :\\n if self.expt == 1 :\\n return \\\"-x\\\"\\n else :\\n return \\\"-x^\\\" + str(self.expt)\\n \\n # str_builder\\n if self.expt == 0 :\\n if self.coeff.denominator == 1 :\\n return str(self.coeff.nominator)\\n else :\\n return \\\"{}/{}\\\".format(str(self.coeff.nominator), str(self.coeff.denominator))\\n elif self.expt == 1 :\\n if self.coeff.denominator == 1 :\\n return str(self.coeff.nominator) + \\\"*x\\\"\\n else :\\n return \\\"{}/{}\\\".format(str(self.coeff.nominator), str(self.coeff.denominator)) + \\\"*x\\\"\\n else :\\n if self.coeff.denominator == 1 :\\n return str(self.coeff.nominator) + \\\"*x^\\\" + str(self.expt)\\n else :\\n return \\\"{}/{}\\\".format(str(self.coeff.nominator), str(self.coeff.denominator)) + \\\"*x^\\\" + str(self.expt)\",\n \"def __str__(self):\\n\\n return '{0} == {1}'.format(self.feat, self.val)\",\n \"def __str__(self):\\n result = \\\"\\\"\\n if self.operator is not None:\\n result = \\\"Operator: \\\" + self.operator + \\\"\\\\n\\\"\\n result += self.dictkey() + \\\"\\\\n\\\"\\n return result\",\n \"def toString(self):\\n \\n if not self.coeff_map:\\n raise Exception('no coeffs in constrain %s'%self.name)\\n \\n if self.result is None:\\n raise Exception('result of this constrain is unknown!')\\n \\n if self.name is None:\\n res=\\\"\\\"\\n else:\\n res=self.name+\\\": \\\"\\n \\n res+=coeff_sum(self.coeff_map) \\n \\n res+=self.op\\n res+=\\\" \\\"+str(self.result)\\n \\n return res;\",\n \"def __str__(self):\\n return self.get_equation()\",\n \"def _repr_latex_(self):\\n reprlatex = \\\"\\\"\\n if not self._terms:\\n reprlatex += \\\"0\\\"\\n else:\\n for term in self:\\n termlatex = term._reprlatex\\n if not reprlatex:\\n # Adding the first term. No leading +.\\n reprlatex += termlatex\\n else:\\n if not termlatex.startswith(\\\"-\\\"):\\n # Is it the first term added to the sum? No leading +.\\n reprlatex += f\\\"+ {termlatex}\\\"\\n else:\\n reprlatex += termlatex\\n\\n return f\\\"${reprlatex}$\\\"\",\n \"def __str__(self):\\n return \\\"chi1=%e chi2=%e m1=%e m2=%e distance=%e thetaJ=%e alpha0=%e chip=%e phic=%e fref=%e mode=%d freqs=[%e...%e]\\\" % (\\n self.chi1, self.chi2, self.m1 / lal.lal.MSUN_SI, self.m2 / lal.lal.MSUN_SI, self.distance / (lal.lal.PC_SI * 100 * 1e6), self.thetaJ, self.alpha0, self.chip, self.phic, self.fref, self.mode, self.freqs[0], self.freqs[-1])\",\n \"def __str__(self):\\n\\n rep = 'Generalized Syllogism:\\\\n'\\n rep += '\\\\ttask: {}\\\\n'.format(self.task)\\n rep += '\\\\tencoded_task: {}\\\\n'.format(self.encoded_task)\\n rep += '\\\\tp1: {}\\\\n'.format(self.p1)\\n rep += '\\\\tp2: {}\\\\n'.format(self.p2)\\n rep += '\\\\tquantifier_p1: {}\\\\n'.format(self.quantifier_p1)\\n rep += '\\\\tquantifier_p2: {}\\\\n'.format(self.quantifier_p2)\\n rep += '\\\\tfigure: {}\\\\n'.format(self.figure)\\n rep += '\\\\tTerms:\\\\n'\\n rep += '\\\\t\\\\tA: {}\\\\n'.format(self.A)\\n rep += '\\\\t\\\\tB: {}\\\\n'.format(self.B)\\n rep += '\\\\t\\\\tC: {}\\\\n'.format(self.C)\\n return rep\",\n \"def __str__(self):\\n # TODO check the terminal width and adjust the presentation\\n # only use for 1D, fall back to repr for ND\\n if self._hist.rank() == 1:\\n s = str(self._hist)\\n # get rid of first line and last character\\n s = s[s.index(\\\"\\\\n\\\") + 1 : -1]\\n else:\\n s = repr(self)\\n return s\",\n \"def toString(self):\\n return self.tokens.toString()\",\n \"def __str__ ( self ):\\n return self.get_label()\",\n \"def get_search_term(self) -> str:\\n search_term = self.args.get(\\\"q\\\", None)\\n if search_term is None:\\n logger.error(self.request_id, \\\"Search term not specified\\\", extra={\\\"status\\\": 400})\\n raise InvalidUsage(\\\"Search term not specified\\\")\\n return search_term\",\n \"def __str__(self):\\n return \\\"{} != {} ({})\\\".format(self.var1.name,\\n self.var2.name,\\n self.satisfied())\",\n \"def __str__(self):\\n\\n if self._s == '':\\n return ''\\n\\n if len(self.quote) == 1:\\n s = self.to_short()\\n else:\\n s = self.to_long()\\n\\n try:\\n eval(self.quote + s + self.quote)\\n except UnicodeDecodeError:\\n if self._safe_mode:\\n raise\\n\\n self._safe_mode = True\\n\\n assert eval(self.quote + s + self.quote) == self._s\\n\\n return s\",\n \"def get_str ( self ):\\n value = self.value\\n def gen_words():\\n if value == self.OV_NONE:\\n yield \\\"none\\\"\\n else:\\n if value & self.OV_SYM_EXIST:\\n if value & self.OV_SYM_DEAD:\\n yield \\\"symlinks\\\"\\n else:\\n yield \\\"symlinks to existing files\\\"\\n elif value & self.OV_SYM_DEAD:\\n yield \\\"broken symlinks\\\"\\n\\n if value & self.OV_FILE:\\n yield \\\"files\\\"\\n # --- end of gen_words (...) ---\\n\\n return ', '.join ( gen_words() ) + \\\" (0x{:x})\\\".format ( value )\",\n \"def get_content_as_string(self):\\n return \\\" \\\".join([token.word for token in self.tokens])\",\n \"def text(self):\\n if self.is_root:\\n return ''\\n elif self.is_comment:\\n return self.__value\\n elif self.is_flag:\\n if self.__value:\\n return '[{0}]'.format(self.name)\\n else:\\n return '!{0}!'.format(self.name)\\n else:\\n return '[{0}:{1}]'.format(self.name, self.value)\",\n \"def __str__(self):\\n s = \\\"\\\"\\n s += self.synset.name + \\\"\\\\t\\\"\\n s += \\\"PosScore: %s\\\\t\\\" % self.pos_score\\n s += \\\"NegScore: %s\\\" % self.neg_score\\n return s\",\n \"def __str__(self):\\n return 'Tokenizer({type}, {value})'.format(\\n type=self.type,\\n value=repr(self.value)\\n )\",\n \"def __str__(self):\\n\\n if self._b == b'':\\n return ''\\n\\n if len(self.quote) == 1:\\n s = self.to_short()\\n else:\\n s = self.to_long()\\n\\n assert eval('b' + self.quote + s + self.quote) == self._b\\n\\n return s\",\n \"def getUniStr(self):\\n return(\\\"%s/%s\\\"%(Entity.getUniStr(self),self.semanticId))\",\n \"def _repr_(self):\\n ending = \\\"\\\"\\n if str(self.t)!='t':\\n ending = ' with t=%s'%(self.t)\\n return \\\"%s-Bounded Quotient of Symmetric Functions over %s\\\"%(self.k, self.base_ring())+ending\",\n \"def get_feature_string_by_document(self, _set, document):\\n label = self.sets[_set][document]['label']\\n line = \\\"{} \\\".format(label)\\n for word in self.sets[_set][document]['words']:\\n line += \\\"{}:{} \\\".format(self.dictionary[word]['id'],tfidf.tfidf(word, document, self))\\n line += \\\"\\\\n\\\"\\n return line\",\n \"def __str__(self):\\n return self.get_ascii_trunk() + self.get_ascii_leaves()\",\n \"def to_string(self):\\n return \\\" \\\".join(self._words)\",\n \"def __str__(self):\\n # Use 'Unknown' if the course instance does not have a term\\n if self.course_instance.term:\\n term = self.course_instance.term.verbose_name()\\n else:\\n term = 'Unknown'\\n\\n exam_unicode = '{term} {number} {type} for {course}'.format(\\n term=term,\\n number=self.get_exam_number_display(),\\n type=self.get_exam_type_display(),\\n course=self.course_instance.course)\\n if self.instructors:\\n instructors = ', '.join([i.last_name for i in self.instructors])\\n return '{}, taught by {}'.format(exam_unicode, instructors)\\n else:\\n return '{} (Instructors Unknown)'.format(exam_unicode)\",\n \"def term(self) -> Optional['outputs.SaasPropertiesResponseTerm']:\\n return pulumi.get(self, \\\"term\\\")\",\n \"def __str__(self):\\n return str(self._value) + ' ' + str(self.unit.get_symbol())\",\n \"def __str__(self):\\n if self.reference is None:\\n return '%s - %s - %s' % (self.name, self.qualifier, self.location)\\n else:\\n return '%s - %s - %s - %s' % (self.name, self.qualifier, self.location, self.reference)\",\n \"def full_string(self):\\n return \\\"{}: {}\\\".format(str(self.word), \\\" \\\".join([str(adj) for adj in self.adjectives]))\",\n \"def toString():\",\n \"def string(self):\\n return self._my_string\",\n \"def __str__(self):\\n return str(self.tag)\",\n \"def word(self):\\n return str(self.name.names[-1])\",\n \"def optstr(self) -> str:\\n typestr: str = (\\n self.typestr().upper() if self.type_frozen else self.typestr()\\n )\\n if not self.ns_param or not self.argname_shorten:\\n # * makes sure it's not wrapped\\n return (\\n self.namestr()\\n if self.is_help\\n else f\\\"{self.namestr()}*<{typestr}>\\\"\\n )\\n\\n ret: List[str] = []\\n for term in sorted(self.terminals, key=len):\\n ret.append(f\\\"~<ns>.{term}\\\")\\n return \\\", \\\".join(ret) + f\\\"*<{typestr}>\\\"\",\n \"def visit_StringNode(self, node: StringNode, symbol_table: SymbolTable) -> String:\\n return String(node.tok.value)\",\n \"def get_text( self, ):\\n a_string = self.a_string_var.get( )\\n return a_string\",\n \"def get_text( self, ):\\n a_string = self.a_string_var.get( )\\n return a_string\",\n \"def __str__(self):\\n\\t\\tif self.code == Const.NEWLINE:\\n\\t\\t\\treturn \\\"[newline]\\\"\\n\\t\\t\\n\\t\\tname = \\\"[\\\" + self.code\\n\\t\\tif self.code in (Const.numericalLiteral, Const.ID, Const.UET):\\n\\t\\t\\tname += \\\"(\\\" + self.value + \\\")\\\"\\n\\t\\tname += \\\"]\\\"\\n\\t\\treturn name\",\n \"def __str__(self):\\n assert not hasattr(self, \\\"value\\\")\\n if self.is_set:\\n return \\\"%s \\\" % self.names[0]\\n else:\\n return \\\"\\\"\",\n \"def __repr__(self) -> str:\\n return f\\\"{self.text}\\\"\",\n \"def get_british_term_definition(word: str) -> str:\\n word = process_word(word)\\n return BRITISH_ENGLISH_ONLY_TERMS[word]\",\n \"def __str__( self ) :\\n\\n return( ' '.join( [ \\\"%g\\\" % c_l for c_l in self.coefficients ] ) )\",\n \"def as_string (self) :\\n\\n if self.is_machinetag() :\\n return \\\"%s:%s=%s\\\" % (self.namespace(), self.predicate(), self.value())\",\n \"def GetSynonymTerm(con, cur, synonym):\\n err, termid = GetSynonymTermId(con, cur, synonym)\\n if err:\\n debug(2, 'ontology term %s is not a synonym' % synonym)\\n return err, str(termid)\\n err, term = dbidval.GetDescriptionFromId(con, cur, 'ontologyTable', termid)\\n if err:\\n debug(3, 'ontology term not found for termid %d (synonym %s)' % (termid, synonym))\\n return err, term\\n return '', term\",\n \"def literal_to_string(self, literal):\\n s = '!' if is_negated(literal) else ''\\n return s + self.variables[literal >> 1]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.701907","0.6807694","0.6807694","0.63728356","0.6359468","0.6359468","0.6359468","0.6359468","0.6359468","0.6359468","0.6359468","0.6359468","0.6359468","0.63586587","0.6223569","0.6177496","0.61670923","0.6108228","0.6096044","0.60886693","0.60877323","0.60554177","0.60402","0.60372484","0.59847575","0.5970998","0.5950238","0.5876445","0.5828525","0.5811192","0.58013207","0.5801168","0.57808447","0.5711293","0.5656968","0.5656968","0.5656968","0.5656098","0.56542605","0.56231594","0.5611664","0.5605182","0.559611","0.55914366","0.5572952","0.55691314","0.55530816","0.5552376","0.5532899","0.55201286","0.55116653","0.55059385","0.54944074","0.5492996","0.54883","0.54861283","0.5475586","0.546941","0.546001","0.54539454","0.54349464","0.54312193","0.5430168","0.54276913","0.54167485","0.54137886","0.5401285","0.5397057","0.5381062","0.53670335","0.53535825","0.53519475","0.53482574","0.5345869","0.53436804","0.53413814","0.5341341","0.53386384","0.53184325","0.53141654","0.5308915","0.53068686","0.5305999","0.5297375","0.5293081","0.5290398","0.5290263","0.52887326","0.52864236","0.52847105","0.5274349","0.5274349","0.5270242","0.5270103","0.5262256","0.52596885","0.5258632","0.5255125","0.52550477","0.52530295"],"string":"[\n \"0.701907\",\n \"0.6807694\",\n \"0.6807694\",\n \"0.63728356\",\n \"0.6359468\",\n \"0.6359468\",\n \"0.6359468\",\n \"0.6359468\",\n \"0.6359468\",\n \"0.6359468\",\n \"0.6359468\",\n \"0.6359468\",\n \"0.6359468\",\n \"0.63586587\",\n \"0.6223569\",\n \"0.6177496\",\n \"0.61670923\",\n \"0.6108228\",\n \"0.6096044\",\n \"0.60886693\",\n \"0.60877323\",\n \"0.60554177\",\n \"0.60402\",\n \"0.60372484\",\n \"0.59847575\",\n \"0.5970998\",\n \"0.5950238\",\n \"0.5876445\",\n \"0.5828525\",\n \"0.5811192\",\n \"0.58013207\",\n \"0.5801168\",\n \"0.57808447\",\n \"0.5711293\",\n \"0.5656968\",\n \"0.5656968\",\n \"0.5656968\",\n \"0.5656098\",\n \"0.56542605\",\n \"0.56231594\",\n \"0.5611664\",\n \"0.5605182\",\n \"0.559611\",\n \"0.55914366\",\n \"0.5572952\",\n \"0.55691314\",\n \"0.55530816\",\n \"0.5552376\",\n \"0.5532899\",\n \"0.55201286\",\n \"0.55116653\",\n \"0.55059385\",\n \"0.54944074\",\n \"0.5492996\",\n \"0.54883\",\n \"0.54861283\",\n \"0.5475586\",\n \"0.546941\",\n \"0.546001\",\n \"0.54539454\",\n \"0.54349464\",\n \"0.54312193\",\n \"0.5430168\",\n \"0.54276913\",\n \"0.54167485\",\n \"0.54137886\",\n \"0.5401285\",\n \"0.5397057\",\n \"0.5381062\",\n \"0.53670335\",\n \"0.53535825\",\n \"0.53519475\",\n \"0.53482574\",\n \"0.5345869\",\n \"0.53436804\",\n \"0.53413814\",\n \"0.5341341\",\n \"0.53386384\",\n \"0.53184325\",\n \"0.53141654\",\n \"0.5308915\",\n \"0.53068686\",\n \"0.5305999\",\n \"0.5297375\",\n \"0.5293081\",\n \"0.5290398\",\n \"0.5290263\",\n \"0.52887326\",\n \"0.52864236\",\n \"0.52847105\",\n \"0.5274349\",\n \"0.5274349\",\n \"0.5270242\",\n \"0.5270103\",\n \"0.5262256\",\n \"0.52596885\",\n \"0.5258632\",\n \"0.5255125\",\n \"0.52550477\",\n \"0.52530295\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5575014"},"document_rank":{"kind":"string","value":"44"}}},{"rowIdx":79095,"cells":{"query":{"kind":"string","value":"Simplifies a term and its subterms, using NAL Theorems."},"document":{"kind":"string","value":"def simplify(term):\n simplified_term = term\n\n if isinstance(term,StatementTerm):\n simplified_term = StatementTerm(subject_term=simplify(term.get_subject_term()),\n predicate_term=simplify(term.get_predicate_term()),\n copula=term.get_copula(),\n interval=term.interval)\n elif isinstance(term,CompoundTerm):\n if term.connector == NALSyntax.TermConnector.Negation and \\\n len(term.subterms) == 1 and \\\n isinstance(term.subterms[0],CompoundTerm) and \\\n term.subterms[0].connector == NALSyntax.TermConnector.Negation :\n # (--,(--,(S --> P)) <====> (S --> P)\n # Double negation theorem. 2 Negations cancel out\n simplified_term = simplify(term.subterms[0].subterms[0]) # get the inner statement\n # elif NALSyntax.TermConnector.is_conjunction(term.connector):\n # #(&&,A,B..C)\n # new_subterms = []\n # new_intervals = []\n # for i in range(len(term.subterms)):\n # subterm = simplify(term.subterms[i])\n # if i < len(term.intervals): new_intervals.append(term.intervals[i])\n # if isinstance(subterm, CompoundTerm) and subterm.connector == term.connector:\n # # inner conjunction\n # new_subterms.extend(subterm.subterms)\n # new_intervals.extend(subterm.intervals)\n # else:\n # new_subterms.append(subterm)\n #\n # simplified_term = CompoundTerm(subterms=new_subterms,\n # term_connector=term.connector,\n # intervals=new_intervals)\n elif term.connector is NALSyntax.TermConnector.ExtensionalDifference:\n pass\n elif term.connector is NALSyntax.TermConnector.IntensionalDifference:\n pass\n elif term.connector is NALSyntax.TermConnector.ExtensionalImage:\n pass\n elif term.connector is NALSyntax.TermConnector.IntensionalImage:\n pass\n\n\n return simplified_term"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def simplify(self, text: str):\n # sanitise the input, remove common words and swap out similar words\n text = self.sanitise(text)\n # Decided not to use stopwords because that would take out too many and then get false positives\n common_words = [\"what\", \"i\", \"you\", \"do\", \"a\", \"thing\", \"of\", \"was\", \"would\", \"were\", \"are\", \"been\"\n \"reddit\", \"why\",\n \"your\", \"it\", \"is\", \"the\", \"that\", \"has\", \"had\", \"for\", \"at\", \"in\", \"on\",\n \"with\", \"if\", \"to\", \"be\", \"and\", \"some\"]\n for common_word in common_words:\n text = text.replace(\" \" + common_word + \" \", \" \")\n\n # Replace common synonyms\n synonyms = [[\"funniest\", \"funny\", \"hilarious\"], [\"food\", \"diet\"], [\"life\", \"lifetime\"],\n [\"stop\", \"end\", \"quit\"], [\"advice\", \"help\"],\n [\"grossest\", \"worst\"], [\"buy\", \"bought\", \"purchase\"],\n [\"scary\", \"scariest\", \"spookiest\"]]\n for synonym in synonyms:\n for word in synonym:\n text = text.replace(\" \" + word + \" \", \" \" + synonym[0] + \" \")\n\n # Stem words\n from nltk.stem.porter import PorterStemmer\n ps = PorterStemmer()\n text = text.split()\n text = [ps.stem(word) for word in text]\n text = \" \".join(text)\n text = \" \" + text + \" \"\n\n # Missed words that still need to be stemmed:\n text = text.replace(\" given \", \" give \")\n text = text.replace(\" younger \", \" young \")\n\n return text","def _simpl_pono_term(term: Term, resolvers) -> Term:\n\n sums_dict = dict(term.sums)\n other, wigner_3js = _parse_3js(term.amp)\n jms, rels = _get_jms_rels(wigner_3js)\n\n new_other = _simpl_pono(\n other, resolvers, sums_dict, jms, rels, sums_only=False\n )\n\n new_amp = new_other * prod_(\n i.expr for i in wigner_3js\n )\n\n return Term(term.sums, new_amp, term.vecs)","def organizeTerms_fromOriginal(self):\n self.LHS = []\n\n # LHS: [ ]\n # LHS: [ term1, term2, term3 ]\n # LHS: [ ( ), ( ), ( ) ]\n # LHS: [ ( item1, item2, item3 ), term2, term3 ]\n # _______________ _______________ __\n # LHS: [ ( (obj1, 'attr1'), (obj2, 'attr2'), 20 ), term2, term3 ]\n\n\n # Expand brackets\n def someTermsHaveListItems():\n for term in self._LHS_original:\n if any(isinstance(item, list) for item in term):\n return True\n return False\n\n while someTermsHaveListItems():\n for termIndex, Term in enumerate(self._LHS_original):\n newTerms_toAdd = []\n listItems_inTerm = [item for item in Term if isinstance(item, list)]\n hasListItems = len(listItems_inTerm) > 0\n\n for listItem_inTerm in listItems_inTerm:\n otherItems_inTerm = tuple(item for item in Term if item is not listItem_inTerm) # otherItems_inTerm are all multiplied items\n for term in listItem_inTerm:\n assert isinstance(term, tuple) # isolated term in format (const, [unknowns])\n # coeff unknown addresses unpacked from unknowns list\n newTerms_toAdd.append( otherItems_inTerm + (term[0],) + tuple(unknownAddress for unknownAddress in term[1]) )\n break # process one list item in the term at once\n\n if hasListItems:\n for newTerm_toAdd in reversed(newTerms_toAdd):\n self._LHS_original.insert(termIndex, newTerm_toAdd)\n self._LHS_original.remove(Term)\n break # process one term and break\n # Brackets expanded.\n\n for term in self._LHS_original: # each term is a tuple as all brackets expanded above\n constantFactors = []\n unknownFactors = []\n\n for item in term: # items within the term are to be multiplied\n\n if isinstance(item, tuple):\n # item is an object.attribute address, in form (object, 'attribute')\n assert isinstance(item[1], str)\n\n attribute = getattr_fromAddress(*item)\n if isNumeric(attribute):\n # If the object.attribute has a value, add it to constant factors\n constantFactors.append(attribute)\n else:\n # If the object.attribute does not have a value, it is an unknownFactor\n # TODO - the following check may be accommodated to have equation solved if the high-power term is found in another equation\n assert item not in unknownFactors, 'LinearEquationError: Same unknown appears twice in one term, i.e. a higher power of the unknown encountered - not a linear equation!'\n unknownFactors.append(item)\n\n elif any(isinstance(item, _type) for _type in [float, int]):\n # item is a number, i.e. a coefficient\n assert isNumeric(item)\n constantFactors.append(item)\n\n constantFactor = 1\n for factor in constantFactors:\n constantFactor *= factor\n\n if len(unknownFactors) != 0:\n # term has an unknown, e.g. term is in form of \"6*x\"\n self.LHS.append([constantFactor, unknownFactors])\n else:\n # term does not have an unknown, e.g. term is in form \"6\"\n self.RHS -= constantFactor # move constant term to the RHS\n\n self._gatherUnknowns()","def normalize(term):\n if isinstance(term, spacy.tokens.token.Token):\n return term.text if term.pos_ == 'PROPN' else term.lemma_\n elif isinstance(term, spacy.tokens.span.Span):\n return ' '.join(word.text if word.pos_ == 'PROPN' else word.lemma_\n for word in term)\n else:\n msg = \"Normalization requires a Token or Span, not {}.\".format(type(term))\n raise TypeError(msg)","def simple_lemmatise(subword_dict):\n return norm_word_id(subword_dict[\"word_id\"])","def simplify(phrase):\n list_phrase = phrase.split()\n \n first_noun = list_phrase[0:2]\n first_verb = list_phrase[-1]\n rest_list_phrase = list_phrase [2:-1]\n \n rest_phrase = phrase[len(first_noun[0] + first_noun[1]) + 2 :\n (-1 * len(first_verb)) - 1]\n #We calculate the length of the first two words and add 2 for the\n #number of spaces to start from the beginning of the rest of the phrase\n #and end at the beginning of the space before the last word by\n #subtracting the length of the last word by 1.\n \n #This is done because we are dealing with lists and strings concurrently.\n \n if len(rest_phrase) == 0:\n return first_noun[0] + \" \" + first_noun[1]\n \n return (simplify(rest_phrase) + \" that \" + first_verb + \" \" +\n first_noun[0] + \" \" + first_noun[1])","def _normal_ordered_term(term, coefficient):\n term = list(term)\n ordered_term = FermionOperator()\n for i in range(1, len(term)):\n for j in range(i, 0, -1):\n left_sub_term = term[j - 1]\n right_sub_term = term[j]\n # Swap operators if left operator is annihilation op and right operator is\n # a\\dagger operator\n if not left_sub_term[1] and right_sub_term[1]:\n term[j], term[j - 1] = left_sub_term, right_sub_term\n coefficient = coefficient * -1\n # If indice are same, employ the anti-commutation relationship\n # And generate the new term\n if left_sub_term[0] == right_sub_term[0]:\n new_term = term[:(j - 1)] + term[(j + 1):]\n ordered_term += _normal_ordered_term(\n new_term, -coefficient)\n # Deal with the case with same operator\n elif left_sub_term[1] == right_sub_term[1]:\n # If indice are same,evaluate it to zero.\n if left_sub_term[0] == right_sub_term[0]:\n return ordered_term\n # Swap them if same operator but lower index on left\n if left_sub_term[0] < right_sub_term[0]:\n term[j], term[j - 1] = left_sub_term, right_sub_term\n coefficient = coefficient * -1\n\n # Add the term and return.\n ordered_term += FermionOperator(tuple(term), coefficient)\n return ordered_term","def update(self):\n\n terms_toRemove = []\n\n for termIndex, [term_constantFactor, term_unknowns_attributeAddresses] in enumerate(self.LHS):\n\n # Check if coefficient is 0 - then no need to process any of the unknowns since term will be 0 anyways\n if term_constantFactor == 0:\n terms_toRemove.append(termIndex)\n continue # continue to next term, no need to resolve the unknowns of this term since the product will be 0 anyways\n\n # Check if any unknowns became known\n unknowns_toRemove = []\n for unknown_attributeAddress in term_unknowns_attributeAddresses:\n attribute = getattr_fromAddress(*unknown_attributeAddress)\n if isNumeric(attribute):\n # object.attribute which had previously been identified as unknown now has a value, add it to the constant factor product and remove from the unknowns\n self.LHS[termIndex][0] *= attribute # multiply it with the constant factor product\n unknowns_toRemove.append([termIndex, unknown_attributeAddress])\n for termIndex, unknown_attributeAddress in unknowns_toRemove: # remove unknowns which have become known in the end\n # removing in the end not to tamper with the iteration of the above loop\n self.LHS[termIndex][1].remove(unknown_attributeAddress)\n\n # Move constants to RHS\n if self.LHS[termIndex][1] == []:\n # if term has no unknowns, it is a constant, move to RHS\n self.RHS -= self.LHS[termIndex][0]\n self.LHS.pop(termIndex)\n\n for termIndex in reversed(terms_toRemove): # reversed - otherwise would tamper with indices of items identified for removal\n self.LHS.pop(termIndex)\n\n self._gatherUnknowns()","def subst_i(term):\n return Term(term.sums, term.amp.xreplace({i: k}), term.vecs)","def simplify(phrase):\n \n num_actors = 0\n \n if phrase == \"\":\n return 0\n \n phrase_list = phrase.split()\n\n for word in phrase_list:\n if word == \"the\":\n num_actors += 1\n \n index = (2 * num_actors) - 1\n actor = phrase_list[index]\n verb = phrase_list[index + 1]\n \n del phrase_list[index]\n del phrase_list[index - 1]\n del phrase_list[index + 1]\n \n phrase_string = \"\"\n for word in phrase_list:\n phrase_string += word\n phrase_string += \" \"\n \n \n return \"the\" + actor + \"that\" + verb + simplify(phase_string)","def deep_simplify(tensor: Tensor):\n\n # Initial simplification.\n res = tensor.simplify()\n # This can possibly reduce the number of terms.\n res = res.merge_j()\n res = res.simplify_am()\n\n # Final trial.\n res = res.simplify().merge_j()\n\n return res","def simplify(self):\n if 0 in self.numer:\n self.numer = [0, ]\n self.denom = []\n self.neg = False\n return\n # Eliminate common factors:\n for factor in set(self.numer):\n # number of shared occurrences:\n count = min(self.denom.count(factor),\n self.numer.count(factor))\n # Remove each shared occurrence:\n for i in range(count):\n self.numer.remove(factor)\n self.denom.remove(factor)","def visit_term(self, node, children):\n if self.debug:\n print(\"Term {}\".format(children))\n term = children[0]\n for i in range(2, len(children), 2):\n if children[i-1] == \"*\":\n term *= children[i]\n else:\n term /= children[i]\n if self.debug:\n print(\"Term = {}\".format(term))\n return term","def correct_subscript(sv, tree):\r\n if not tree or tree[0]!=Special: return tree\r\n O, A, B=tree # subscripting ( e.g. cumul(L)(0) ) \r\n O=tree_join(A) # make operator from first term \r\n A, B = B, None # make subscript from second term\r\n return O, A, B","def build_sublemma_index(self):\n terms = []\n with open(self.path_lemma_terms, 'r', encoding='utf8') as f:\n for line in f:\n term = line.strip('\\n')\n terms.append(term)\n terms = set(terms)\n for term in terms:\n term_list = term.split('_')\n subterms = get_sublists(term_list)\n self.sublemma_index[term] = [t for t in subterms if t in terms]","def _simplification_technique_1(rels):\n rels = list(set(rels))\n rels.sort()\n l_rels = len(rels)\n\n # all syllables with single syllable\n one_syllable_rels = set()\n # since \"nw\" has a max size = l_rels, only identity element\n # removal can possibly happen\n nw = [None]*l_rels\n for i in range(l_rels):\n w = rels[i].identity_cyclic_reduction()\n if w.number_syllables() == 1:\n\n # replace one syllable relator with the corresponding inverse\n # element, for ex. x**-4 -> x**4 in relator list\n if w.array_form[0][1] < 0:\n rels[i] = w**-1\n one_syllable_rels.add(rels[i])\n\n # since modifies the array rep., so should be\n # added a list\n nw[i] = list(rels[i].array_form)\n\n # bound the exponent of relators, making use of the single\n # syllable relators\n for i in range(l_rels):\n k = nw[i]\n rels_i = rels[i]\n for gen in one_syllable_rels:\n n = gen.array_form[0][1]\n gen_arr0 = gen.array_form[0][0]\n j = len(k) - 1\n while j >= 0:\n if gen_arr0 == k[j][0] and gen is not rels_i:\n t = Mod(k[j][1], n)\n\n # multiple of one syllable relator\n if t == 0:\n del k[j]\n zero_mul_simp(k, j - 1)\n j = len(k)\n\n # power should be bounded by (-n/2, n/2]\n elif t <= n/2:\n k[j] = k[j][0], Mod(k[j][1], n)\n elif t > n/2:\n k[j] = k[j][0], Mod(k[j][1], n) - n\n j -= 1\n\n return nw","def removeSameTerms(lines):\r\n flag_main = 0\r\n line_depth = find_depth(lines)\r\n\r\n i = 0\r\n while i < len(lines):\r\n subst_dict = {}\r\n j = i + 1\r\n while j < len(lines):\r\n if set(lines[i][1:3]) == set(lines[j][1:3]): # same function detected\r\n flag_main = 1\r\n if 'y' in lines[j][0]: # taking care of the special case\r\n subst_dict[lines[i][0]] = lines[j][0]\r\n else: # 'y' in lines[i][0] is covered in this case too\r\n subst_dict[lines[j][0]] = lines[i][0]\r\n \r\n # deletion\r\n if line_depth[i] < line_depth[j]:\r\n del lines[j]\r\n else:\r\n del lines[i]\r\n \r\n # substitution\r\n for k in range(len(lines)):\r\n if lines[k][0] in subst_dict.keys():\r\n lines[k][0] = subst_dict[lines[k][0]]\r\n elif lines[k][1] in subst_dict.keys():\r\n lines[k][1] = subst_dict[lines[k][1]]\r\n elif lines[k][2] in subst_dict.keys():\r\n lines[k][2] = subst_dict[lines[k][2]]\r\n \r\n # restart the whole loop after substitution\r\n i = -1\r\n break\r\n j += 1\r\n i += 1\r\n \r\n # reorganise the order\r\n reorgOrder(lines)\r\n # renaming in order\r\n renaming(lines)\r\n \r\n return flag_main","def simplify_nature(sv, tot, done):\r\n prev=tot\r\n # one pass to get rid of list nature\r\n if done: \r\n for nod in sv.Object.values():\r\n if len(nod.nature)==2 and Lst[0] in nod.nature: # not a list unless proved otherwise\r\n nod.nature.remove(Lst[0])\r\n prev-=1\r\n done=False # continue search \r\n\r\n # one pass to infer a state\r\n if done: \r\n for nod in sv.Object.values():\r\n if len(nod.nature)>1 and Stt[0] in nod.nature: # a state unless proved otherwise \r\n prev-=len(nod.nature)-1\r\n nod.nature=Stt[:]\r\n done=False # continue search \r\n\r\n return prev, done","def simplify(word, lexicon):\n\tsim = random.choice(lexicon[word])[1]\n\tif type(sim) == str:\n\t\tsim = [sim]\n\treturn \" \".join(sim)","def normalize_word(self, word, treebank_tag):\n wordnet_pos, part_of_speech = self.get_wordnet_pos(treebank_tag)\n\n if wordnet_pos == wordnet.NOUN and part_of_speech == 'proper':\n return word, 'proper_noun'\n\n lemword = self.wordnetlemmatize.lemmatize(word, wordnet_pos)\n return self.stemmer.stem(lemword), part_of_speech","def normalization(obj):\n dic = obj.mainfield.para_dict.copy()\n for item in obj.forfield: dic.update(item.para_dict)\n for item in obj.existfield: dic.update(item.para_dict)\n\n global_dic = number_type(dic)\n obj.normal_guards = norm_rep(global_dic, obj.all_sentence)\n\n main_dic = number_type(obj.mainfield.para_dict)\n obj.mainfield.content = norm_rep(main_dic, obj.mainfield.content)\n\n for index in range(len(obj.forfield)):\n obj.forfield[index].para_dict.update(obj.mainfield.para_dict)\n # temp_dic.update(obj.mainfield.para_dict)\n # for_dic = number_type(temp_dic)\n obj.forfield[index].content = norm_rep(global_dic, obj.forfield[index].content)\n print(global_dic, obj.forfield[index].para_dict)\n obj.forfield[index].para_dict = pair_2_dict(global_dic, obj.forfield[index].para_dict)\n\n for index in range(len(obj.existfield)):\n obj.existfield[index].para_dict.update(obj.mainfield.para_dict)\n # temp_dic.update(obj.mainfield.para_dict)\n # exist_dic = number_type(temp_dic)\n obj.existfield[index].content = norm_rep(global_dic, obj.existfield[index].content)\n obj.existfield[index].para_dict = pair_2_dict(global_dic, obj.existfield[index].para_dict)\n\n # change para_dict: {'i':'NODE} -> {'NODE_1', 'NODE'}\n obj.mainfield.para_dict = pair_2_dict(global_dic, obj.mainfield.para_dict)","def simplify_am(self, tensor: Tensor):\n\n tensor = tensor.map2amps(_rewrite_cg)\n\n # Initial simplification of some summations.\n tensor = tensor.simplify_sums(\n simplifiers=self._am_sum_simplifiers.bcast\n )\n\n # Deltas could come from some simplification rules.\n tensor = tensor.simplify_deltas()\n\n # Some summations could become simplifiable after the delta resolution.\n tensor = tensor.simplify_sums()\n\n return tensor","def clean_text_subroutine(text, thing, suffix):\n\n # Synonyms + skipping optional part of the sentence\n clean_text = skip_and_replace_phrases(text)\n\n # Remove full stop, empty spaces, capitalize the start letter.\n clean_text = re.sub(' +', ' ', clean_text.replace(suffix, '').strip(' '))\n # First replace 'a thing' -> 'an object'.\n # Then perform remaining actions.\n if thing == 'object':\n clean_text = clean_text.replace('a thing', 'an object')\n clean_text = clean_text.replace('thing', thing)\n clean_text = clean_text[0].upper() + clean_text[1:] + suffix\n return clean_text","def nom_struc_rebuilding(nom_struc):\n\n #init\n nominal_structure = ns = nn = []\n i = 0\n\n while i < len(nom_struc):\n\n if nom_struc[i]._quantifier == 'SOME' and (nom_struc[i].det == ['a'] or nom_struc[i].det == ['an']):\n nom_struc[i]._quantifier = 'ONE'\n\n #The first nominal group not preceded but 'and' if there is\n if nom_struc[i]._conjunction == 'AND' and i > 0:\n nominal_structure = nominal_structure + ['and']\n elif nom_struc[i]._conjunction == 'OR':\n nominal_structure = nominal_structure + ['or']\n elif nom_struc[i]._conjunction == 'BUT':\n nominal_structure = nominal_structure + ['but']\n\n #We recover the nominal group and his complement\n if nom_struc[i]._quantifier == 'SOME' or nom_struc[i]._quantifier == 'ALL' or nom_struc[\n i]._quantifier == 'ANY' or (nom_struc[i]._quantifier == 'DIGIT' and nom_struc[i].det != 'one'):\n #If there is a specific quantifier (plural)\n for n in ResourcePool().plural_nouns:\n if nom_struc[i].noun != [] and n[1] == nom_struc[i].noun[0]:\n nn = [n[0]]\n\n #If it is not a specific plural, we add 's'\n if nom_struc[i].noun != [] and nn == []:\n nn = [nom_struc[i].noun[0] + 's']\n\n #We reconver the other information \n nominal_structure = nominal_structure + nom_struc[i].det\n for z in nom_struc[i].adj:\n nominal_structure = nominal_structure + z[1] + [z[0]]\n nominal_structure = nominal_structure + nn\n\n #Re-init\n nn = []\n\n else:\n #if not plural\n nominal_structure = nominal_structure + nom_struc[i].det\n for z in nom_struc[i].adj:\n nominal_structure = nominal_structure + z[1] + [z[0]]\n nominal_structure = nominal_structure + nom_struc[i].noun\n\n #We recover noun complement\n if nom_struc[i].noun_cmpl:\n nominal_structure = nominal_structure + ['of']\n nominal_structure = nominal_structure + nom_struc_rebuilding(nom_struc[i].noun_cmpl)\n\n #We recover the relative\n for j in nom_struc[i].relative:\n if not j.sn:\n ns = [nom_struc[i]]\n\n nominal_structure = nominal_structure + [j.aim] + sentence_rebuilding.relative(j, ns)\n ns = []\n\n i += 1\n return nominal_structure","def simplify(cnf, lit):\n for clause in cnf:\n for l in clause:\n if l.equals(lit):\n cnf.remove(clause)\n break\n elif l.is_opposite(lit):\n clause.remove(l)\n return cnf","def substitution(formula, old_subformula, new_subformula):\n pass\n # ======== YOUR CODE HERE ========","def clean_term(term, site='', siteWordCount=None, dataType=''): # dtype\n if pd.isna(term): \n print(\"(clean_term) Input term is NaN: {}\".format(term))\n return ''\n if not isinstance(term, str): \n return str(term)\n\n insigWords = LoincTable.stop_words # [\"IN\", \"FROM\", \"ON\", \"OR\", \"OF\", \"BY\", \"AND\", \"&\", \"TO\", \"BY\", \"\", \" \"]\n \n modTerm = (term.replace(\"'\", \"\").replace(\",\", \" \").replace(\".\", \" \") \\\n .replace(\":\", \" \").replace('\\t', \" \").replace(\"^\", \" \").replace(\"+\", \" \")\\\n .replace(\"*\", \" \").replace(\"~\", \" \").replace(\"(\", \" \").replace(\")\", \" \")\\\n .replace(\"!\", \" \").replace(\"[\", \" \").replace(\"]\", \" \").replace(\"{\", \" \").replace(\"}\", \" \")\\\n .replace(\"_\", \" \").replace(\"|\", \" \").replace('\"', \" \").split(\" \"))\n\n #############################################################################\n i = 0\n while i < len(modTerm):\n modTerm[i] = re.sub(r\"\\d{1,2}[\\/-]\\d{1,4}([\\/-]\\d{2,4})*|\\d{6}\", \"\", modTerm[i])\n if modTerm[i] != None and len(modTerm[i]) > 0:\n i = i + 1\n else:\n modTerm.remove(modTerm[i])\n #############################################################################\n\n # remove repeated tokens \n modTerm = sorted(set(modTerm), key=modTerm.index)\n\n j = 0\n nameSplit = list()\n while j < len(modTerm):\n splits = modTerm[j].replace(\"/\", \" \").replace(\"\\\\\", \" \").replace(\"-\", \" \").split(\" \")\n k = 0\n while ((k < len(splits)) and (len(splits[k]) > 0) and (splits[k] not in insigWords)):\n newWord = splits[k].strip()\n nameSplit.append(newWord)\n\n if len(site) > 0 and isinstance(siteWordCount, dict): \n siteWordCount[site][newWord] += 1\n k = k + 1\n j = j + 1\n\n return \" \".join(nameSplit)","def _translate(s):\r\n\t\t\r\n\t\t# new term is determined by a space followed by + or -\r\n\t\t# replace with _ and split into terms\r\n\t\ts = s.replace(' +','_+')\r\n\t\ts = s.replace(' -','_-')\r\n\t\t\r\n\t\t# split string into terms\r\n\t\tp = s.split('_')\r\n\t\tt = [Te(i) for i in p]\r\n\t\t\r\n\t\treturn t","def normalize_answer(s):\n\n def remove_articles(text):\n return re_art.sub(' ', text)\n\n def white_space_fix(text):\n return ' '.join(text.split())\n\n def remove_punc(text):\n return re_punc.sub(' ', text) # convert punctuation to spaces\n\n def lower(text):\n return text.lower()\n\n return white_space_fix(remove_articles(remove_punc(lower(s))))","def normalize_answer(s):\n\n def remove_articles(text):\n return re_art.sub(' ', text)\n\n def white_space_fix(text):\n return ' '.join(text.split())\n\n def remove_punc(text):\n return re_punc.sub(' ', text) # convert punctuation to spaces\n\n def lower(text):\n return text.lower()\n\n return white_space_fix(remove_articles(remove_punc(lower(s))))","def correct_spelling(sample):\n words = nltk.word_tokenize(sample[\"full_text\"])\n for word in words:\n for char, duplicate_char in duplicate_chars.items():\n word = re.sub(duplicate_char, char, word)\n #sample[\"full_text\"] = ' '.join([spell(w)] for w in tweet.split()])\n sample[\"full_text\"] = ' '.join([w for w in words])\n return sample","def reindex_subcomponent_taxa():\n pass","def simplify_indices(kernel):\n from loopy.symbolic import SubstitutionRuleMappingContext as SRMC\n rule_mapping_context = SRMC(kernel.substitutions,\n kernel.get_var_name_generator())\n idx_simplifier = IndexSimplifier(rule_mapping_context, kernel)\n return rule_mapping_context.finish_kernel(idx_simplifier.map_kernel(kernel))","def normalize_answer(s):\n\n def remove_articles(text):\n return re.sub(r'\\b(a|an|the)\\b', ' ', text)\n\n def white_space_fix(text):\n return ' '.join(text.split())\n\n def remove_punc(text):\n exclude = set(string.punctuation)\n return ''.join(ch for ch in text if ch not in exclude)\n\n def lower(text):\n return text.lower()\n\n return white_space_fix(remove_articles(remove_punc(lower(normalize(s)))))","def morph_noun(word, number, a_an, feature):\n word = morph_number(word, number)\n if not (number in ['first', 'second']) and word[-1] == 's':\n return mark_noun_as_plural(word)\n else:\n return word\n\n if a_an == 'an':\n return mark_noun_as_an(word)\n else:\n return word","def normal_ordered_quad_term(term, coefficient, hbar=1.):\n # Iterate from left to right across operators and reorder to normal\n # form. Swap terms operators into correct position by moving from\n # left to right across ladder operators.\n term = list(term)\n ordered_term = QuadOperator()\n for i in range(1, len(term)):\n for j in range(i, 0, -1):\n right_operator = term[j]\n left_operator = term[j - 1]\n\n # Swap operators if q on right and p on left.\n # p q -> q p\n if right_operator[1] == 'q' and not left_operator[1] == 'q':\n term[j - 1] = right_operator\n term[j] = left_operator\n\n # Replace p q with i hbar + q p\n # if indices are the same.\n if right_operator[0] == left_operator[0]:\n new_term = term[:(j - 1)] + term[(j + 1)::]\n\n # Recursively add the processed new term.\n ordered_term += normal_ordered_quad_term(\n tuple(new_term), -coefficient * 1j * hbar)\n\n # Handle case when operator type is the same.\n elif right_operator[1] == left_operator[1]:\n\n # Swap if same type but lower index on left.\n if right_operator[0] > left_operator[0]:\n term[j - 1] = right_operator\n term[j] = left_operator\n\n # Add processed term and return.\n ordered_term += QuadOperator(tuple(term), coefficient)\n return ordered_term","def _sort_majorana_term(term):\n if len(term) < 2:\n return term, 0\n center = len(term) // 2\n left_term, left_parity = _sort_majorana_term(term[:center])\n right_term, right_parity = _sort_majorana_term(term[center:])\n merged_term, merge_parity = _merge_majorana_terms(left_term, right_term)\n return merged_term, (left_parity + right_parity + merge_parity) % 2","def _normalize_answer(s):\n\n def remove_articles(text):\n return re.sub(r'\\b(a|an|the)\\b', ' ', text)\n\n def white_space_fix(text):\n return ' '.join(text.split())\n\n def remove_punc(text):\n exclude = set(string.punctuation)\n return ''.join(ch for ch in text if ch not in exclude)\n\n def lower(text):\n return text.lower()\n\n return white_space_fix(remove_articles(remove_punc(lower(s))))","def normalise(word):\n\t\tword = word.lower()\n\t\tword = lemmatizer.lemmatize(word)\n\t\t# word = stemmer.stem_word(word)\n\t\treturn word","def normalize(s):\n def remove_articles(text):\n return re.sub(r'\\b(a|an|the)\\b', ' ', text)\n\n def white_space_fix(text):\n return ' '.join(text.split())\n\n# def remove_punc(text):\n# exclude = set(string.punctuation)\n# return ''.join(ch for ch in text if ch not in exclude)\n\n def lower(text):\n return text.lower()\n\n return white_space_fix(remove_articles(lower(s)))","def prepare_terms(terms, search_mode):\n if search_mode in (\"contains\", \"starts_with\"):\n terms = terms.replace(\"_\", \"\\_\").replace(\"%\", \"\\%\")\n\n if search_mode == \"contains\":\n terms = \"%\" + terms + \"%\"\n elif search_mode == \"starts_with\":\n terms = terms + \"%\"\n return terms","def __mul__(self, other, nested=False):\n\n other = formula(other, namespace=self.namespace)\n\n selftermnames = self.termnames()\n othertermnames = other.termnames()\n\n I = len(selftermnames)\n J = len(othertermnames)\n\n terms = []\n termnames = []\n\n for i in range(I):\n for j in range(J):\n termname = '%s*%s' % (str(selftermnames[i]), str(othertermnames[j]))\n pieces = termname.split('*')\n pieces.sort()\n termname = '*'.join(pieces)\n termnames.append(termname)\n\n selfnames = self.terms[i].names()\n othernames = other.terms[j].names()\n\n if self.terms[i].name is 'intercept':\n _term = other.terms[j]\n _term.namespace = other.namespace\n\n elif other.terms[j].name is 'intercept':\n _term = self.terms[i]\n _term.namespace = self.namespace\n else:\n names = []\n\n d1 = len(selfnames) \n d2 = len(othernames)\n\n for r in range(d1):\n for s in range(d2):\n name = '%s*%s' % (str(selfnames[r]), str(othernames[s]))\n pieces = name.split('*')\n pieces.sort()\n name = '*'.join(pieces)\n names.append(name)\n\n def product_func(value, d1=d1, d2=d2):\n\n out = []\n for r in range(d1):\n for s in range(d2):\n out.append(value[r] * value[d1+s])\n return N.array(out)\n\n sumterms = self + other\n sumterms.terms = [self, other] # enforce the order we want\n sumterms.namespace = self.namespace\n\n _term = quantitative(names, func=sumterms, termname=termname,\n transform=product_func)\n _term.namespace = self.namespace\n\n\n terms.append(_term)\n\n return formula(terms, namespace=self.namespace)","def _solve_double_synonym(parse_tree, solution_format=None):\n def _get_value(solution_list, word):\n # Gets the value of a word in a solution list\n for solution in solution_list:\n if solution[0] == word:\n return solution[1]\n\n return 0\n\n # Get the two synonym parts\n first_syn, second_syn = _get_parts_ignore_EQU(parse_tree)\n first_syn = _create_sentence(first_syn)\n second_syn = _create_sentence(second_syn)\n\n # Get top 1000 matching scores for each part of the clue\n if solution_format is not None:\n first_solutions = SimilaritySolver.solve(first_syn, length=solution_format.get_total_length(spaces=True))\n second_solutions = SimilaritySolver.solve(second_syn, length=solution_format.get_total_length(spaces=True))\n second_words = [word for word, _ in second_solutions if solution_format.check(word)]\n else:\n first_solutions = SimilaritySolver.solve(first_syn)\n second_solutions = SimilaritySolver.solve(second_syn)\n second_words = [word for word, _ in second_solutions]\n\n # Combine both lists, with the value being the product of the value for eac syn part\n solutions = [(solution[0], _get_value(second_solutions, solution[0]) * solution[1]) for\n solution in first_solutions if solution[0] in second_words]\n\n return solutions","def oversimplify(strng):\n s = strng.encode('latex').decode('utf-8')\n s = reg_simplify.sub('', s)\n return s","def _gen_terms(self, tree):\n for leaf in self._leaves(tree):\n terms = [self._normalize(w) for w, _ in leaf if self._filter(w)]\n # Phrase only\n if len(terms) > 1:\n yield terms","def spelling_normalization(words, dictionary):\n\n logging.debug('spelling_normalization(): Incoming words: ')\n logging.debug(words)\n\n def edits1(word):\n \"\"\"Return 1-edits away\"\"\"\n letters = 'abcdefghijklmnopqrstuvwxyz'\n\n def split_word(word):\n \"\"\"Returns all possible variations of word split up\"\"\"\n return [(word[:i], word[i:]) for i in range(len(word) + 1)]\n\n pairs = split_word(word)\n deletes = [a + b[1:] for (a, b) in pairs if b]\n transposes = [a + b[1] + b[0] + b[2:] for (a, b) in pairs if len(b) > 1]\n replaces = [a + c + b[1:] for (a, b) in pairs for c in letters if b]\n inserts = [a + c + b for (a, b) in pairs for c in letters]\n return set(deletes + transposes + replaces + inserts)\n\n def edits2(word):\n \"\"\"Return 2-edits away\"\"\"\n return {e2 for e1 in edits1(word) for e2 in edits1(e1)}\n\n def known(words):\n return {w for w in words if w in dictionary}\n\n corrected = []\n for word in words:\n if word.isnumeric():\n corrected.append(word)\n continue\n elif word in dictionary or wordnet.synsets(word):\n corrected.append(word)\n continue\n else: # Doesn't seem to be necessary, but will be guard clause; seem to have some suspicious deletions\n candidates = (known(edits1(word)) or\n known(edits2(word)) or\n [word])\n corrected.append(max(candidates, key=dictionary.get))\n logging.debug('spelling_normalization(): Outgoing words:')\n logging.debug(corrected)\n return corrected","def normalize_answer(s):\n\tdef remove_articles(text):\n\t\treturn re.sub(r'\\b(a|an|the)\\b', ' ', text)\n\n\tdef white_space_fix(text):\n\t\treturn ' '.join(text.split())\n\n\tdef remove_punc(text):\n\t\texclude = set(string.punctuation)\n\t\treturn ''.join(ch for ch in text if ch not in exclude)\n\n\tdef lower(text):\n\t\treturn text.lower()\n\n\treturn white_space_fix(remove_articles(remove_punc(lower(s))))","def normalize_answer(s):\n\n def remove_articles(text):\n return re.sub(r'\\b(a|an|the)\\b', ' ', text)\n\n def white_space_fix(text):\n return ' '.join(text.split())\n\n def remove_punc(text):\n exclude = set(string.punctuation)\n return ''.join(ch for ch in text if ch not in exclude)\n\n def lower(text):\n return text.lower()\n\n return white_space_fix(remove_articles(remove_punc(lower(s))))","def replaceElongated(word):\n\n repeat_regexp = re.compile(r'(\\w*)(\\w)\\2(\\w*)')\n repl = r'\\1\\2\\3'\n if wordnet.synsets(word):\n return word\n repl_word = repeat_regexp.sub(repl, word)\n if repl_word != word: \n return replaceElongated(repl_word)\n else: \n return repl_word","def _distribute_terms(terms):\n aux_ind = 0\n new_list = [terms[0]]\n while aux_ind < len(terms) - 1:\n aux_list = []\n for i in range(len(new_list[aux_ind])):\n for j in range(len(terms[aux_ind + 1])):\n new_terms = Mult(new_list[aux_ind][i], terms[aux_ind + 1][j])\n aux_list.append(new_terms)\n new_list.append(aux_list)\n aux_ind += 1\n return new_list[-1]","def normalize_answer(s):\n\n def remove_articles(text):\n return re.sub(r\"\\b(a|an|the)\\b\", \" \", text)\n\n def white_space_fix(text):\n return \" \".join(text.split())\n\n def remove_punc(text):\n exclude = set(string.punctuation)\n return \"\".join(ch for ch in text if ch not in exclude)\n\n def lower(text):\n return text.lower()\n\n return white_space_fix(remove_articles(remove_punc(lower(s))))","def normalize_answer(s):\n\n def remove_articles(text):\n return re.sub(r\"\\b(a|an|the)\\b\", \" \", text)\n\n def white_space_fix(text):\n return \" \".join(text.split())\n\n def remove_punc(text):\n exclude = set(string.punctuation)\n return \"\".join(ch for ch in text if ch not in exclude)\n\n def lower(text):\n return text.lower()\n\n return white_space_fix(remove_articles(remove_punc(lower(s))))","def simplify(self, expr):\n return sy.simplify(expr)","def simplify(self):\n self._express = self._simplify(self._express)\n self._del_derived()\n return self","def normalize_answer(s):\n def remove_articles(text):\n return re.sub(r'\\b(a|an|the)\\b', ' ', text)\n\n def white_space_fix(text):\n return ' '.join(text.split())\n\n def remove_punc(text):\n exclude = set(string.punctuation)\n return ''.join(ch for ch in text if ch not in exclude)\n\n def lower(text):\n return text.lower()\n\n return white_space_fix(remove_articles(remove_punc(lower(s))))","def reduce_base(word: str) -> str:\n porter = PorterStemmer()\n return porter.stem(word)","def normalize_answer(s):\n def remove_articles(text):\n regex = re.compile(r'\\b(a|an|the)\\b', re.UNICODE)\n return re.sub(regex, ' ', text)\n def white_space_fix(text):\n return ' '.join(text.split())\n def remove_punc(text):\n exclude = set(string.punctuation)\n return ''.join(ch for ch in text if ch not in exclude)\n def lower(text):\n return text.lower()\n return white_space_fix(remove_articles(remove_punc(lower(s))))","def normalise(word):\n word = word.lower()\n word = stemmer.stem_word(word)\n word = lemmatizer.lemmatize(word)\n return word","def filter_plurals(ngrams):\n\n remove = set()\n for ng in ngrams:\n pl = ng[:-1] + (ng[-1] + 's',)\n if pl in ngrams:\n remove.add(pl)\n try:\n # Counts\n ngrams[ng] += ngrams[pl]\n except TypeError:\n # Sets of IDs\n ngrams[ng] |= ngrams[pl]\n pl = ng[:-1] + (ng[-1] + 'es',)\n if pl in ngrams:\n remove.add(pl)\n try:\n # Counts\n ngrams[ng] += ngrams[pl]\n except TypeError:\n # Sets of IDs\n ngrams[ng] |= ngrams[pl]\n for ng in remove:\n del ngrams[ng]\n return ngrams","def NormalizeDisjunctions(disj,\n clause,\n ruleset,\n network,\n constructNetwork,\n negativeStratus,\n ignoreNegativeStratus):\n from FuXi.DLP import breadth_first, breadth_first_replace\n# disj = [i for i in breadth_first(clause.body) if isinstance(i,Or)]\n while len(disj) > 1:\n ApplyDemorgans(clause)\n if HasBreadthFirstNestedConj(clause.body):\n FlattenConjunctions(clause.body)\n disj=[i for i in breadth_first(clause.body) if isinstance(i,Or)]\n assert len(disj)<2,\"Unable to effectively reduce disjunctions\"\n if len(disj) == 1:\n #There is one disjunction in the body, we can reduce from:\n #H :- B1 V B2 to H : - B1 and H :- B2\n origDisj = disj[0]\n for item in origDisj:\n #First we want to replace the entire disjunct with an item within it\n list(breadth_first_replace(clause.body,candidate=origDisj,replacement=item))\n clause_clone = copy.deepcopy(clause)\n disj = [i for i in breadth_first(clause_clone.body) if isinstance(i,Or)]\n if len(disj) > 0:\n #If the formula has disjunctions of it's own, we handle them recursively\n NormalizeDisjunctions(disj,\n clause_clone,\n ruleset,\n network,\n constructNetwork,\n negativeStratus,\n ignoreNegativeStratus)\n else:\n if HasBreadthFirstNestedConj(clause_clone.body):\n FlattenConjunctions(clause_clone.body)\n #Otherwise handle normally\n HandleNonDisjunctiveClauses(ruleset, network, constructNetwork, negativeStratus, ignoreNegativeStratus, clause_clone)\n #restore the replaced term (for the subsequent iteration)\n list(breadth_first_replace(clause.body,candidate=item,replacement=origDisj))\n else:\n #The disjunction has been handled by normal form transformation, we just need to\n #handle normally\n if HasBreadthFirstNestedConj(clause_clone.body):\n FlattenConjunctions(clause_clone.body)\n HandleNonDisjunctiveClauses(ruleset, network, constructNetwork, negativeStratus, ignoreNegativeStratus, clause)","def _form_term_from_wick(term, contrs, phase, resolvers, wick_scheme):\n\n sums_dict = term.dumms\n\n perm, n_contred = wick_scheme\n phase = _get_perm_phase(perm, phase)\n\n amp = phase\n substs = {}\n for contr_i in range(0, n_contred, 2):\n contr_amp, contr_substs = contrs[perm[contr_i]][perm[contr_i + 1]]\n amp, _ = compose_simplified_delta(\n amp * contr_amp, contr_substs,\n substs, sums_dict=sums_dict, resolvers=resolvers\n )\n continue\n\n vecs = tuple(term.vecs[i] for i in perm[n_contred:])\n return term.subst(\n substs, amp=amp * term.amp, vecs=vecs, purge_sums=True\n )","def multiply(self,l,s=True):\r\n\t\t\r\n\t\t# convert to line\r\n\t\tl = Li(l,c=False)\r\n\t\t\r\n\t\t# new term list\r\n\t\tw = []\r\n\t\t\r\n\t\t# for every term in first\r\n\t\tfor i in self:\r\n\t\t\t\t\r\n\t\t\t# multiply each member of second\r\n\t\t\tfor j in l:\r\n\t\t\t\t\r\n\t\t\t\t# multiply together\r\n\t\t\t\tm = i.multiply(j)\r\n\t\t\t\t\r\n\t\t\t\t# append into new line\r\n\t\t\t\tw.append(m)\r\n\r\n\t\t# new line, condenses\r\n\t\tw = Li(w)\r\n\t\t\t\t\t\r\n\t\t# sort new line\r\n\t\tif s:\r\n\t\t\tw = w.sort()\r\n\t\t\r\n\t\treturn w","def set_weight(term, irrelevant):\n if term in irrelevant:\n return (0.2 * max([x/sum(indtf_features[term]) for x in indtf_features[term]]))\n elif isinstance(term, tuple):\n return len(term)\n else:\n return 1","def _make_product(terms):\n if terms:\n product = terms[0]\n for term in terms[1:]:\n product = Mul((product, term))\n return product \n else:\n return Const(1)","def normalize(s):\r\n def remove_articles(text):\r\n return re.sub(r'\\b(a|an|the)\\b', ' ', text)\r\n\r\n def white_space_fix(text):\r\n return ' '.join(text.split())\r\n\r\n def remove_punc(text):\r\n exclude = set(string.punctuation)\r\n return ''.join(ch for ch in text if ch not in exclude)\r\n\r\n def lower(text):\r\n return text.lower()\r\n\r\n return white_space_fix(remove_articles(remove_punc(lower(s))))","def normalize(s):\r\n def remove_articles(text):\r\n return re.sub(r'\\b(a|an|the)\\b', ' ', text)\r\n\r\n def white_space_fix(text):\r\n return ' '.join(text.split())\r\n\r\n def remove_punc(text):\r\n exclude = set(string.punctuation)\r\n return ''.join(ch for ch in text if ch not in exclude)\r\n\r\n def lower(text):\r\n return text.lower()\r\n\r\n return white_space_fix(remove_articles(remove_punc(lower(s))))","def eng_with_sub(self, eng: list, subword: list) -> list:\n subwords = subword + eng[0]\n while [] in subwords:\n subwords.remove([])\n out = \" \".join('%s' % id for id in subwords).split()\n return out","def fold_term(self, init_repr, term):\n if isinstance(term, Var):\n return self.var(init_repr, term.name)\n elif isinstance(term, Const):\n return self.const(init_repr, term.name)\n elif isinstance(term, Dist):\n return self.dist(init_repr, term.name)\n elif isinstance(term, Func):\n return self.func(\n init_repr,\n term.funcname,\n [ self.fold_term(init_repr, x)\n for x in term.args ])\n elif isinstance(term, Eq):\n return self.eq(\n init_repr,\n term.pos,\n self.fold_term(init_repr, term.t1),\n self.fold_term(init_repr, term.t2))\n elif isinstance(term, Disj):\n return self.disj(\n init_repr,\n term.role,\n [ self.fold_term(init_repr, eq)\n for eq in term.eqs ])\n elif isinstance(term, Conj):\n return self.conj(\n init_repr,\n [ self.fold_term(init_repr, disj)\n for disj in term.disjs ])","def normalize(self, factor):","def normal(e, **kw_args):\n\n if not e:\n return S.Zero\n\n opts = {\n 'simplify_kronecker_deltas': False,\n 'expand': True,\n 'simplify_dummies': False,\n 'keep_only_fully_contracted': False,\n 'lam': 1\n }\n opts.update(kw_args)\n\n # break up any NO-objects, and evaluate commutators\n e = e.doit(wicks=True)\n\n # make sure we have only one term to consider\n e = e.expand()\n if isinstance(e, Add):\n return Add(*[ normal(term, **kw_args) for term in e.args])\n\n # For Mul-objects we can actually do something\n if isinstance(e, Mul):\n\n # we don't want to mess around with commuting part of Mul\n # so we factorize it out before starting recursion\n c_part = []\n string1 = []\n for factor in e.args:\n if factor.is_commutative:\n c_part.append(factor)\n else:\n string1.append(factor)\n n = len(string1)\n\n # catch trivial cases\n if n == 0:\n result = e\n elif n == 1:\n result = e\n else: # non-trivial\n if n > 2:\n # recursive step\n if isinstance(string1[0], CreateBoson) \\\n or (string1[0].is_Pow and \\\n isinstance(string1[0].args[0], CreateBoson)):\n # if the first term is ad^m\n result = string1[0] * normal(Mul(*string1[1:]), **kw_args)\n else:\n # if the first term is a^m,\n # bring the first two terms to normal order first\n result = normal(normal(Mul(*string1[:2]), **kw_args)*Mul(*string1[2:]), **kw_args)\n else: # n = 2,\n result = _normal(string1, opts['lam'])\n result = Mul(*c_part)*result\n\n if opts['expand']:\n result = result.expand()\n # if opts['simplify_kronecker_deltas']:\n # result = evaluate_deltas(result)\n\n return result\n\n # there was nothing to do\n return e","def tag_terms(text, terms, nlp=None):\n from spacy.lang.en.stop_words import STOP_WORDS\n spacy.tokens.token.Token.set_extension('workaround', default='', force=True)\n \n HEURISTIC_TOKENS = [\"-\", \"plant\", \"substance\", \"atom\"]\n \n # default to Stanford NLP pipeline wrapped in Spacy\n if nlp is None:\n snlp = stanfordnlp.Pipeline(lang=\"en\")\n nlp = StanfordNLPLanguage(snlp)\n \n # preprocess with spacy if needed\n if type(terms[0]) != spacy.tokens.doc.Doc:\n terms = [nlp(term) for term in terms]\n if (type(text) != spacy.tokens.doc.Doc and type(text) != spacy.tokens.span.Span):\n text = nlp(text)\n \n # set up a custom representation of the text where we can add term type annotations\n for token in text:\n token._.workaround = token.text_with_ws\n\n lemmatized_text = [token.lemma_ for token in text]\n tokenized_text = [token.text for token in text]\n tags = ['O'] * len(text)\n found_terms = defaultdict(lambda: {\"text\": [], \"indices\": [], \"pos\": [], \"type\": []})\n \n # iterate through terms from longest to shortest\n terms = sorted(terms, key=len)[::-1]\n for spacy_term in terms:\n term_length = len(spacy_term)\n lemma_term_list = [token.lemma_ for token in spacy_term]\n text_term_list = [token.text for token in spacy_term]\n term_lemma = \" \".join(lemma_term_list)\n \n # skip short acronyms that can cause problems\n if len(term_lemma) <= 2:\n continue\n \n # additional check to check for simple plural of uncommon biology terms\n match_uncommon_plural = lemma_term_list.copy()\n match_uncommon_plural[-1] = match_uncommon_plural[-1] + \"s\"\n\n # additional check using heuristics on lemmatized version\n match_heuristic = []\n if lemma_term_list[0] not in HEURISTIC_TOKENS:\n for token in lemma_term_list:\n if token not in HEURISTIC_TOKENS:\n match_heuristic += token.split(\"-\")\n heuristic_length = len(match_heuristic)\n else:\n heuristic_term = lemma_term_list\n heuristic_length = len(lemma_term_list)\n \n for ix in range(len(text) - term_length):\n \n heuristic_match = (lemmatized_text[ix:ix + heuristic_length] == match_heuristic)\n plural_match = (lemmatized_text[ix:ix + term_length] == match_uncommon_plural)\n lemma_match = (lemmatized_text[ix:ix + term_length] == lemma_term_list)\n text_match = (tokenized_text[ix:ix + term_length] == text_term_list)\n lower_match = ([t.lower() for t in tokenized_text[ix:ix + term_length]] ==\n [t.lower() for t in text_term_list])\n \n # Only match on text if lemmatized version is a stop word (i.e. lower casing acronym)\n if term_lemma in STOP_WORDS:\n valid_match = text_match\n else:\n valid_match = heuristic_match or plural_match or text_match or lemma_match or lower_match\n \n if valid_match:\n \n if heuristic_match and not lemma_match:\n match_length = heuristic_length\n else:\n match_length = term_length\n \n term_text = \" \".join([t.text for t in text[ix:ix + match_length]])\n term_tag = \" \".join([t.tag_ for t in text[ix:ix + match_length]])\n \n # only tag term if not part of larger term\n if tags[ix:ix + match_length] == [\"O\"] * match_length:\n \n # classify term type\n term_type = determine_term_type(spacy_term)\n \n # collect term information\n found_terms[term_lemma][\"text\"].append(term_text)\n found_terms[term_lemma][\"indices\"].append((ix, ix + match_length))\n found_terms[term_lemma][\"pos\"].append(term_tag)\n found_terms[term_lemma][\"type\"].append(term_type)\n \n # update sentence tags\n tags = tag_bioes(tags, ix, match_length)\n \n # annotate token representations with term type\n text[ix]._.workaround = f\"<{term_type}>\" + text[ix]._.workaround\n end_ix = ix + match_length - 1\n if text[end_ix]._.workaround.endswith(\" \"):\n text[end_ix]._.workaround = text[end_ix]._.workaround[:-1] + f\"</{term_type}> \"\n else:\n text[end_ix]._.workaround += f\"</{term_type}>\"\n \n # reconstruct fully annotated input text\n annotated_text = \"\"\n for token in text:\n annotated_text += token._.workaround\n \n return {\n \"tokenized_text\": tokenized_text, \n \"tags\": tags, \n \"annotated_text\": annotated_text,\n \"found_terms\": dict(found_terms)\n }","def transform(self, entry):\r\n res = ''\r\n doc = self.nlp(entry, disable=['tagger', 'parser'])\r\n ents = doc.ents\r\n start_indices = {}\r\n end_indices = {}\r\n\r\n for ent in ents:\r\n start, end, label = ent.start, ent.end, ent.label_\r\n if label in ['NORP', 'GPE', 'LOC', 'PERSON', 'PRODUCT']:\r\n start_indices[start] = 'PRODUCT'\r\n end_indices[end] = 'PRODUCT'\r\n if label in ['DATE', 'QUANTITY', 'TIME', 'PERCENT', 'MONEY']:\r\n start_indices[start] = 'NUM'\r\n end_indices[end] = 'NUM'\r\n\r\n for idx, token in enumerate(doc):\r\n if idx in start_indices:\r\n res += start_indices[idx] + ' '\r\n\r\n # normalizing the numbers\r\n if token.like_num:\r\n try:\r\n val = float(token.text)\r\n if val == round(val):\r\n res += '%d ' % (int(val))\r\n else:\r\n res += '%.2f ' % (val)\r\n except:\r\n res += token.text + ' '\r\n elif len(token.text) >= 7 and \\\r\n any([ch.isdigit() for ch in token.text]):\r\n res += 'ID ' + token.text + ' '\r\n else:\r\n res += token.text + ' '\r\n return res.strip()","def split_word_in_all_comps(self, term: str) -> List[str]:\n all_stems = []\n\n words = term.split()\n for word in words:\n stems = self.decompound(word)\n all_stems.extend(stems)\n\n for stem in stems:\n more_stems = self.split_word_in_all_comps(stem)\n all_stems.extend(more_stems)\n\n return all_stems","def normalize_answer(s):\n\n def remove_articles(text):\n regex = re.compile(r'\\b(a|an|the)\\b', re.UNICODE)\n return re.sub(regex, ' ', text)\n\n def white_space_fix(text):\n return ' '.join(text.split())\n\n def remove_punc(text):\n exclude = set(string.punctuation)\n return ''.join(ch for ch in text if ch not in exclude)\n\n def lower(text):\n return text.lower()\n\n return white_space_fix(remove_articles(remove_punc(lower(s))))","def correctDefaultNounTag(idx, tagged_term, tagged_terms, lexicon):\n term, tag, norm = tagged_term\n if tag == 'NND':\n if term.endswith('s'):\n tagged_term[1] = 'NNS'\n tagged_term[2] = term[:-1]\n else:\n tagged_term[1] = 'NN'","def generate_transitional_modifications(self, word: str = \"\") -> list: # noqa: C901\n possible_modifications = []\n\n # Create a list of possible initial words\n word_list = [word]\n\n # Replace Umlaute to handle things like \"H_ä_userschlucht\"\n # If the first letter is an Umlaut, it is not going to be changed\n if 'ä' in word and not word[0].lower() == 'ä':\n tmp_word = word.replace(u'ä', 'a')\n word_list.append(tmp_word)\n\n if 'ö' in word and not word[0].lower() == 'ö':\n tmp_word = word.replace(u'ö', 'o')\n word_list.append(tmp_word)\n\n if 'ü' in word and not word[0].lower() == 'ü':\n tmp_word = word.replace(u'ü', 'u')\n word_list.append(tmp_word)\n\n for word in word_list:\n # Consider the unmodified word lowered and capitalized as possible modifications\n possible_modifications.append(word.lower())\n possible_modifications.append(word.capitalize())\n\n \"\"\"\n M O D I F Y W O R D S\n Noun Rules\n \"\"\"\n # If not last letter is 's'\n # Remove s\n # Remove s, add e\n if word[-1:] == \"s\": #\n # action = [\"-s\"]\n # action2 = [\"-s\", \"+e\"]\n possible_modifications.append(word[:-1].lower())\n possible_modifications.append(word[:-1].lower() + \"e\")\n\n possible_modifications.append(word[:-1].capitalize())\n possible_modifications.append(word[:-1].capitalize() + \"e\")\n\n # If not last letter is 'e'\n # Add e\n if not word[-1:] == \"e\": # Kirch|turm (Kirch) -> (Kirche)\n # action = [\"+e\"]\n possible_modifications.append(word.lower() + \"e\")\n possible_modifications.append(word.capitalize() + \"e\")\n\n # If not last letter is 'n'\n # Add n\n if word[-1:] == \"n\": # Hasen|braten (Hasen) -> (Hase)\n # action = [\"-n\"]\n possible_modifications.append(word[:-1].lower())\n possible_modifications.append(word[:-1].capitalize())\n\n # If last letter IS 'e'\n # Remove e\n if word[-1:] == \"e\": # Hunde|hütte (Hunde) -> (Hund)\n # action = [\"-e\"]\n possible_modifications.append(word[:-1].lower())\n possible_modifications.append(word[:-1].capitalize())\n\n # If word ends on \"en\"\n # Remove \"en\"\n if word[-2:] == \"en\": # Taten|drang (Taten) -> (Tag)\n # action = [\"-en\"]\n possible_modifications.append(word[:-2].lower())\n possible_modifications.append(word[:-2].capitalize())\n\n # If word ends on \"er\"\n # Remove \"er\"\n if word[-2:] == \"er\": # Bücher|Regal (Bücher/Bucher) -> (Büch/Buch)\n # action = [\"-er\"]\n possible_modifications.append(word[:-2].lower())\n possible_modifications.append(word[:-2].capitalize())\n\n # If word ends on \"ns\"\n # Remove \"ns\"\n if word[-2:] == \"ns\": # Glaubens|frage (Glaubens) -> (Glaube)\n # action = [\"-ns\"]\n possible_modifications.append(word[:-2].lower())\n possible_modifications.append(word[:-2].capitalize())\n\n # If word ends on \"ens\"\n # Remove \"ens\"\n if word[-3:] == \"ens\": # Herzens|güte (Herzens) -> (Herz)\n # action = [\"-ens\"]\n possible_modifications.append(word[:-3].lower())\n possible_modifications.append(word[:-3].capitalize())\n\n # If ends on \"es\"\n # Remove \"es\"\n if word[-2:] == \"es\": # Kindes|wohl (Kindes) -> (Kind)\n # action = [\"-es\"]\n possible_modifications.append(word[:-2].lower())\n possible_modifications.append(word[:-2].capitalize())\n\n \"\"\"\n Verb Rules\n \"\"\"\n # If word does not end on \"en\" and not on \"e\"\n # Add -en\n if not word[-2:] == \"en\" and not word[-1:] == \"e\":\n # action = [\"+en\"]\n possible_modifications.append(word.lower() + \"en\")\n possible_modifications.append(word.capitalize() + \"en\")\n\n # If word ends on \"en\" PR word ends on \"em\"\n # Add -en, remove -e- in context of n, m)\n # This is totally different to the NOUN rule above\n if word[-2:] == \"en\" or word[-2:] == \"em\":\n # action = [\"+n\", \"+en\"]\n possible_modifications.append(word[:-2].lower() + word[-1:] + \"en\")\n possible_modifications.append(word[:-2].capitalize() + word[-1:] + \"en\")\n\n # If word does not end on \"n\"\n # Add -n\n if not word[-1:] == \"n\":\n # action = [\"+n\"]\n possible_modifications.append(word.lower() + \"n\")\n possible_modifications.append(word.capitalize() + \"n\")\n\n # modification is valid if:\n # - not in stopwords\n # - len > 2\n # - not in forbidden modifier list\n # - in lemma list\n\n possible_modifications = [w for w in possible_modifications if w.lower() not in self.stop_words\n and len(w) > 2\n and str(w) in self.lemma_data]\n\n return possible_modifications","def preprocess_sub_units(self):\n if self.unit == \"char\":\n self.preprocess_char()\n elif self.unit == \"char-ngram\":\n self.preprocess_char_ngram()\n elif self.unit == \"morpheme\":\n self.preprocess_morpheme()\n elif self.unit == \"oracle\":\n self.preprocess_oracle()\n else:\n sys.exit(\"Unknown unit\")","def simplify_pono(self, tensor: Tensor):\n resolvers = self.resolvers\n return tensor.map(\n lambda term: _simpl_pono_term(term, resolvers.value)\n )","def _simpl_one_pono(\n expr: Pow, resolvers, sums_dict, j_of, symb2idx, rel_vecs\n):\n\n expr = _simpl_pono_jm(expr, resolvers, sums_dict, j_of)\n if not isinstance(expr, Pow):\n return expr\n\n exps = _parse_pono(expr)\n\n # Next, simplification based on the linear relations are performed.\n coeffs = [0 for _ in symb2idx] # Coefficients for symbols with relations.\n other = [] # Other addends.\n\n for i in exps:\n coeff, symb = _parse_linear(i)\n if symb is None or symb not in symb2idx:\n other.append(i)\n else:\n coeffs[symb2idx[symb]] += coeff\n continue\n\n projed_coeffs = _proj_out(rel_vecs, Matrix(coeffs))\n addends = other\n for i, j in zip(symb2idx.keys(), projed_coeffs):\n if j != 0:\n addends.append(i * j)\n continue\n\n # Finally, canonicalize the coefficients again.\n expr = _NEG_UNITY ** sum(addends)\n if not isinstance(expr, Pow):\n return expr\n\n expr = _simpl_pono_jm(\n expr, resolvers, sums_dict, j_of\n )\n\n return expr","def qsimplify(e_orig, _n=0):\n if _n > 15:\n warnings.warn(\"Too high level or recursion, aborting\")\n return e_orig\n\n e = normal_ordered_form(e_orig)\n\n if isinstance(e, Add):\n return Add(*(qsimplify(arg, _n=_n+1) for arg in e.args))\n\n elif isinstance(e, Pow):\n return Pow(*(qsimplify(arg, _n=_n+1) for arg in e.args))\n\n elif isinstance(e, exp):\n return exp(*(qsimplify(arg, _n=_n+1) for arg in e.args))\n\n elif isinstance(e, Mul):\n args1 = tuple(arg for arg in e.args if arg.is_commutative)\n args2 = tuple(arg for arg in e.args if not arg.is_commutative)\n #x = 1\n #for y in args2:\n # x = x * y\n\n x = 1\n for y in reversed(args2):\n x = y * x\n\n if isinstance(x, Mul):\n args2 = x.args\n x = 1\n for y in args2:\n x = x * y\n\n e_new = simplify(Mul(*args1)) * x\n\n if e_new == e:\n return e\n else:\n return qsimplify(e_new.expand(), _n=_n+1)\n\n if e == e_orig:\n return e\n else:\n return qsimplify(e, _n=_n+1).expand()","def reindex_subcomponent_taxa(self):\n ti_mutable = self.taxon_set._is_mutable\n self.taxon_set._is_mutable = True\n new_map = CharacterDataMap()\n for taxon, seq in self.taxon_seq_map.items():\n taxon = self.taxon_set.require_taxon(label=taxon.label)\n new_map[taxon] = seq\n self.taxon_set._is_mutable = ti_mutable\n self.taxon_seq_map = new_map","def subexpr_to_smtlib(expr, pre, suff='', fun_annotate_subexpr = None):\n if fun_annotate_subexpr is not None and pre in PythonOperators.logic_ops:\n return '(! (' + pre + ' ' + ExprTranslator.concatenate_args(expr, fun_annotate_subexpr) + suff + \\\n ') :named ' + fun_annotate_subexpr() + ')'\n else:\n return '(' + pre + ' ' + ExprTranslator.concatenate_args(expr, fun_annotate_subexpr) + suff + ')'","def renormalize(self,proposal,proposal_label,ref_label):\n import copy\n renormalized = copy.deepcopy(proposal)\n all_scales = self.refl_table[ref_label+\"_shoebox_sum\"]/self.refl_table[proposal_label+\"_shoebox_sum\"]\n for sidx in range(len(self.refl_table)): #loop through the shoeboxes\n scale_factor = all_scales[sidx]\n for ipanel, islow, ifast in self.per_shoebox_whitelist_iterator(sidx):\n renormalized[ipanel,islow,ifast] *= scale_factor\n return renormalized","def corrected_ttr(n_terms, n_words):\n if n_words == 0:\n return 0\n return n_terms / math.sqrt(2 * n_words)","def __call__(self, *args, **kw):\n return self.transform(Term.__call__(self, *args, **kw))","def fold_term(self, term):\n if isinstance(term, Var):\n return self.var(term.name)\n elif isinstance(term, Const):\n return self.const(term.name)\n elif isinstance(term, Dist):\n return self.dist(term.name)\n elif isinstance(term, Func):\n return self.func(\n term.funcname,\n tuple( self.fold_term(x)\n for x in term.args ))\n elif isinstance(term, Eq):\n return self.encode_eq(term)\n elif isinstance(term, Disj):\n return self.encode_disj(term)\n elif isinstance(term, Conj):\n return self.encode_conj(term)\n raise RuntimeError('Invalid term {}'.format(term))","def test_unstem():\n\n # cat > cats\n t = Text('cat cat cats')\n assert t.unstem('cat') == 'cat'\n\n # cats > cat\n t = Text('cat cat cats cats cats')\n assert t.unstem('cat') == 'cats'","def _normalize(self, word):\n return self.lemmatize(word.lower())","def _step1a(self, word):\n # this NLTK-only rule extends the original algorithm, so\n # that 'flies'->'fli' but 'dies'->'die' etc\n if self.mode == self.NLTK_EXTENSIONS:\n if word.endswith(\"ies\") and len(word) == 4:\n return self._replace_suffix(word, \"ies\", \"ie\")\n\n return self._apply_rule_list(\n word,\n [\n (\"sses\", \"ss\", None), # SSES -> SS\n (\"ies\", \"i\", None), # IES -> I\n (\"ss\", \"ss\", None), # SS -> SS\n (\"s\", \"\", None), # S ->\n ],\n )","def __transform_term(self, term: ast.TermASTNode) -> ast.TermASTNode:\n # TODO: expansion cycle detection\n if isinstance(term, ast.FunctionApplicationASTNode) \\\n and isinstance(term.get_declaration().get_declaring_ast_node(), ast.DefineFunCommandASTNode):\n definition = term.get_declaration().get_declaring_ast_node()\n result = self.__create_expansion(term, definition)\n else:\n result = term\n\n # Transform child nodes.\n children = result.get_child_nodes()\n for i, child_node in enumerate(children):\n result.set_child_node(i, self.__transform_term(child_node))\n\n return result","def transform_one_sentence(sentence):\n words = list(map(str, nlp(sentence)))\n return ' '.join(list(map(spell.correction, words)))","def __sub__(self, other):\n\n other = formula(other, namespace=self.namespace)\n terms = copy.copy(self.terms)\n\n for term in other.terms:\n for i in range(len(terms)):\n if terms[i].termname == term.termname:\n terms.pop(i)\n break \n return formula(terms, namespace=self.namespace)","def scale(self,n,d=1):\r\n\t\t\r\n\t\t# scale all terms\r\n\t\ts = [i.scale(n,d) for i in self]\r\n\t\t\r\n\t\treturn Li(s)","def _update_term_relevance(self, term):\n term_entry = self.sql_session.query(Term).get(term)\n term_entry.relevance = self.term_relevance(term)\n #self.sql_engine.execute(\n # \"update terms set relevance=:relevance where term=:term\",\n # term=term, relevance=self.term_relevance(term)\n #)","def simplify(self, formula):\n return self.walk(formula)","def simplify(cls, x: Term, bound: int = -1) -> Optional[Term]:\n if not isinstance(x, FuncTerm):\n raise ValueError(\"simplify function expects a FuncTerm.\")\n return normal(x, cls.rules, bound)[0]","def normal_ordered_ladder_term(term, coefficient, parity=-1):\n # Iterate from left to right across operators and reorder to normal\n # form. Swap terms operators into correct position by moving from\n # left to right across ladder operators.\n term = list(term)\n\n if parity == -1:\n Op = FermionOperator\n elif parity == 1:\n Op = BosonOperator\n\n ordered_term = Op()\n\n for i in range(1, len(term)):\n for j in range(i, 0, -1):\n right_operator = term[j]\n left_operator = term[j - 1]\n\n # Swap operators if raising on right and lowering on left.\n if right_operator[1] and not left_operator[1]:\n term[j - 1] = right_operator\n term[j] = left_operator\n coefficient *= parity\n\n # Replace a a^\\dagger with 1 + parity*a^\\dagger a\n # if indices are the same.\n if right_operator[0] == left_operator[0]:\n new_term = term[:(j - 1)] + term[(j + 1):]\n\n # Recursively add the processed new term.\n ordered_term += normal_ordered_ladder_term(\n tuple(new_term), parity * coefficient, parity)\n\n # Handle case when operator type is the same.\n elif right_operator[1] == left_operator[1]:\n\n # If same two Fermionic operators are repeated,\n # evaluate to zero.\n if parity == -1 and right_operator[0] == left_operator[0]:\n return ordered_term\n\n # Swap if same ladder type but lower index on left.\n elif right_operator[0] > left_operator[0]:\n term[j - 1] = right_operator\n term[j] = left_operator\n coefficient *= parity\n\n # Add processed term and return.\n ordered_term += Op(tuple(term), coefficient)\n return ordered_term","def factor_statements(kb):\n # Unify literals in same rule\n for rule in kb:\n for index, literal1 in enumerate(rule):\n rest = rule[index + 1:]\n for literal2 in rest:\n if literal1.negate == literal2.negate and literal1.predicate == literal2.predicate:\n unification = unify_literal(literal1.arguments, literal2.arguments)\n if unification is False:\n continue\n else:\n for literal in rule:\n substitute(literal, unification)\n # Remove same literals\n new_kb = []\n for rule in kb:\n new_rule = []\n for literal in rule:\n if literal not in new_rule:\n new_rule.append(literal)\n new_kb.append(new_rule)\n return new_kb","def transform_article(article):\n tokens = clean_article(article)\n lemmatizer = WordNetLemmatizer()\n lemmatized = [lemmatizer.lemmatize(token) for token in tokens]\n transformed_article = \" \".join(lemmatized)\n return transformed_article","def substitute(self,s,x):\r\n\t\t\r\n\t\t# turn substitution into top line\r\n\t\ttry:\r\n\t\t\tt = Li(s)\r\n\t\t\tb = Li(1)\r\n\t\t\t\r\n\t\t# unless it is a list of lines\r\n\t\texcept:\r\n\t\t\tt = Li(s[0])\r\n\t\t\tb = Li(s[1])\r\n\t\t\r\n\t\t# split variable from power\r\n\t\th = Te._chop(x)\r\n\t\tx = h[0]\r\n\t\t\r\n\t\t# assume power of 1 for substituted variable, but revise if found in string\r\n\t\tp = 1\r\n\t\ttry:\r\n\t\t\tp = int(h[1])\r\n\t\texcept:\r\n\t\t\tpass\r\n\t\t\r\n\t\t# exponents in each term\r\n\t\te = [i.look(x) for i in self]\r\n\t\t\r\n\t\t# adjust for power of substituted variable\r\n\t\te = [i // p for i in e]\r\n\t\t\r\n\t\t# max, min powers of substitution\r\n\t\ttry:\r\n\t\t\ta = max(e)\r\n\t\t\tm = min(e)\r\n\t\texcept:\r\n\t\t\ta = 0\r\n\t\t\tm = 0\r\n\t\t\r\n\t\t# truncate max and min powers \r\n\t\tif a < 0:\r\n\t\t\ta = 0\r\n\t\tif m > 0:\r\n\t\t\tm = 0\r\n\t\t\t\r\n\t\t# dictionaries of calculated terms for top and bottom\r\n\t\tf = {}\r\n\t\tg = {}\r\n\t\t\t\r\n\t\t# expand top and bottom to truncated max and min\r\n\t\tq,f = Li._expand(t,-m,f)\r\n\t\tr,g = Li._expand(b,a,g)\r\n\t\tq = Li(q,c=False)\r\n\t\tr = Li(r,c=False)\r\n\t\t\r\n\t\t# store results in dictionaries\r\n\t\ty = {-m: q}\r\n\t\tz = {a: r}\r\n\t\t\r\n\t\t# make denominator\r\n\t\td = q.multiply(r)\r\n\t\t\r\n\t\t# convert each term\r\n\t\tl = Li([])\r\n\t\tfor n,i in enumerate(self):\r\n\t\t\t\r\n\t\t\t# exponent of substitution\r\n\t\t\tw = e[n]\r\n\t\t\t\r\n\t\t\t# divide out variable\r\n\t\t\tv = Te({x: -w * p})\r\n\t\t\ti = i.multiply(v)\r\n\t\t\t\r\n\t\t\t# retrieve top expansion\r\n\t\t\tif (w - m) in y:\r\n\t\t\t\tu = y[w - m]\r\n\t\t\t\t\r\n\t\t\t# or calculate\r\n\t\t\telse:\r\n\t\t\t\tu,f = Li._expand(t,w - m,f)\r\n\t\t\t\tu = Li(u,c=False)\r\n\t\t\t\ty[w - m] = u\r\n\t\t\t\r\n\t\t\t# retrieve bottom expansion\r\n\t\t\tif (a - w) in z:\r\n\t\t\t\tc = z[a - w]\r\n\t\t\t\r\n\t\t\t# or calculate\r\n\t\t\telse:\r\n\t\t\t\tc,g = Li._expand(b,a - w,g)\r\n\t\t\t\tc = Li(c,c=False)\r\n\t\t\t\tz[a - w] = c\r\n\t\t\t\r\n\t\t\t# multiply and add\r\n\t\t\tu = u.multiply(c)\r\n\t\t\tu = u.multiply(i)\r\n\t\t\tl = l.add(u)\r\n\t\t\r\n\t\treturn [l,d]"],"string":"[\n \"def simplify(self, text: str):\\n # sanitise the input, remove common words and swap out similar words\\n text = self.sanitise(text)\\n # Decided not to use stopwords because that would take out too many and then get false positives\\n common_words = [\\\"what\\\", \\\"i\\\", \\\"you\\\", \\\"do\\\", \\\"a\\\", \\\"thing\\\", \\\"of\\\", \\\"was\\\", \\\"would\\\", \\\"were\\\", \\\"are\\\", \\\"been\\\"\\n \\\"reddit\\\", \\\"why\\\",\\n \\\"your\\\", \\\"it\\\", \\\"is\\\", \\\"the\\\", \\\"that\\\", \\\"has\\\", \\\"had\\\", \\\"for\\\", \\\"at\\\", \\\"in\\\", \\\"on\\\",\\n \\\"with\\\", \\\"if\\\", \\\"to\\\", \\\"be\\\", \\\"and\\\", \\\"some\\\"]\\n for common_word in common_words:\\n text = text.replace(\\\" \\\" + common_word + \\\" \\\", \\\" \\\")\\n\\n # Replace common synonyms\\n synonyms = [[\\\"funniest\\\", \\\"funny\\\", \\\"hilarious\\\"], [\\\"food\\\", \\\"diet\\\"], [\\\"life\\\", \\\"lifetime\\\"],\\n [\\\"stop\\\", \\\"end\\\", \\\"quit\\\"], [\\\"advice\\\", \\\"help\\\"],\\n [\\\"grossest\\\", \\\"worst\\\"], [\\\"buy\\\", \\\"bought\\\", \\\"purchase\\\"],\\n [\\\"scary\\\", \\\"scariest\\\", \\\"spookiest\\\"]]\\n for synonym in synonyms:\\n for word in synonym:\\n text = text.replace(\\\" \\\" + word + \\\" \\\", \\\" \\\" + synonym[0] + \\\" \\\")\\n\\n # Stem words\\n from nltk.stem.porter import PorterStemmer\\n ps = PorterStemmer()\\n text = text.split()\\n text = [ps.stem(word) for word in text]\\n text = \\\" \\\".join(text)\\n text = \\\" \\\" + text + \\\" \\\"\\n\\n # Missed words that still need to be stemmed:\\n text = text.replace(\\\" given \\\", \\\" give \\\")\\n text = text.replace(\\\" younger \\\", \\\" young \\\")\\n\\n return text\",\n \"def _simpl_pono_term(term: Term, resolvers) -> Term:\\n\\n sums_dict = dict(term.sums)\\n other, wigner_3js = _parse_3js(term.amp)\\n jms, rels = _get_jms_rels(wigner_3js)\\n\\n new_other = _simpl_pono(\\n other, resolvers, sums_dict, jms, rels, sums_only=False\\n )\\n\\n new_amp = new_other * prod_(\\n i.expr for i in wigner_3js\\n )\\n\\n return Term(term.sums, new_amp, term.vecs)\",\n \"def organizeTerms_fromOriginal(self):\\n self.LHS = []\\n\\n # LHS: [ ]\\n # LHS: [ term1, term2, term3 ]\\n # LHS: [ ( ), ( ), ( ) ]\\n # LHS: [ ( item1, item2, item3 ), term2, term3 ]\\n # _______________ _______________ __\\n # LHS: [ ( (obj1, 'attr1'), (obj2, 'attr2'), 20 ), term2, term3 ]\\n\\n\\n # Expand brackets\\n def someTermsHaveListItems():\\n for term in self._LHS_original:\\n if any(isinstance(item, list) for item in term):\\n return True\\n return False\\n\\n while someTermsHaveListItems():\\n for termIndex, Term in enumerate(self._LHS_original):\\n newTerms_toAdd = []\\n listItems_inTerm = [item for item in Term if isinstance(item, list)]\\n hasListItems = len(listItems_inTerm) > 0\\n\\n for listItem_inTerm in listItems_inTerm:\\n otherItems_inTerm = tuple(item for item in Term if item is not listItem_inTerm) # otherItems_inTerm are all multiplied items\\n for term in listItem_inTerm:\\n assert isinstance(term, tuple) # isolated term in format (const, [unknowns])\\n # coeff unknown addresses unpacked from unknowns list\\n newTerms_toAdd.append( otherItems_inTerm + (term[0],) + tuple(unknownAddress for unknownAddress in term[1]) )\\n break # process one list item in the term at once\\n\\n if hasListItems:\\n for newTerm_toAdd in reversed(newTerms_toAdd):\\n self._LHS_original.insert(termIndex, newTerm_toAdd)\\n self._LHS_original.remove(Term)\\n break # process one term and break\\n # Brackets expanded.\\n\\n for term in self._LHS_original: # each term is a tuple as all brackets expanded above\\n constantFactors = []\\n unknownFactors = []\\n\\n for item in term: # items within the term are to be multiplied\\n\\n if isinstance(item, tuple):\\n # item is an object.attribute address, in form (object, 'attribute')\\n assert isinstance(item[1], str)\\n\\n attribute = getattr_fromAddress(*item)\\n if isNumeric(attribute):\\n # If the object.attribute has a value, add it to constant factors\\n constantFactors.append(attribute)\\n else:\\n # If the object.attribute does not have a value, it is an unknownFactor\\n # TODO - the following check may be accommodated to have equation solved if the high-power term is found in another equation\\n assert item not in unknownFactors, 'LinearEquationError: Same unknown appears twice in one term, i.e. a higher power of the unknown encountered - not a linear equation!'\\n unknownFactors.append(item)\\n\\n elif any(isinstance(item, _type) for _type in [float, int]):\\n # item is a number, i.e. a coefficient\\n assert isNumeric(item)\\n constantFactors.append(item)\\n\\n constantFactor = 1\\n for factor in constantFactors:\\n constantFactor *= factor\\n\\n if len(unknownFactors) != 0:\\n # term has an unknown, e.g. term is in form of \\\"6*x\\\"\\n self.LHS.append([constantFactor, unknownFactors])\\n else:\\n # term does not have an unknown, e.g. term is in form \\\"6\\\"\\n self.RHS -= constantFactor # move constant term to the RHS\\n\\n self._gatherUnknowns()\",\n \"def normalize(term):\\n if isinstance(term, spacy.tokens.token.Token):\\n return term.text if term.pos_ == 'PROPN' else term.lemma_\\n elif isinstance(term, spacy.tokens.span.Span):\\n return ' '.join(word.text if word.pos_ == 'PROPN' else word.lemma_\\n for word in term)\\n else:\\n msg = \\\"Normalization requires a Token or Span, not {}.\\\".format(type(term))\\n raise TypeError(msg)\",\n \"def simple_lemmatise(subword_dict):\\n return norm_word_id(subword_dict[\\\"word_id\\\"])\",\n \"def simplify(phrase):\\n list_phrase = phrase.split()\\n \\n first_noun = list_phrase[0:2]\\n first_verb = list_phrase[-1]\\n rest_list_phrase = list_phrase [2:-1]\\n \\n rest_phrase = phrase[len(first_noun[0] + first_noun[1]) + 2 :\\n (-1 * len(first_verb)) - 1]\\n #We calculate the length of the first two words and add 2 for the\\n #number of spaces to start from the beginning of the rest of the phrase\\n #and end at the beginning of the space before the last word by\\n #subtracting the length of the last word by 1.\\n \\n #This is done because we are dealing with lists and strings concurrently.\\n \\n if len(rest_phrase) == 0:\\n return first_noun[0] + \\\" \\\" + first_noun[1]\\n \\n return (simplify(rest_phrase) + \\\" that \\\" + first_verb + \\\" \\\" +\\n first_noun[0] + \\\" \\\" + first_noun[1])\",\n \"def _normal_ordered_term(term, coefficient):\\n term = list(term)\\n ordered_term = FermionOperator()\\n for i in range(1, len(term)):\\n for j in range(i, 0, -1):\\n left_sub_term = term[j - 1]\\n right_sub_term = term[j]\\n # Swap operators if left operator is annihilation op and right operator is\\n # a\\\\dagger operator\\n if not left_sub_term[1] and right_sub_term[1]:\\n term[j], term[j - 1] = left_sub_term, right_sub_term\\n coefficient = coefficient * -1\\n # If indice are same, employ the anti-commutation relationship\\n # And generate the new term\\n if left_sub_term[0] == right_sub_term[0]:\\n new_term = term[:(j - 1)] + term[(j + 1):]\\n ordered_term += _normal_ordered_term(\\n new_term, -coefficient)\\n # Deal with the case with same operator\\n elif left_sub_term[1] == right_sub_term[1]:\\n # If indice are same,evaluate it to zero.\\n if left_sub_term[0] == right_sub_term[0]:\\n return ordered_term\\n # Swap them if same operator but lower index on left\\n if left_sub_term[0] < right_sub_term[0]:\\n term[j], term[j - 1] = left_sub_term, right_sub_term\\n coefficient = coefficient * -1\\n\\n # Add the term and return.\\n ordered_term += FermionOperator(tuple(term), coefficient)\\n return ordered_term\",\n \"def update(self):\\n\\n terms_toRemove = []\\n\\n for termIndex, [term_constantFactor, term_unknowns_attributeAddresses] in enumerate(self.LHS):\\n\\n # Check if coefficient is 0 - then no need to process any of the unknowns since term will be 0 anyways\\n if term_constantFactor == 0:\\n terms_toRemove.append(termIndex)\\n continue # continue to next term, no need to resolve the unknowns of this term since the product will be 0 anyways\\n\\n # Check if any unknowns became known\\n unknowns_toRemove = []\\n for unknown_attributeAddress in term_unknowns_attributeAddresses:\\n attribute = getattr_fromAddress(*unknown_attributeAddress)\\n if isNumeric(attribute):\\n # object.attribute which had previously been identified as unknown now has a value, add it to the constant factor product and remove from the unknowns\\n self.LHS[termIndex][0] *= attribute # multiply it with the constant factor product\\n unknowns_toRemove.append([termIndex, unknown_attributeAddress])\\n for termIndex, unknown_attributeAddress in unknowns_toRemove: # remove unknowns which have become known in the end\\n # removing in the end not to tamper with the iteration of the above loop\\n self.LHS[termIndex][1].remove(unknown_attributeAddress)\\n\\n # Move constants to RHS\\n if self.LHS[termIndex][1] == []:\\n # if term has no unknowns, it is a constant, move to RHS\\n self.RHS -= self.LHS[termIndex][0]\\n self.LHS.pop(termIndex)\\n\\n for termIndex in reversed(terms_toRemove): # reversed - otherwise would tamper with indices of items identified for removal\\n self.LHS.pop(termIndex)\\n\\n self._gatherUnknowns()\",\n \"def subst_i(term):\\n return Term(term.sums, term.amp.xreplace({i: k}), term.vecs)\",\n \"def simplify(phrase):\\n \\n num_actors = 0\\n \\n if phrase == \\\"\\\":\\n return 0\\n \\n phrase_list = phrase.split()\\n\\n for word in phrase_list:\\n if word == \\\"the\\\":\\n num_actors += 1\\n \\n index = (2 * num_actors) - 1\\n actor = phrase_list[index]\\n verb = phrase_list[index + 1]\\n \\n del phrase_list[index]\\n del phrase_list[index - 1]\\n del phrase_list[index + 1]\\n \\n phrase_string = \\\"\\\"\\n for word in phrase_list:\\n phrase_string += word\\n phrase_string += \\\" \\\"\\n \\n \\n return \\\"the\\\" + actor + \\\"that\\\" + verb + simplify(phase_string)\",\n \"def deep_simplify(tensor: Tensor):\\n\\n # Initial simplification.\\n res = tensor.simplify()\\n # This can possibly reduce the number of terms.\\n res = res.merge_j()\\n res = res.simplify_am()\\n\\n # Final trial.\\n res = res.simplify().merge_j()\\n\\n return res\",\n \"def simplify(self):\\n if 0 in self.numer:\\n self.numer = [0, ]\\n self.denom = []\\n self.neg = False\\n return\\n # Eliminate common factors:\\n for factor in set(self.numer):\\n # number of shared occurrences:\\n count = min(self.denom.count(factor),\\n self.numer.count(factor))\\n # Remove each shared occurrence:\\n for i in range(count):\\n self.numer.remove(factor)\\n self.denom.remove(factor)\",\n \"def visit_term(self, node, children):\\n if self.debug:\\n print(\\\"Term {}\\\".format(children))\\n term = children[0]\\n for i in range(2, len(children), 2):\\n if children[i-1] == \\\"*\\\":\\n term *= children[i]\\n else:\\n term /= children[i]\\n if self.debug:\\n print(\\\"Term = {}\\\".format(term))\\n return term\",\n \"def correct_subscript(sv, tree):\\r\\n if not tree or tree[0]!=Special: return tree\\r\\n O, A, B=tree # subscripting ( e.g. cumul(L)(0) ) \\r\\n O=tree_join(A) # make operator from first term \\r\\n A, B = B, None # make subscript from second term\\r\\n return O, A, B\",\n \"def build_sublemma_index(self):\\n terms = []\\n with open(self.path_lemma_terms, 'r', encoding='utf8') as f:\\n for line in f:\\n term = line.strip('\\\\n')\\n terms.append(term)\\n terms = set(terms)\\n for term in terms:\\n term_list = term.split('_')\\n subterms = get_sublists(term_list)\\n self.sublemma_index[term] = [t for t in subterms if t in terms]\",\n \"def _simplification_technique_1(rels):\\n rels = list(set(rels))\\n rels.sort()\\n l_rels = len(rels)\\n\\n # all syllables with single syllable\\n one_syllable_rels = set()\\n # since \\\"nw\\\" has a max size = l_rels, only identity element\\n # removal can possibly happen\\n nw = [None]*l_rels\\n for i in range(l_rels):\\n w = rels[i].identity_cyclic_reduction()\\n if w.number_syllables() == 1:\\n\\n # replace one syllable relator with the corresponding inverse\\n # element, for ex. x**-4 -> x**4 in relator list\\n if w.array_form[0][1] < 0:\\n rels[i] = w**-1\\n one_syllable_rels.add(rels[i])\\n\\n # since modifies the array rep., so should be\\n # added a list\\n nw[i] = list(rels[i].array_form)\\n\\n # bound the exponent of relators, making use of the single\\n # syllable relators\\n for i in range(l_rels):\\n k = nw[i]\\n rels_i = rels[i]\\n for gen in one_syllable_rels:\\n n = gen.array_form[0][1]\\n gen_arr0 = gen.array_form[0][0]\\n j = len(k) - 1\\n while j >= 0:\\n if gen_arr0 == k[j][0] and gen is not rels_i:\\n t = Mod(k[j][1], n)\\n\\n # multiple of one syllable relator\\n if t == 0:\\n del k[j]\\n zero_mul_simp(k, j - 1)\\n j = len(k)\\n\\n # power should be bounded by (-n/2, n/2]\\n elif t <= n/2:\\n k[j] = k[j][0], Mod(k[j][1], n)\\n elif t > n/2:\\n k[j] = k[j][0], Mod(k[j][1], n) - n\\n j -= 1\\n\\n return nw\",\n \"def removeSameTerms(lines):\\r\\n flag_main = 0\\r\\n line_depth = find_depth(lines)\\r\\n\\r\\n i = 0\\r\\n while i < len(lines):\\r\\n subst_dict = {}\\r\\n j = i + 1\\r\\n while j < len(lines):\\r\\n if set(lines[i][1:3]) == set(lines[j][1:3]): # same function detected\\r\\n flag_main = 1\\r\\n if 'y' in lines[j][0]: # taking care of the special case\\r\\n subst_dict[lines[i][0]] = lines[j][0]\\r\\n else: # 'y' in lines[i][0] is covered in this case too\\r\\n subst_dict[lines[j][0]] = lines[i][0]\\r\\n \\r\\n # deletion\\r\\n if line_depth[i] < line_depth[j]:\\r\\n del lines[j]\\r\\n else:\\r\\n del lines[i]\\r\\n \\r\\n # substitution\\r\\n for k in range(len(lines)):\\r\\n if lines[k][0] in subst_dict.keys():\\r\\n lines[k][0] = subst_dict[lines[k][0]]\\r\\n elif lines[k][1] in subst_dict.keys():\\r\\n lines[k][1] = subst_dict[lines[k][1]]\\r\\n elif lines[k][2] in subst_dict.keys():\\r\\n lines[k][2] = subst_dict[lines[k][2]]\\r\\n \\r\\n # restart the whole loop after substitution\\r\\n i = -1\\r\\n break\\r\\n j += 1\\r\\n i += 1\\r\\n \\r\\n # reorganise the order\\r\\n reorgOrder(lines)\\r\\n # renaming in order\\r\\n renaming(lines)\\r\\n \\r\\n return flag_main\",\n \"def simplify_nature(sv, tot, done):\\r\\n prev=tot\\r\\n # one pass to get rid of list nature\\r\\n if done: \\r\\n for nod in sv.Object.values():\\r\\n if len(nod.nature)==2 and Lst[0] in nod.nature: # not a list unless proved otherwise\\r\\n nod.nature.remove(Lst[0])\\r\\n prev-=1\\r\\n done=False # continue search \\r\\n\\r\\n # one pass to infer a state\\r\\n if done: \\r\\n for nod in sv.Object.values():\\r\\n if len(nod.nature)>1 and Stt[0] in nod.nature: # a state unless proved otherwise \\r\\n prev-=len(nod.nature)-1\\r\\n nod.nature=Stt[:]\\r\\n done=False # continue search \\r\\n\\r\\n return prev, done\",\n \"def simplify(word, lexicon):\\n\\tsim = random.choice(lexicon[word])[1]\\n\\tif type(sim) == str:\\n\\t\\tsim = [sim]\\n\\treturn \\\" \\\".join(sim)\",\n \"def normalize_word(self, word, treebank_tag):\\n wordnet_pos, part_of_speech = self.get_wordnet_pos(treebank_tag)\\n\\n if wordnet_pos == wordnet.NOUN and part_of_speech == 'proper':\\n return word, 'proper_noun'\\n\\n lemword = self.wordnetlemmatize.lemmatize(word, wordnet_pos)\\n return self.stemmer.stem(lemword), part_of_speech\",\n \"def normalization(obj):\\n dic = obj.mainfield.para_dict.copy()\\n for item in obj.forfield: dic.update(item.para_dict)\\n for item in obj.existfield: dic.update(item.para_dict)\\n\\n global_dic = number_type(dic)\\n obj.normal_guards = norm_rep(global_dic, obj.all_sentence)\\n\\n main_dic = number_type(obj.mainfield.para_dict)\\n obj.mainfield.content = norm_rep(main_dic, obj.mainfield.content)\\n\\n for index in range(len(obj.forfield)):\\n obj.forfield[index].para_dict.update(obj.mainfield.para_dict)\\n # temp_dic.update(obj.mainfield.para_dict)\\n # for_dic = number_type(temp_dic)\\n obj.forfield[index].content = norm_rep(global_dic, obj.forfield[index].content)\\n print(global_dic, obj.forfield[index].para_dict)\\n obj.forfield[index].para_dict = pair_2_dict(global_dic, obj.forfield[index].para_dict)\\n\\n for index in range(len(obj.existfield)):\\n obj.existfield[index].para_dict.update(obj.mainfield.para_dict)\\n # temp_dic.update(obj.mainfield.para_dict)\\n # exist_dic = number_type(temp_dic)\\n obj.existfield[index].content = norm_rep(global_dic, obj.existfield[index].content)\\n obj.existfield[index].para_dict = pair_2_dict(global_dic, obj.existfield[index].para_dict)\\n\\n # change para_dict: {'i':'NODE} -> {'NODE_1', 'NODE'}\\n obj.mainfield.para_dict = pair_2_dict(global_dic, obj.mainfield.para_dict)\",\n \"def simplify_am(self, tensor: Tensor):\\n\\n tensor = tensor.map2amps(_rewrite_cg)\\n\\n # Initial simplification of some summations.\\n tensor = tensor.simplify_sums(\\n simplifiers=self._am_sum_simplifiers.bcast\\n )\\n\\n # Deltas could come from some simplification rules.\\n tensor = tensor.simplify_deltas()\\n\\n # Some summations could become simplifiable after the delta resolution.\\n tensor = tensor.simplify_sums()\\n\\n return tensor\",\n \"def clean_text_subroutine(text, thing, suffix):\\n\\n # Synonyms + skipping optional part of the sentence\\n clean_text = skip_and_replace_phrases(text)\\n\\n # Remove full stop, empty spaces, capitalize the start letter.\\n clean_text = re.sub(' +', ' ', clean_text.replace(suffix, '').strip(' '))\\n # First replace 'a thing' -> 'an object'.\\n # Then perform remaining actions.\\n if thing == 'object':\\n clean_text = clean_text.replace('a thing', 'an object')\\n clean_text = clean_text.replace('thing', thing)\\n clean_text = clean_text[0].upper() + clean_text[1:] + suffix\\n return clean_text\",\n \"def nom_struc_rebuilding(nom_struc):\\n\\n #init\\n nominal_structure = ns = nn = []\\n i = 0\\n\\n while i < len(nom_struc):\\n\\n if nom_struc[i]._quantifier == 'SOME' and (nom_struc[i].det == ['a'] or nom_struc[i].det == ['an']):\\n nom_struc[i]._quantifier = 'ONE'\\n\\n #The first nominal group not preceded but 'and' if there is\\n if nom_struc[i]._conjunction == 'AND' and i > 0:\\n nominal_structure = nominal_structure + ['and']\\n elif nom_struc[i]._conjunction == 'OR':\\n nominal_structure = nominal_structure + ['or']\\n elif nom_struc[i]._conjunction == 'BUT':\\n nominal_structure = nominal_structure + ['but']\\n\\n #We recover the nominal group and his complement\\n if nom_struc[i]._quantifier == 'SOME' or nom_struc[i]._quantifier == 'ALL' or nom_struc[\\n i]._quantifier == 'ANY' or (nom_struc[i]._quantifier == 'DIGIT' and nom_struc[i].det != 'one'):\\n #If there is a specific quantifier (plural)\\n for n in ResourcePool().plural_nouns:\\n if nom_struc[i].noun != [] and n[1] == nom_struc[i].noun[0]:\\n nn = [n[0]]\\n\\n #If it is not a specific plural, we add 's'\\n if nom_struc[i].noun != [] and nn == []:\\n nn = [nom_struc[i].noun[0] + 's']\\n\\n #We reconver the other information \\n nominal_structure = nominal_structure + nom_struc[i].det\\n for z in nom_struc[i].adj:\\n nominal_structure = nominal_structure + z[1] + [z[0]]\\n nominal_structure = nominal_structure + nn\\n\\n #Re-init\\n nn = []\\n\\n else:\\n #if not plural\\n nominal_structure = nominal_structure + nom_struc[i].det\\n for z in nom_struc[i].adj:\\n nominal_structure = nominal_structure + z[1] + [z[0]]\\n nominal_structure = nominal_structure + nom_struc[i].noun\\n\\n #We recover noun complement\\n if nom_struc[i].noun_cmpl:\\n nominal_structure = nominal_structure + ['of']\\n nominal_structure = nominal_structure + nom_struc_rebuilding(nom_struc[i].noun_cmpl)\\n\\n #We recover the relative\\n for j in nom_struc[i].relative:\\n if not j.sn:\\n ns = [nom_struc[i]]\\n\\n nominal_structure = nominal_structure + [j.aim] + sentence_rebuilding.relative(j, ns)\\n ns = []\\n\\n i += 1\\n return nominal_structure\",\n \"def simplify(cnf, lit):\\n for clause in cnf:\\n for l in clause:\\n if l.equals(lit):\\n cnf.remove(clause)\\n break\\n elif l.is_opposite(lit):\\n clause.remove(l)\\n return cnf\",\n \"def substitution(formula, old_subformula, new_subformula):\\n pass\\n # ======== YOUR CODE HERE ========\",\n \"def clean_term(term, site='', siteWordCount=None, dataType=''): # dtype\\n if pd.isna(term): \\n print(\\\"(clean_term) Input term is NaN: {}\\\".format(term))\\n return ''\\n if not isinstance(term, str): \\n return str(term)\\n\\n insigWords = LoincTable.stop_words # [\\\"IN\\\", \\\"FROM\\\", \\\"ON\\\", \\\"OR\\\", \\\"OF\\\", \\\"BY\\\", \\\"AND\\\", \\\"&\\\", \\\"TO\\\", \\\"BY\\\", \\\"\\\", \\\" \\\"]\\n \\n modTerm = (term.replace(\\\"'\\\", \\\"\\\").replace(\\\",\\\", \\\" \\\").replace(\\\".\\\", \\\" \\\") \\\\\\n .replace(\\\":\\\", \\\" \\\").replace('\\\\t', \\\" \\\").replace(\\\"^\\\", \\\" \\\").replace(\\\"+\\\", \\\" \\\")\\\\\\n .replace(\\\"*\\\", \\\" \\\").replace(\\\"~\\\", \\\" \\\").replace(\\\"(\\\", \\\" \\\").replace(\\\")\\\", \\\" \\\")\\\\\\n .replace(\\\"!\\\", \\\" \\\").replace(\\\"[\\\", \\\" \\\").replace(\\\"]\\\", \\\" \\\").replace(\\\"{\\\", \\\" \\\").replace(\\\"}\\\", \\\" \\\")\\\\\\n .replace(\\\"_\\\", \\\" \\\").replace(\\\"|\\\", \\\" \\\").replace('\\\"', \\\" \\\").split(\\\" \\\"))\\n\\n #############################################################################\\n i = 0\\n while i < len(modTerm):\\n modTerm[i] = re.sub(r\\\"\\\\d{1,2}[\\\\/-]\\\\d{1,4}([\\\\/-]\\\\d{2,4})*|\\\\d{6}\\\", \\\"\\\", modTerm[i])\\n if modTerm[i] != None and len(modTerm[i]) > 0:\\n i = i + 1\\n else:\\n modTerm.remove(modTerm[i])\\n #############################################################################\\n\\n # remove repeated tokens \\n modTerm = sorted(set(modTerm), key=modTerm.index)\\n\\n j = 0\\n nameSplit = list()\\n while j < len(modTerm):\\n splits = modTerm[j].replace(\\\"/\\\", \\\" \\\").replace(\\\"\\\\\\\\\\\", \\\" \\\").replace(\\\"-\\\", \\\" \\\").split(\\\" \\\")\\n k = 0\\n while ((k < len(splits)) and (len(splits[k]) > 0) and (splits[k] not in insigWords)):\\n newWord = splits[k].strip()\\n nameSplit.append(newWord)\\n\\n if len(site) > 0 and isinstance(siteWordCount, dict): \\n siteWordCount[site][newWord] += 1\\n k = k + 1\\n j = j + 1\\n\\n return \\\" \\\".join(nameSplit)\",\n \"def _translate(s):\\r\\n\\t\\t\\r\\n\\t\\t# new term is determined by a space followed by + or -\\r\\n\\t\\t# replace with _ and split into terms\\r\\n\\t\\ts = s.replace(' +','_+')\\r\\n\\t\\ts = s.replace(' -','_-')\\r\\n\\t\\t\\r\\n\\t\\t# split string into terms\\r\\n\\t\\tp = s.split('_')\\r\\n\\t\\tt = [Te(i) for i in p]\\r\\n\\t\\t\\r\\n\\t\\treturn t\",\n \"def normalize_answer(s):\\n\\n def remove_articles(text):\\n return re_art.sub(' ', text)\\n\\n def white_space_fix(text):\\n return ' '.join(text.split())\\n\\n def remove_punc(text):\\n return re_punc.sub(' ', text) # convert punctuation to spaces\\n\\n def lower(text):\\n return text.lower()\\n\\n return white_space_fix(remove_articles(remove_punc(lower(s))))\",\n \"def normalize_answer(s):\\n\\n def remove_articles(text):\\n return re_art.sub(' ', text)\\n\\n def white_space_fix(text):\\n return ' '.join(text.split())\\n\\n def remove_punc(text):\\n return re_punc.sub(' ', text) # convert punctuation to spaces\\n\\n def lower(text):\\n return text.lower()\\n\\n return white_space_fix(remove_articles(remove_punc(lower(s))))\",\n \"def correct_spelling(sample):\\n words = nltk.word_tokenize(sample[\\\"full_text\\\"])\\n for word in words:\\n for char, duplicate_char in duplicate_chars.items():\\n word = re.sub(duplicate_char, char, word)\\n #sample[\\\"full_text\\\"] = ' '.join([spell(w)] for w in tweet.split()])\\n sample[\\\"full_text\\\"] = ' '.join([w for w in words])\\n return sample\",\n \"def reindex_subcomponent_taxa():\\n pass\",\n \"def simplify_indices(kernel):\\n from loopy.symbolic import SubstitutionRuleMappingContext as SRMC\\n rule_mapping_context = SRMC(kernel.substitutions,\\n kernel.get_var_name_generator())\\n idx_simplifier = IndexSimplifier(rule_mapping_context, kernel)\\n return rule_mapping_context.finish_kernel(idx_simplifier.map_kernel(kernel))\",\n \"def normalize_answer(s):\\n\\n def remove_articles(text):\\n return re.sub(r'\\\\b(a|an|the)\\\\b', ' ', text)\\n\\n def white_space_fix(text):\\n return ' '.join(text.split())\\n\\n def remove_punc(text):\\n exclude = set(string.punctuation)\\n return ''.join(ch for ch in text if ch not in exclude)\\n\\n def lower(text):\\n return text.lower()\\n\\n return white_space_fix(remove_articles(remove_punc(lower(normalize(s)))))\",\n \"def morph_noun(word, number, a_an, feature):\\n word = morph_number(word, number)\\n if not (number in ['first', 'second']) and word[-1] == 's':\\n return mark_noun_as_plural(word)\\n else:\\n return word\\n\\n if a_an == 'an':\\n return mark_noun_as_an(word)\\n else:\\n return word\",\n \"def normal_ordered_quad_term(term, coefficient, hbar=1.):\\n # Iterate from left to right across operators and reorder to normal\\n # form. Swap terms operators into correct position by moving from\\n # left to right across ladder operators.\\n term = list(term)\\n ordered_term = QuadOperator()\\n for i in range(1, len(term)):\\n for j in range(i, 0, -1):\\n right_operator = term[j]\\n left_operator = term[j - 1]\\n\\n # Swap operators if q on right and p on left.\\n # p q -> q p\\n if right_operator[1] == 'q' and not left_operator[1] == 'q':\\n term[j - 1] = right_operator\\n term[j] = left_operator\\n\\n # Replace p q with i hbar + q p\\n # if indices are the same.\\n if right_operator[0] == left_operator[0]:\\n new_term = term[:(j - 1)] + term[(j + 1)::]\\n\\n # Recursively add the processed new term.\\n ordered_term += normal_ordered_quad_term(\\n tuple(new_term), -coefficient * 1j * hbar)\\n\\n # Handle case when operator type is the same.\\n elif right_operator[1] == left_operator[1]:\\n\\n # Swap if same type but lower index on left.\\n if right_operator[0] > left_operator[0]:\\n term[j - 1] = right_operator\\n term[j] = left_operator\\n\\n # Add processed term and return.\\n ordered_term += QuadOperator(tuple(term), coefficient)\\n return ordered_term\",\n \"def _sort_majorana_term(term):\\n if len(term) < 2:\\n return term, 0\\n center = len(term) // 2\\n left_term, left_parity = _sort_majorana_term(term[:center])\\n right_term, right_parity = _sort_majorana_term(term[center:])\\n merged_term, merge_parity = _merge_majorana_terms(left_term, right_term)\\n return merged_term, (left_parity + right_parity + merge_parity) % 2\",\n \"def _normalize_answer(s):\\n\\n def remove_articles(text):\\n return re.sub(r'\\\\b(a|an|the)\\\\b', ' ', text)\\n\\n def white_space_fix(text):\\n return ' '.join(text.split())\\n\\n def remove_punc(text):\\n exclude = set(string.punctuation)\\n return ''.join(ch for ch in text if ch not in exclude)\\n\\n def lower(text):\\n return text.lower()\\n\\n return white_space_fix(remove_articles(remove_punc(lower(s))))\",\n \"def normalise(word):\\n\\t\\tword = word.lower()\\n\\t\\tword = lemmatizer.lemmatize(word)\\n\\t\\t# word = stemmer.stem_word(word)\\n\\t\\treturn word\",\n \"def normalize(s):\\n def remove_articles(text):\\n return re.sub(r'\\\\b(a|an|the)\\\\b', ' ', text)\\n\\n def white_space_fix(text):\\n return ' '.join(text.split())\\n\\n# def remove_punc(text):\\n# exclude = set(string.punctuation)\\n# return ''.join(ch for ch in text if ch not in exclude)\\n\\n def lower(text):\\n return text.lower()\\n\\n return white_space_fix(remove_articles(lower(s)))\",\n \"def prepare_terms(terms, search_mode):\\n if search_mode in (\\\"contains\\\", \\\"starts_with\\\"):\\n terms = terms.replace(\\\"_\\\", \\\"\\\\_\\\").replace(\\\"%\\\", \\\"\\\\%\\\")\\n\\n if search_mode == \\\"contains\\\":\\n terms = \\\"%\\\" + terms + \\\"%\\\"\\n elif search_mode == \\\"starts_with\\\":\\n terms = terms + \\\"%\\\"\\n return terms\",\n \"def __mul__(self, other, nested=False):\\n\\n other = formula(other, namespace=self.namespace)\\n\\n selftermnames = self.termnames()\\n othertermnames = other.termnames()\\n\\n I = len(selftermnames)\\n J = len(othertermnames)\\n\\n terms = []\\n termnames = []\\n\\n for i in range(I):\\n for j in range(J):\\n termname = '%s*%s' % (str(selftermnames[i]), str(othertermnames[j]))\\n pieces = termname.split('*')\\n pieces.sort()\\n termname = '*'.join(pieces)\\n termnames.append(termname)\\n\\n selfnames = self.terms[i].names()\\n othernames = other.terms[j].names()\\n\\n if self.terms[i].name is 'intercept':\\n _term = other.terms[j]\\n _term.namespace = other.namespace\\n\\n elif other.terms[j].name is 'intercept':\\n _term = self.terms[i]\\n _term.namespace = self.namespace\\n else:\\n names = []\\n\\n d1 = len(selfnames) \\n d2 = len(othernames)\\n\\n for r in range(d1):\\n for s in range(d2):\\n name = '%s*%s' % (str(selfnames[r]), str(othernames[s]))\\n pieces = name.split('*')\\n pieces.sort()\\n name = '*'.join(pieces)\\n names.append(name)\\n\\n def product_func(value, d1=d1, d2=d2):\\n\\n out = []\\n for r in range(d1):\\n for s in range(d2):\\n out.append(value[r] * value[d1+s])\\n return N.array(out)\\n\\n sumterms = self + other\\n sumterms.terms = [self, other] # enforce the order we want\\n sumterms.namespace = self.namespace\\n\\n _term = quantitative(names, func=sumterms, termname=termname,\\n transform=product_func)\\n _term.namespace = self.namespace\\n\\n\\n terms.append(_term)\\n\\n return formula(terms, namespace=self.namespace)\",\n \"def _solve_double_synonym(parse_tree, solution_format=None):\\n def _get_value(solution_list, word):\\n # Gets the value of a word in a solution list\\n for solution in solution_list:\\n if solution[0] == word:\\n return solution[1]\\n\\n return 0\\n\\n # Get the two synonym parts\\n first_syn, second_syn = _get_parts_ignore_EQU(parse_tree)\\n first_syn = _create_sentence(first_syn)\\n second_syn = _create_sentence(second_syn)\\n\\n # Get top 1000 matching scores for each part of the clue\\n if solution_format is not None:\\n first_solutions = SimilaritySolver.solve(first_syn, length=solution_format.get_total_length(spaces=True))\\n second_solutions = SimilaritySolver.solve(second_syn, length=solution_format.get_total_length(spaces=True))\\n second_words = [word for word, _ in second_solutions if solution_format.check(word)]\\n else:\\n first_solutions = SimilaritySolver.solve(first_syn)\\n second_solutions = SimilaritySolver.solve(second_syn)\\n second_words = [word for word, _ in second_solutions]\\n\\n # Combine both lists, with the value being the product of the value for eac syn part\\n solutions = [(solution[0], _get_value(second_solutions, solution[0]) * solution[1]) for\\n solution in first_solutions if solution[0] in second_words]\\n\\n return solutions\",\n \"def oversimplify(strng):\\n s = strng.encode('latex').decode('utf-8')\\n s = reg_simplify.sub('', s)\\n return s\",\n \"def _gen_terms(self, tree):\\n for leaf in self._leaves(tree):\\n terms = [self._normalize(w) for w, _ in leaf if self._filter(w)]\\n # Phrase only\\n if len(terms) > 1:\\n yield terms\",\n \"def spelling_normalization(words, dictionary):\\n\\n logging.debug('spelling_normalization(): Incoming words: ')\\n logging.debug(words)\\n\\n def edits1(word):\\n \\\"\\\"\\\"Return 1-edits away\\\"\\\"\\\"\\n letters = 'abcdefghijklmnopqrstuvwxyz'\\n\\n def split_word(word):\\n \\\"\\\"\\\"Returns all possible variations of word split up\\\"\\\"\\\"\\n return [(word[:i], word[i:]) for i in range(len(word) + 1)]\\n\\n pairs = split_word(word)\\n deletes = [a + b[1:] for (a, b) in pairs if b]\\n transposes = [a + b[1] + b[0] + b[2:] for (a, b) in pairs if len(b) > 1]\\n replaces = [a + c + b[1:] for (a, b) in pairs for c in letters if b]\\n inserts = [a + c + b for (a, b) in pairs for c in letters]\\n return set(deletes + transposes + replaces + inserts)\\n\\n def edits2(word):\\n \\\"\\\"\\\"Return 2-edits away\\\"\\\"\\\"\\n return {e2 for e1 in edits1(word) for e2 in edits1(e1)}\\n\\n def known(words):\\n return {w for w in words if w in dictionary}\\n\\n corrected = []\\n for word in words:\\n if word.isnumeric():\\n corrected.append(word)\\n continue\\n elif word in dictionary or wordnet.synsets(word):\\n corrected.append(word)\\n continue\\n else: # Doesn't seem to be necessary, but will be guard clause; seem to have some suspicious deletions\\n candidates = (known(edits1(word)) or\\n known(edits2(word)) or\\n [word])\\n corrected.append(max(candidates, key=dictionary.get))\\n logging.debug('spelling_normalization(): Outgoing words:')\\n logging.debug(corrected)\\n return corrected\",\n \"def normalize_answer(s):\\n\\tdef remove_articles(text):\\n\\t\\treturn re.sub(r'\\\\b(a|an|the)\\\\b', ' ', text)\\n\\n\\tdef white_space_fix(text):\\n\\t\\treturn ' '.join(text.split())\\n\\n\\tdef remove_punc(text):\\n\\t\\texclude = set(string.punctuation)\\n\\t\\treturn ''.join(ch for ch in text if ch not in exclude)\\n\\n\\tdef lower(text):\\n\\t\\treturn text.lower()\\n\\n\\treturn white_space_fix(remove_articles(remove_punc(lower(s))))\",\n \"def normalize_answer(s):\\n\\n def remove_articles(text):\\n return re.sub(r'\\\\b(a|an|the)\\\\b', ' ', text)\\n\\n def white_space_fix(text):\\n return ' '.join(text.split())\\n\\n def remove_punc(text):\\n exclude = set(string.punctuation)\\n return ''.join(ch for ch in text if ch not in exclude)\\n\\n def lower(text):\\n return text.lower()\\n\\n return white_space_fix(remove_articles(remove_punc(lower(s))))\",\n \"def replaceElongated(word):\\n\\n repeat_regexp = re.compile(r'(\\\\w*)(\\\\w)\\\\2(\\\\w*)')\\n repl = r'\\\\1\\\\2\\\\3'\\n if wordnet.synsets(word):\\n return word\\n repl_word = repeat_regexp.sub(repl, word)\\n if repl_word != word: \\n return replaceElongated(repl_word)\\n else: \\n return repl_word\",\n \"def _distribute_terms(terms):\\n aux_ind = 0\\n new_list = [terms[0]]\\n while aux_ind < len(terms) - 1:\\n aux_list = []\\n for i in range(len(new_list[aux_ind])):\\n for j in range(len(terms[aux_ind + 1])):\\n new_terms = Mult(new_list[aux_ind][i], terms[aux_ind + 1][j])\\n aux_list.append(new_terms)\\n new_list.append(aux_list)\\n aux_ind += 1\\n return new_list[-1]\",\n \"def normalize_answer(s):\\n\\n def remove_articles(text):\\n return re.sub(r\\\"\\\\b(a|an|the)\\\\b\\\", \\\" \\\", text)\\n\\n def white_space_fix(text):\\n return \\\" \\\".join(text.split())\\n\\n def remove_punc(text):\\n exclude = set(string.punctuation)\\n return \\\"\\\".join(ch for ch in text if ch not in exclude)\\n\\n def lower(text):\\n return text.lower()\\n\\n return white_space_fix(remove_articles(remove_punc(lower(s))))\",\n \"def normalize_answer(s):\\n\\n def remove_articles(text):\\n return re.sub(r\\\"\\\\b(a|an|the)\\\\b\\\", \\\" \\\", text)\\n\\n def white_space_fix(text):\\n return \\\" \\\".join(text.split())\\n\\n def remove_punc(text):\\n exclude = set(string.punctuation)\\n return \\\"\\\".join(ch for ch in text if ch not in exclude)\\n\\n def lower(text):\\n return text.lower()\\n\\n return white_space_fix(remove_articles(remove_punc(lower(s))))\",\n \"def simplify(self, expr):\\n return sy.simplify(expr)\",\n \"def simplify(self):\\n self._express = self._simplify(self._express)\\n self._del_derived()\\n return self\",\n \"def normalize_answer(s):\\n def remove_articles(text):\\n return re.sub(r'\\\\b(a|an|the)\\\\b', ' ', text)\\n\\n def white_space_fix(text):\\n return ' '.join(text.split())\\n\\n def remove_punc(text):\\n exclude = set(string.punctuation)\\n return ''.join(ch for ch in text if ch not in exclude)\\n\\n def lower(text):\\n return text.lower()\\n\\n return white_space_fix(remove_articles(remove_punc(lower(s))))\",\n \"def reduce_base(word: str) -> str:\\n porter = PorterStemmer()\\n return porter.stem(word)\",\n \"def normalize_answer(s):\\n def remove_articles(text):\\n regex = re.compile(r'\\\\b(a|an|the)\\\\b', re.UNICODE)\\n return re.sub(regex, ' ', text)\\n def white_space_fix(text):\\n return ' '.join(text.split())\\n def remove_punc(text):\\n exclude = set(string.punctuation)\\n return ''.join(ch for ch in text if ch not in exclude)\\n def lower(text):\\n return text.lower()\\n return white_space_fix(remove_articles(remove_punc(lower(s))))\",\n \"def normalise(word):\\n word = word.lower()\\n word = stemmer.stem_word(word)\\n word = lemmatizer.lemmatize(word)\\n return word\",\n \"def filter_plurals(ngrams):\\n\\n remove = set()\\n for ng in ngrams:\\n pl = ng[:-1] + (ng[-1] + 's',)\\n if pl in ngrams:\\n remove.add(pl)\\n try:\\n # Counts\\n ngrams[ng] += ngrams[pl]\\n except TypeError:\\n # Sets of IDs\\n ngrams[ng] |= ngrams[pl]\\n pl = ng[:-1] + (ng[-1] + 'es',)\\n if pl in ngrams:\\n remove.add(pl)\\n try:\\n # Counts\\n ngrams[ng] += ngrams[pl]\\n except TypeError:\\n # Sets of IDs\\n ngrams[ng] |= ngrams[pl]\\n for ng in remove:\\n del ngrams[ng]\\n return ngrams\",\n \"def NormalizeDisjunctions(disj,\\n clause,\\n ruleset,\\n network,\\n constructNetwork,\\n negativeStratus,\\n ignoreNegativeStratus):\\n from FuXi.DLP import breadth_first, breadth_first_replace\\n# disj = [i for i in breadth_first(clause.body) if isinstance(i,Or)]\\n while len(disj) > 1:\\n ApplyDemorgans(clause)\\n if HasBreadthFirstNestedConj(clause.body):\\n FlattenConjunctions(clause.body)\\n disj=[i for i in breadth_first(clause.body) if isinstance(i,Or)]\\n assert len(disj)<2,\\\"Unable to effectively reduce disjunctions\\\"\\n if len(disj) == 1:\\n #There is one disjunction in the body, we can reduce from:\\n #H :- B1 V B2 to H : - B1 and H :- B2\\n origDisj = disj[0]\\n for item in origDisj:\\n #First we want to replace the entire disjunct with an item within it\\n list(breadth_first_replace(clause.body,candidate=origDisj,replacement=item))\\n clause_clone = copy.deepcopy(clause)\\n disj = [i for i in breadth_first(clause_clone.body) if isinstance(i,Or)]\\n if len(disj) > 0:\\n #If the formula has disjunctions of it's own, we handle them recursively\\n NormalizeDisjunctions(disj,\\n clause_clone,\\n ruleset,\\n network,\\n constructNetwork,\\n negativeStratus,\\n ignoreNegativeStratus)\\n else:\\n if HasBreadthFirstNestedConj(clause_clone.body):\\n FlattenConjunctions(clause_clone.body)\\n #Otherwise handle normally\\n HandleNonDisjunctiveClauses(ruleset, network, constructNetwork, negativeStratus, ignoreNegativeStratus, clause_clone)\\n #restore the replaced term (for the subsequent iteration)\\n list(breadth_first_replace(clause.body,candidate=item,replacement=origDisj))\\n else:\\n #The disjunction has been handled by normal form transformation, we just need to\\n #handle normally\\n if HasBreadthFirstNestedConj(clause_clone.body):\\n FlattenConjunctions(clause_clone.body)\\n HandleNonDisjunctiveClauses(ruleset, network, constructNetwork, negativeStratus, ignoreNegativeStratus, clause)\",\n \"def _form_term_from_wick(term, contrs, phase, resolvers, wick_scheme):\\n\\n sums_dict = term.dumms\\n\\n perm, n_contred = wick_scheme\\n phase = _get_perm_phase(perm, phase)\\n\\n amp = phase\\n substs = {}\\n for contr_i in range(0, n_contred, 2):\\n contr_amp, contr_substs = contrs[perm[contr_i]][perm[contr_i + 1]]\\n amp, _ = compose_simplified_delta(\\n amp * contr_amp, contr_substs,\\n substs, sums_dict=sums_dict, resolvers=resolvers\\n )\\n continue\\n\\n vecs = tuple(term.vecs[i] for i in perm[n_contred:])\\n return term.subst(\\n substs, amp=amp * term.amp, vecs=vecs, purge_sums=True\\n )\",\n \"def multiply(self,l,s=True):\\r\\n\\t\\t\\r\\n\\t\\t# convert to line\\r\\n\\t\\tl = Li(l,c=False)\\r\\n\\t\\t\\r\\n\\t\\t# new term list\\r\\n\\t\\tw = []\\r\\n\\t\\t\\r\\n\\t\\t# for every term in first\\r\\n\\t\\tfor i in self:\\r\\n\\t\\t\\t\\t\\r\\n\\t\\t\\t# multiply each member of second\\r\\n\\t\\t\\tfor j in l:\\r\\n\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t# multiply together\\r\\n\\t\\t\\t\\tm = i.multiply(j)\\r\\n\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t# append into new line\\r\\n\\t\\t\\t\\tw.append(m)\\r\\n\\r\\n\\t\\t# new line, condenses\\r\\n\\t\\tw = Li(w)\\r\\n\\t\\t\\t\\t\\t\\r\\n\\t\\t# sort new line\\r\\n\\t\\tif s:\\r\\n\\t\\t\\tw = w.sort()\\r\\n\\t\\t\\r\\n\\t\\treturn w\",\n \"def set_weight(term, irrelevant):\\n if term in irrelevant:\\n return (0.2 * max([x/sum(indtf_features[term]) for x in indtf_features[term]]))\\n elif isinstance(term, tuple):\\n return len(term)\\n else:\\n return 1\",\n \"def _make_product(terms):\\n if terms:\\n product = terms[0]\\n for term in terms[1:]:\\n product = Mul((product, term))\\n return product \\n else:\\n return Const(1)\",\n \"def normalize(s):\\r\\n def remove_articles(text):\\r\\n return re.sub(r'\\\\b(a|an|the)\\\\b', ' ', text)\\r\\n\\r\\n def white_space_fix(text):\\r\\n return ' '.join(text.split())\\r\\n\\r\\n def remove_punc(text):\\r\\n exclude = set(string.punctuation)\\r\\n return ''.join(ch for ch in text if ch not in exclude)\\r\\n\\r\\n def lower(text):\\r\\n return text.lower()\\r\\n\\r\\n return white_space_fix(remove_articles(remove_punc(lower(s))))\",\n \"def normalize(s):\\r\\n def remove_articles(text):\\r\\n return re.sub(r'\\\\b(a|an|the)\\\\b', ' ', text)\\r\\n\\r\\n def white_space_fix(text):\\r\\n return ' '.join(text.split())\\r\\n\\r\\n def remove_punc(text):\\r\\n exclude = set(string.punctuation)\\r\\n return ''.join(ch for ch in text if ch not in exclude)\\r\\n\\r\\n def lower(text):\\r\\n return text.lower()\\r\\n\\r\\n return white_space_fix(remove_articles(remove_punc(lower(s))))\",\n \"def eng_with_sub(self, eng: list, subword: list) -> list:\\n subwords = subword + eng[0]\\n while [] in subwords:\\n subwords.remove([])\\n out = \\\" \\\".join('%s' % id for id in subwords).split()\\n return out\",\n \"def fold_term(self, init_repr, term):\\n if isinstance(term, Var):\\n return self.var(init_repr, term.name)\\n elif isinstance(term, Const):\\n return self.const(init_repr, term.name)\\n elif isinstance(term, Dist):\\n return self.dist(init_repr, term.name)\\n elif isinstance(term, Func):\\n return self.func(\\n init_repr,\\n term.funcname,\\n [ self.fold_term(init_repr, x)\\n for x in term.args ])\\n elif isinstance(term, Eq):\\n return self.eq(\\n init_repr,\\n term.pos,\\n self.fold_term(init_repr, term.t1),\\n self.fold_term(init_repr, term.t2))\\n elif isinstance(term, Disj):\\n return self.disj(\\n init_repr,\\n term.role,\\n [ self.fold_term(init_repr, eq)\\n for eq in term.eqs ])\\n elif isinstance(term, Conj):\\n return self.conj(\\n init_repr,\\n [ self.fold_term(init_repr, disj)\\n for disj in term.disjs ])\",\n \"def normalize(self, factor):\",\n \"def normal(e, **kw_args):\\n\\n if not e:\\n return S.Zero\\n\\n opts = {\\n 'simplify_kronecker_deltas': False,\\n 'expand': True,\\n 'simplify_dummies': False,\\n 'keep_only_fully_contracted': False,\\n 'lam': 1\\n }\\n opts.update(kw_args)\\n\\n # break up any NO-objects, and evaluate commutators\\n e = e.doit(wicks=True)\\n\\n # make sure we have only one term to consider\\n e = e.expand()\\n if isinstance(e, Add):\\n return Add(*[ normal(term, **kw_args) for term in e.args])\\n\\n # For Mul-objects we can actually do something\\n if isinstance(e, Mul):\\n\\n # we don't want to mess around with commuting part of Mul\\n # so we factorize it out before starting recursion\\n c_part = []\\n string1 = []\\n for factor in e.args:\\n if factor.is_commutative:\\n c_part.append(factor)\\n else:\\n string1.append(factor)\\n n = len(string1)\\n\\n # catch trivial cases\\n if n == 0:\\n result = e\\n elif n == 1:\\n result = e\\n else: # non-trivial\\n if n > 2:\\n # recursive step\\n if isinstance(string1[0], CreateBoson) \\\\\\n or (string1[0].is_Pow and \\\\\\n isinstance(string1[0].args[0], CreateBoson)):\\n # if the first term is ad^m\\n result = string1[0] * normal(Mul(*string1[1:]), **kw_args)\\n else:\\n # if the first term is a^m,\\n # bring the first two terms to normal order first\\n result = normal(normal(Mul(*string1[:2]), **kw_args)*Mul(*string1[2:]), **kw_args)\\n else: # n = 2,\\n result = _normal(string1, opts['lam'])\\n result = Mul(*c_part)*result\\n\\n if opts['expand']:\\n result = result.expand()\\n # if opts['simplify_kronecker_deltas']:\\n # result = evaluate_deltas(result)\\n\\n return result\\n\\n # there was nothing to do\\n return e\",\n \"def tag_terms(text, terms, nlp=None):\\n from spacy.lang.en.stop_words import STOP_WORDS\\n spacy.tokens.token.Token.set_extension('workaround', default='', force=True)\\n \\n HEURISTIC_TOKENS = [\\\"-\\\", \\\"plant\\\", \\\"substance\\\", \\\"atom\\\"]\\n \\n # default to Stanford NLP pipeline wrapped in Spacy\\n if nlp is None:\\n snlp = stanfordnlp.Pipeline(lang=\\\"en\\\")\\n nlp = StanfordNLPLanguage(snlp)\\n \\n # preprocess with spacy if needed\\n if type(terms[0]) != spacy.tokens.doc.Doc:\\n terms = [nlp(term) for term in terms]\\n if (type(text) != spacy.tokens.doc.Doc and type(text) != spacy.tokens.span.Span):\\n text = nlp(text)\\n \\n # set up a custom representation of the text where we can add term type annotations\\n for token in text:\\n token._.workaround = token.text_with_ws\\n\\n lemmatized_text = [token.lemma_ for token in text]\\n tokenized_text = [token.text for token in text]\\n tags = ['O'] * len(text)\\n found_terms = defaultdict(lambda: {\\\"text\\\": [], \\\"indices\\\": [], \\\"pos\\\": [], \\\"type\\\": []})\\n \\n # iterate through terms from longest to shortest\\n terms = sorted(terms, key=len)[::-1]\\n for spacy_term in terms:\\n term_length = len(spacy_term)\\n lemma_term_list = [token.lemma_ for token in spacy_term]\\n text_term_list = [token.text for token in spacy_term]\\n term_lemma = \\\" \\\".join(lemma_term_list)\\n \\n # skip short acronyms that can cause problems\\n if len(term_lemma) <= 2:\\n continue\\n \\n # additional check to check for simple plural of uncommon biology terms\\n match_uncommon_plural = lemma_term_list.copy()\\n match_uncommon_plural[-1] = match_uncommon_plural[-1] + \\\"s\\\"\\n\\n # additional check using heuristics on lemmatized version\\n match_heuristic = []\\n if lemma_term_list[0] not in HEURISTIC_TOKENS:\\n for token in lemma_term_list:\\n if token not in HEURISTIC_TOKENS:\\n match_heuristic += token.split(\\\"-\\\")\\n heuristic_length = len(match_heuristic)\\n else:\\n heuristic_term = lemma_term_list\\n heuristic_length = len(lemma_term_list)\\n \\n for ix in range(len(text) - term_length):\\n \\n heuristic_match = (lemmatized_text[ix:ix + heuristic_length] == match_heuristic)\\n plural_match = (lemmatized_text[ix:ix + term_length] == match_uncommon_plural)\\n lemma_match = (lemmatized_text[ix:ix + term_length] == lemma_term_list)\\n text_match = (tokenized_text[ix:ix + term_length] == text_term_list)\\n lower_match = ([t.lower() for t in tokenized_text[ix:ix + term_length]] ==\\n [t.lower() for t in text_term_list])\\n \\n # Only match on text if lemmatized version is a stop word (i.e. lower casing acronym)\\n if term_lemma in STOP_WORDS:\\n valid_match = text_match\\n else:\\n valid_match = heuristic_match or plural_match or text_match or lemma_match or lower_match\\n \\n if valid_match:\\n \\n if heuristic_match and not lemma_match:\\n match_length = heuristic_length\\n else:\\n match_length = term_length\\n \\n term_text = \\\" \\\".join([t.text for t in text[ix:ix + match_length]])\\n term_tag = \\\" \\\".join([t.tag_ for t in text[ix:ix + match_length]])\\n \\n # only tag term if not part of larger term\\n if tags[ix:ix + match_length] == [\\\"O\\\"] * match_length:\\n \\n # classify term type\\n term_type = determine_term_type(spacy_term)\\n \\n # collect term information\\n found_terms[term_lemma][\\\"text\\\"].append(term_text)\\n found_terms[term_lemma][\\\"indices\\\"].append((ix, ix + match_length))\\n found_terms[term_lemma][\\\"pos\\\"].append(term_tag)\\n found_terms[term_lemma][\\\"type\\\"].append(term_type)\\n \\n # update sentence tags\\n tags = tag_bioes(tags, ix, match_length)\\n \\n # annotate token representations with term type\\n text[ix]._.workaround = f\\\"<{term_type}>\\\" + text[ix]._.workaround\\n end_ix = ix + match_length - 1\\n if text[end_ix]._.workaround.endswith(\\\" \\\"):\\n text[end_ix]._.workaround = text[end_ix]._.workaround[:-1] + f\\\"</{term_type}> \\\"\\n else:\\n text[end_ix]._.workaround += f\\\"</{term_type}>\\\"\\n \\n # reconstruct fully annotated input text\\n annotated_text = \\\"\\\"\\n for token in text:\\n annotated_text += token._.workaround\\n \\n return {\\n \\\"tokenized_text\\\": tokenized_text, \\n \\\"tags\\\": tags, \\n \\\"annotated_text\\\": annotated_text,\\n \\\"found_terms\\\": dict(found_terms)\\n }\",\n \"def transform(self, entry):\\r\\n res = ''\\r\\n doc = self.nlp(entry, disable=['tagger', 'parser'])\\r\\n ents = doc.ents\\r\\n start_indices = {}\\r\\n end_indices = {}\\r\\n\\r\\n for ent in ents:\\r\\n start, end, label = ent.start, ent.end, ent.label_\\r\\n if label in ['NORP', 'GPE', 'LOC', 'PERSON', 'PRODUCT']:\\r\\n start_indices[start] = 'PRODUCT'\\r\\n end_indices[end] = 'PRODUCT'\\r\\n if label in ['DATE', 'QUANTITY', 'TIME', 'PERCENT', 'MONEY']:\\r\\n start_indices[start] = 'NUM'\\r\\n end_indices[end] = 'NUM'\\r\\n\\r\\n for idx, token in enumerate(doc):\\r\\n if idx in start_indices:\\r\\n res += start_indices[idx] + ' '\\r\\n\\r\\n # normalizing the numbers\\r\\n if token.like_num:\\r\\n try:\\r\\n val = float(token.text)\\r\\n if val == round(val):\\r\\n res += '%d ' % (int(val))\\r\\n else:\\r\\n res += '%.2f ' % (val)\\r\\n except:\\r\\n res += token.text + ' '\\r\\n elif len(token.text) >= 7 and \\\\\\r\\n any([ch.isdigit() for ch in token.text]):\\r\\n res += 'ID ' + token.text + ' '\\r\\n else:\\r\\n res += token.text + ' '\\r\\n return res.strip()\",\n \"def split_word_in_all_comps(self, term: str) -> List[str]:\\n all_stems = []\\n\\n words = term.split()\\n for word in words:\\n stems = self.decompound(word)\\n all_stems.extend(stems)\\n\\n for stem in stems:\\n more_stems = self.split_word_in_all_comps(stem)\\n all_stems.extend(more_stems)\\n\\n return all_stems\",\n \"def normalize_answer(s):\\n\\n def remove_articles(text):\\n regex = re.compile(r'\\\\b(a|an|the)\\\\b', re.UNICODE)\\n return re.sub(regex, ' ', text)\\n\\n def white_space_fix(text):\\n return ' '.join(text.split())\\n\\n def remove_punc(text):\\n exclude = set(string.punctuation)\\n return ''.join(ch for ch in text if ch not in exclude)\\n\\n def lower(text):\\n return text.lower()\\n\\n return white_space_fix(remove_articles(remove_punc(lower(s))))\",\n \"def correctDefaultNounTag(idx, tagged_term, tagged_terms, lexicon):\\n term, tag, norm = tagged_term\\n if tag == 'NND':\\n if term.endswith('s'):\\n tagged_term[1] = 'NNS'\\n tagged_term[2] = term[:-1]\\n else:\\n tagged_term[1] = 'NN'\",\n \"def generate_transitional_modifications(self, word: str = \\\"\\\") -> list: # noqa: C901\\n possible_modifications = []\\n\\n # Create a list of possible initial words\\n word_list = [word]\\n\\n # Replace Umlaute to handle things like \\\"H_ä_userschlucht\\\"\\n # If the first letter is an Umlaut, it is not going to be changed\\n if 'ä' in word and not word[0].lower() == 'ä':\\n tmp_word = word.replace(u'ä', 'a')\\n word_list.append(tmp_word)\\n\\n if 'ö' in word and not word[0].lower() == 'ö':\\n tmp_word = word.replace(u'ö', 'o')\\n word_list.append(tmp_word)\\n\\n if 'ü' in word and not word[0].lower() == 'ü':\\n tmp_word = word.replace(u'ü', 'u')\\n word_list.append(tmp_word)\\n\\n for word in word_list:\\n # Consider the unmodified word lowered and capitalized as possible modifications\\n possible_modifications.append(word.lower())\\n possible_modifications.append(word.capitalize())\\n\\n \\\"\\\"\\\"\\n M O D I F Y W O R D S\\n Noun Rules\\n \\\"\\\"\\\"\\n # If not last letter is 's'\\n # Remove s\\n # Remove s, add e\\n if word[-1:] == \\\"s\\\": #\\n # action = [\\\"-s\\\"]\\n # action2 = [\\\"-s\\\", \\\"+e\\\"]\\n possible_modifications.append(word[:-1].lower())\\n possible_modifications.append(word[:-1].lower() + \\\"e\\\")\\n\\n possible_modifications.append(word[:-1].capitalize())\\n possible_modifications.append(word[:-1].capitalize() + \\\"e\\\")\\n\\n # If not last letter is 'e'\\n # Add e\\n if not word[-1:] == \\\"e\\\": # Kirch|turm (Kirch) -> (Kirche)\\n # action = [\\\"+e\\\"]\\n possible_modifications.append(word.lower() + \\\"e\\\")\\n possible_modifications.append(word.capitalize() + \\\"e\\\")\\n\\n # If not last letter is 'n'\\n # Add n\\n if word[-1:] == \\\"n\\\": # Hasen|braten (Hasen) -> (Hase)\\n # action = [\\\"-n\\\"]\\n possible_modifications.append(word[:-1].lower())\\n possible_modifications.append(word[:-1].capitalize())\\n\\n # If last letter IS 'e'\\n # Remove e\\n if word[-1:] == \\\"e\\\": # Hunde|hütte (Hunde) -> (Hund)\\n # action = [\\\"-e\\\"]\\n possible_modifications.append(word[:-1].lower())\\n possible_modifications.append(word[:-1].capitalize())\\n\\n # If word ends on \\\"en\\\"\\n # Remove \\\"en\\\"\\n if word[-2:] == \\\"en\\\": # Taten|drang (Taten) -> (Tag)\\n # action = [\\\"-en\\\"]\\n possible_modifications.append(word[:-2].lower())\\n possible_modifications.append(word[:-2].capitalize())\\n\\n # If word ends on \\\"er\\\"\\n # Remove \\\"er\\\"\\n if word[-2:] == \\\"er\\\": # Bücher|Regal (Bücher/Bucher) -> (Büch/Buch)\\n # action = [\\\"-er\\\"]\\n possible_modifications.append(word[:-2].lower())\\n possible_modifications.append(word[:-2].capitalize())\\n\\n # If word ends on \\\"ns\\\"\\n # Remove \\\"ns\\\"\\n if word[-2:] == \\\"ns\\\": # Glaubens|frage (Glaubens) -> (Glaube)\\n # action = [\\\"-ns\\\"]\\n possible_modifications.append(word[:-2].lower())\\n possible_modifications.append(word[:-2].capitalize())\\n\\n # If word ends on \\\"ens\\\"\\n # Remove \\\"ens\\\"\\n if word[-3:] == \\\"ens\\\": # Herzens|güte (Herzens) -> (Herz)\\n # action = [\\\"-ens\\\"]\\n possible_modifications.append(word[:-3].lower())\\n possible_modifications.append(word[:-3].capitalize())\\n\\n # If ends on \\\"es\\\"\\n # Remove \\\"es\\\"\\n if word[-2:] == \\\"es\\\": # Kindes|wohl (Kindes) -> (Kind)\\n # action = [\\\"-es\\\"]\\n possible_modifications.append(word[:-2].lower())\\n possible_modifications.append(word[:-2].capitalize())\\n\\n \\\"\\\"\\\"\\n Verb Rules\\n \\\"\\\"\\\"\\n # If word does not end on \\\"en\\\" and not on \\\"e\\\"\\n # Add -en\\n if not word[-2:] == \\\"en\\\" and not word[-1:] == \\\"e\\\":\\n # action = [\\\"+en\\\"]\\n possible_modifications.append(word.lower() + \\\"en\\\")\\n possible_modifications.append(word.capitalize() + \\\"en\\\")\\n\\n # If word ends on \\\"en\\\" PR word ends on \\\"em\\\"\\n # Add -en, remove -e- in context of n, m)\\n # This is totally different to the NOUN rule above\\n if word[-2:] == \\\"en\\\" or word[-2:] == \\\"em\\\":\\n # action = [\\\"+n\\\", \\\"+en\\\"]\\n possible_modifications.append(word[:-2].lower() + word[-1:] + \\\"en\\\")\\n possible_modifications.append(word[:-2].capitalize() + word[-1:] + \\\"en\\\")\\n\\n # If word does not end on \\\"n\\\"\\n # Add -n\\n if not word[-1:] == \\\"n\\\":\\n # action = [\\\"+n\\\"]\\n possible_modifications.append(word.lower() + \\\"n\\\")\\n possible_modifications.append(word.capitalize() + \\\"n\\\")\\n\\n # modification is valid if:\\n # - not in stopwords\\n # - len > 2\\n # - not in forbidden modifier list\\n # - in lemma list\\n\\n possible_modifications = [w for w in possible_modifications if w.lower() not in self.stop_words\\n and len(w) > 2\\n and str(w) in self.lemma_data]\\n\\n return possible_modifications\",\n \"def preprocess_sub_units(self):\\n if self.unit == \\\"char\\\":\\n self.preprocess_char()\\n elif self.unit == \\\"char-ngram\\\":\\n self.preprocess_char_ngram()\\n elif self.unit == \\\"morpheme\\\":\\n self.preprocess_morpheme()\\n elif self.unit == \\\"oracle\\\":\\n self.preprocess_oracle()\\n else:\\n sys.exit(\\\"Unknown unit\\\")\",\n \"def simplify_pono(self, tensor: Tensor):\\n resolvers = self.resolvers\\n return tensor.map(\\n lambda term: _simpl_pono_term(term, resolvers.value)\\n )\",\n \"def _simpl_one_pono(\\n expr: Pow, resolvers, sums_dict, j_of, symb2idx, rel_vecs\\n):\\n\\n expr = _simpl_pono_jm(expr, resolvers, sums_dict, j_of)\\n if not isinstance(expr, Pow):\\n return expr\\n\\n exps = _parse_pono(expr)\\n\\n # Next, simplification based on the linear relations are performed.\\n coeffs = [0 for _ in symb2idx] # Coefficients for symbols with relations.\\n other = [] # Other addends.\\n\\n for i in exps:\\n coeff, symb = _parse_linear(i)\\n if symb is None or symb not in symb2idx:\\n other.append(i)\\n else:\\n coeffs[symb2idx[symb]] += coeff\\n continue\\n\\n projed_coeffs = _proj_out(rel_vecs, Matrix(coeffs))\\n addends = other\\n for i, j in zip(symb2idx.keys(), projed_coeffs):\\n if j != 0:\\n addends.append(i * j)\\n continue\\n\\n # Finally, canonicalize the coefficients again.\\n expr = _NEG_UNITY ** sum(addends)\\n if not isinstance(expr, Pow):\\n return expr\\n\\n expr = _simpl_pono_jm(\\n expr, resolvers, sums_dict, j_of\\n )\\n\\n return expr\",\n \"def qsimplify(e_orig, _n=0):\\n if _n > 15:\\n warnings.warn(\\\"Too high level or recursion, aborting\\\")\\n return e_orig\\n\\n e = normal_ordered_form(e_orig)\\n\\n if isinstance(e, Add):\\n return Add(*(qsimplify(arg, _n=_n+1) for arg in e.args))\\n\\n elif isinstance(e, Pow):\\n return Pow(*(qsimplify(arg, _n=_n+1) for arg in e.args))\\n\\n elif isinstance(e, exp):\\n return exp(*(qsimplify(arg, _n=_n+1) for arg in e.args))\\n\\n elif isinstance(e, Mul):\\n args1 = tuple(arg for arg in e.args if arg.is_commutative)\\n args2 = tuple(arg for arg in e.args if not arg.is_commutative)\\n #x = 1\\n #for y in args2:\\n # x = x * y\\n\\n x = 1\\n for y in reversed(args2):\\n x = y * x\\n\\n if isinstance(x, Mul):\\n args2 = x.args\\n x = 1\\n for y in args2:\\n x = x * y\\n\\n e_new = simplify(Mul(*args1)) * x\\n\\n if e_new == e:\\n return e\\n else:\\n return qsimplify(e_new.expand(), _n=_n+1)\\n\\n if e == e_orig:\\n return e\\n else:\\n return qsimplify(e, _n=_n+1).expand()\",\n \"def reindex_subcomponent_taxa(self):\\n ti_mutable = self.taxon_set._is_mutable\\n self.taxon_set._is_mutable = True\\n new_map = CharacterDataMap()\\n for taxon, seq in self.taxon_seq_map.items():\\n taxon = self.taxon_set.require_taxon(label=taxon.label)\\n new_map[taxon] = seq\\n self.taxon_set._is_mutable = ti_mutable\\n self.taxon_seq_map = new_map\",\n \"def subexpr_to_smtlib(expr, pre, suff='', fun_annotate_subexpr = None):\\n if fun_annotate_subexpr is not None and pre in PythonOperators.logic_ops:\\n return '(! (' + pre + ' ' + ExprTranslator.concatenate_args(expr, fun_annotate_subexpr) + suff + \\\\\\n ') :named ' + fun_annotate_subexpr() + ')'\\n else:\\n return '(' + pre + ' ' + ExprTranslator.concatenate_args(expr, fun_annotate_subexpr) + suff + ')'\",\n \"def renormalize(self,proposal,proposal_label,ref_label):\\n import copy\\n renormalized = copy.deepcopy(proposal)\\n all_scales = self.refl_table[ref_label+\\\"_shoebox_sum\\\"]/self.refl_table[proposal_label+\\\"_shoebox_sum\\\"]\\n for sidx in range(len(self.refl_table)): #loop through the shoeboxes\\n scale_factor = all_scales[sidx]\\n for ipanel, islow, ifast in self.per_shoebox_whitelist_iterator(sidx):\\n renormalized[ipanel,islow,ifast] *= scale_factor\\n return renormalized\",\n \"def corrected_ttr(n_terms, n_words):\\n if n_words == 0:\\n return 0\\n return n_terms / math.sqrt(2 * n_words)\",\n \"def __call__(self, *args, **kw):\\n return self.transform(Term.__call__(self, *args, **kw))\",\n \"def fold_term(self, term):\\n if isinstance(term, Var):\\n return self.var(term.name)\\n elif isinstance(term, Const):\\n return self.const(term.name)\\n elif isinstance(term, Dist):\\n return self.dist(term.name)\\n elif isinstance(term, Func):\\n return self.func(\\n term.funcname,\\n tuple( self.fold_term(x)\\n for x in term.args ))\\n elif isinstance(term, Eq):\\n return self.encode_eq(term)\\n elif isinstance(term, Disj):\\n return self.encode_disj(term)\\n elif isinstance(term, Conj):\\n return self.encode_conj(term)\\n raise RuntimeError('Invalid term {}'.format(term))\",\n \"def test_unstem():\\n\\n # cat > cats\\n t = Text('cat cat cats')\\n assert t.unstem('cat') == 'cat'\\n\\n # cats > cat\\n t = Text('cat cat cats cats cats')\\n assert t.unstem('cat') == 'cats'\",\n \"def _normalize(self, word):\\n return self.lemmatize(word.lower())\",\n \"def _step1a(self, word):\\n # this NLTK-only rule extends the original algorithm, so\\n # that 'flies'->'fli' but 'dies'->'die' etc\\n if self.mode == self.NLTK_EXTENSIONS:\\n if word.endswith(\\\"ies\\\") and len(word) == 4:\\n return self._replace_suffix(word, \\\"ies\\\", \\\"ie\\\")\\n\\n return self._apply_rule_list(\\n word,\\n [\\n (\\\"sses\\\", \\\"ss\\\", None), # SSES -> SS\\n (\\\"ies\\\", \\\"i\\\", None), # IES -> I\\n (\\\"ss\\\", \\\"ss\\\", None), # SS -> SS\\n (\\\"s\\\", \\\"\\\", None), # S ->\\n ],\\n )\",\n \"def __transform_term(self, term: ast.TermASTNode) -> ast.TermASTNode:\\n # TODO: expansion cycle detection\\n if isinstance(term, ast.FunctionApplicationASTNode) \\\\\\n and isinstance(term.get_declaration().get_declaring_ast_node(), ast.DefineFunCommandASTNode):\\n definition = term.get_declaration().get_declaring_ast_node()\\n result = self.__create_expansion(term, definition)\\n else:\\n result = term\\n\\n # Transform child nodes.\\n children = result.get_child_nodes()\\n for i, child_node in enumerate(children):\\n result.set_child_node(i, self.__transform_term(child_node))\\n\\n return result\",\n \"def transform_one_sentence(sentence):\\n words = list(map(str, nlp(sentence)))\\n return ' '.join(list(map(spell.correction, words)))\",\n \"def __sub__(self, other):\\n\\n other = formula(other, namespace=self.namespace)\\n terms = copy.copy(self.terms)\\n\\n for term in other.terms:\\n for i in range(len(terms)):\\n if terms[i].termname == term.termname:\\n terms.pop(i)\\n break \\n return formula(terms, namespace=self.namespace)\",\n \"def scale(self,n,d=1):\\r\\n\\t\\t\\r\\n\\t\\t# scale all terms\\r\\n\\t\\ts = [i.scale(n,d) for i in self]\\r\\n\\t\\t\\r\\n\\t\\treturn Li(s)\",\n \"def _update_term_relevance(self, term):\\n term_entry = self.sql_session.query(Term).get(term)\\n term_entry.relevance = self.term_relevance(term)\\n #self.sql_engine.execute(\\n # \\\"update terms set relevance=:relevance where term=:term\\\",\\n # term=term, relevance=self.term_relevance(term)\\n #)\",\n \"def simplify(self, formula):\\n return self.walk(formula)\",\n \"def simplify(cls, x: Term, bound: int = -1) -> Optional[Term]:\\n if not isinstance(x, FuncTerm):\\n raise ValueError(\\\"simplify function expects a FuncTerm.\\\")\\n return normal(x, cls.rules, bound)[0]\",\n \"def normal_ordered_ladder_term(term, coefficient, parity=-1):\\n # Iterate from left to right across operators and reorder to normal\\n # form. Swap terms operators into correct position by moving from\\n # left to right across ladder operators.\\n term = list(term)\\n\\n if parity == -1:\\n Op = FermionOperator\\n elif parity == 1:\\n Op = BosonOperator\\n\\n ordered_term = Op()\\n\\n for i in range(1, len(term)):\\n for j in range(i, 0, -1):\\n right_operator = term[j]\\n left_operator = term[j - 1]\\n\\n # Swap operators if raising on right and lowering on left.\\n if right_operator[1] and not left_operator[1]:\\n term[j - 1] = right_operator\\n term[j] = left_operator\\n coefficient *= parity\\n\\n # Replace a a^\\\\dagger with 1 + parity*a^\\\\dagger a\\n # if indices are the same.\\n if right_operator[0] == left_operator[0]:\\n new_term = term[:(j - 1)] + term[(j + 1):]\\n\\n # Recursively add the processed new term.\\n ordered_term += normal_ordered_ladder_term(\\n tuple(new_term), parity * coefficient, parity)\\n\\n # Handle case when operator type is the same.\\n elif right_operator[1] == left_operator[1]:\\n\\n # If same two Fermionic operators are repeated,\\n # evaluate to zero.\\n if parity == -1 and right_operator[0] == left_operator[0]:\\n return ordered_term\\n\\n # Swap if same ladder type but lower index on left.\\n elif right_operator[0] > left_operator[0]:\\n term[j - 1] = right_operator\\n term[j] = left_operator\\n coefficient *= parity\\n\\n # Add processed term and return.\\n ordered_term += Op(tuple(term), coefficient)\\n return ordered_term\",\n \"def factor_statements(kb):\\n # Unify literals in same rule\\n for rule in kb:\\n for index, literal1 in enumerate(rule):\\n rest = rule[index + 1:]\\n for literal2 in rest:\\n if literal1.negate == literal2.negate and literal1.predicate == literal2.predicate:\\n unification = unify_literal(literal1.arguments, literal2.arguments)\\n if unification is False:\\n continue\\n else:\\n for literal in rule:\\n substitute(literal, unification)\\n # Remove same literals\\n new_kb = []\\n for rule in kb:\\n new_rule = []\\n for literal in rule:\\n if literal not in new_rule:\\n new_rule.append(literal)\\n new_kb.append(new_rule)\\n return new_kb\",\n \"def transform_article(article):\\n tokens = clean_article(article)\\n lemmatizer = WordNetLemmatizer()\\n lemmatized = [lemmatizer.lemmatize(token) for token in tokens]\\n transformed_article = \\\" \\\".join(lemmatized)\\n return transformed_article\",\n \"def substitute(self,s,x):\\r\\n\\t\\t\\r\\n\\t\\t# turn substitution into top line\\r\\n\\t\\ttry:\\r\\n\\t\\t\\tt = Li(s)\\r\\n\\t\\t\\tb = Li(1)\\r\\n\\t\\t\\t\\r\\n\\t\\t# unless it is a list of lines\\r\\n\\t\\texcept:\\r\\n\\t\\t\\tt = Li(s[0])\\r\\n\\t\\t\\tb = Li(s[1])\\r\\n\\t\\t\\r\\n\\t\\t# split variable from power\\r\\n\\t\\th = Te._chop(x)\\r\\n\\t\\tx = h[0]\\r\\n\\t\\t\\r\\n\\t\\t# assume power of 1 for substituted variable, but revise if found in string\\r\\n\\t\\tp = 1\\r\\n\\t\\ttry:\\r\\n\\t\\t\\tp = int(h[1])\\r\\n\\t\\texcept:\\r\\n\\t\\t\\tpass\\r\\n\\t\\t\\r\\n\\t\\t# exponents in each term\\r\\n\\t\\te = [i.look(x) for i in self]\\r\\n\\t\\t\\r\\n\\t\\t# adjust for power of substituted variable\\r\\n\\t\\te = [i // p for i in e]\\r\\n\\t\\t\\r\\n\\t\\t# max, min powers of substitution\\r\\n\\t\\ttry:\\r\\n\\t\\t\\ta = max(e)\\r\\n\\t\\t\\tm = min(e)\\r\\n\\t\\texcept:\\r\\n\\t\\t\\ta = 0\\r\\n\\t\\t\\tm = 0\\r\\n\\t\\t\\r\\n\\t\\t# truncate max and min powers \\r\\n\\t\\tif a < 0:\\r\\n\\t\\t\\ta = 0\\r\\n\\t\\tif m > 0:\\r\\n\\t\\t\\tm = 0\\r\\n\\t\\t\\t\\r\\n\\t\\t# dictionaries of calculated terms for top and bottom\\r\\n\\t\\tf = {}\\r\\n\\t\\tg = {}\\r\\n\\t\\t\\t\\r\\n\\t\\t# expand top and bottom to truncated max and min\\r\\n\\t\\tq,f = Li._expand(t,-m,f)\\r\\n\\t\\tr,g = Li._expand(b,a,g)\\r\\n\\t\\tq = Li(q,c=False)\\r\\n\\t\\tr = Li(r,c=False)\\r\\n\\t\\t\\r\\n\\t\\t# store results in dictionaries\\r\\n\\t\\ty = {-m: q}\\r\\n\\t\\tz = {a: r}\\r\\n\\t\\t\\r\\n\\t\\t# make denominator\\r\\n\\t\\td = q.multiply(r)\\r\\n\\t\\t\\r\\n\\t\\t# convert each term\\r\\n\\t\\tl = Li([])\\r\\n\\t\\tfor n,i in enumerate(self):\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t# exponent of substitution\\r\\n\\t\\t\\tw = e[n]\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t# divide out variable\\r\\n\\t\\t\\tv = Te({x: -w * p})\\r\\n\\t\\t\\ti = i.multiply(v)\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t# retrieve top expansion\\r\\n\\t\\t\\tif (w - m) in y:\\r\\n\\t\\t\\t\\tu = y[w - m]\\r\\n\\t\\t\\t\\t\\r\\n\\t\\t\\t# or calculate\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tu,f = Li._expand(t,w - m,f)\\r\\n\\t\\t\\t\\tu = Li(u,c=False)\\r\\n\\t\\t\\t\\ty[w - m] = u\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t# retrieve bottom expansion\\r\\n\\t\\t\\tif (a - w) in z:\\r\\n\\t\\t\\t\\tc = z[a - w]\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t# or calculate\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tc,g = Li._expand(b,a - w,g)\\r\\n\\t\\t\\t\\tc = Li(c,c=False)\\r\\n\\t\\t\\t\\tz[a - w] = c\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t# multiply and add\\r\\n\\t\\t\\tu = u.multiply(c)\\r\\n\\t\\t\\tu = u.multiply(i)\\r\\n\\t\\t\\tl = l.add(u)\\r\\n\\t\\t\\r\\n\\t\\treturn [l,d]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.58145285","0.57417417","0.5672962","0.5574244","0.5386782","0.52982134","0.5281623","0.5270715","0.5269361","0.524937","0.5215512","0.519514","0.5169542","0.51584274","0.5112584","0.5109358","0.51056045","0.5094979","0.5041347","0.5013541","0.50019133","0.49973586","0.49574056","0.49479467","0.4937592","0.49345887","0.49330518","0.4930314","0.4921315","0.4921315","0.49180073","0.4915843","0.48949382","0.48665476","0.48646542","0.48642078","0.48634565","0.4863448","0.4858877","0.4858617","0.4857272","0.48538032","0.48443404","0.4834803","0.4824768","0.48244292","0.480248","0.47987604","0.47929606","0.4791329","0.47825474","0.47825474","0.47808287","0.47616896","0.47574198","0.47556448","0.4753372","0.47445488","0.47398734","0.4739335","0.47360656","0.47348544","0.47343248","0.47273394","0.47249863","0.47249863","0.47224024","0.47175777","0.4701512","0.46992168","0.46970934","0.4696247","0.468507","0.46846178","0.46795854","0.46785265","0.46768913","0.46712488","0.46680123","0.46644768","0.46639603","0.46608418","0.46534142","0.46497878","0.4643607","0.4640411","0.46341273","0.4632906","0.46282554","0.46105695","0.46012896","0.4594785","0.45868838","0.45818552","0.45788795","0.4577662","0.4570099","0.45655406","0.45582312","0.45578316"],"string":"[\n \"0.58145285\",\n \"0.57417417\",\n \"0.5672962\",\n \"0.5574244\",\n \"0.5386782\",\n \"0.52982134\",\n \"0.5281623\",\n \"0.5270715\",\n \"0.5269361\",\n \"0.524937\",\n \"0.5215512\",\n \"0.519514\",\n \"0.5169542\",\n \"0.51584274\",\n \"0.5112584\",\n \"0.5109358\",\n \"0.51056045\",\n \"0.5094979\",\n \"0.5041347\",\n \"0.5013541\",\n \"0.50019133\",\n \"0.49973586\",\n \"0.49574056\",\n \"0.49479467\",\n \"0.4937592\",\n \"0.49345887\",\n \"0.49330518\",\n \"0.4930314\",\n \"0.4921315\",\n \"0.4921315\",\n \"0.49180073\",\n \"0.4915843\",\n \"0.48949382\",\n \"0.48665476\",\n \"0.48646542\",\n \"0.48642078\",\n \"0.48634565\",\n \"0.4863448\",\n \"0.4858877\",\n \"0.4858617\",\n \"0.4857272\",\n \"0.48538032\",\n \"0.48443404\",\n \"0.4834803\",\n \"0.4824768\",\n \"0.48244292\",\n \"0.480248\",\n \"0.47987604\",\n \"0.47929606\",\n \"0.4791329\",\n \"0.47825474\",\n \"0.47825474\",\n \"0.47808287\",\n \"0.47616896\",\n \"0.47574198\",\n \"0.47556448\",\n \"0.4753372\",\n \"0.47445488\",\n \"0.47398734\",\n \"0.4739335\",\n \"0.47360656\",\n \"0.47348544\",\n \"0.47343248\",\n \"0.47273394\",\n \"0.47249863\",\n \"0.47249863\",\n \"0.47224024\",\n \"0.47175777\",\n \"0.4701512\",\n \"0.46992168\",\n \"0.46970934\",\n \"0.4696247\",\n \"0.468507\",\n \"0.46846178\",\n \"0.46795854\",\n \"0.46785265\",\n \"0.46768913\",\n \"0.46712488\",\n \"0.46680123\",\n \"0.46644768\",\n \"0.46639603\",\n \"0.46608418\",\n \"0.46534142\",\n \"0.46497878\",\n \"0.4643607\",\n \"0.4640411\",\n \"0.46341273\",\n \"0.4632906\",\n \"0.46282554\",\n \"0.46105695\",\n \"0.46012896\",\n \"0.4594785\",\n \"0.45868838\",\n \"0.45818552\",\n \"0.45788795\",\n \"0.4577662\",\n \"0.4570099\",\n \"0.45655406\",\n \"0.45582312\",\n \"0.45578316\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6677275"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":79096,"cells":{"query":{"kind":"string","value":"Get flatParameters note that getParameters and parameters is not equal in this case getParameters do not get parameters of output module"},"document":{"kind":"string","value":"def getParameters(self):\n params = []\n for m in [self.ix, self.ih, self.fx, self.fh, self.ox, self.oh, self.ux, self.uh]:\n # we do not get param of output module\n l = list(m.parameters())\n params.extend(l)\n\n one_dim = [p.view(p.numel()) for p in params]\n params = F.torch.cat(one_dim)\n return params"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def flatten_parameters(self):","def get_params(self, deep=...):\n ...","def get_parameters(self):\n return(_deepcopy(self.parameters))","def get_params(self, deep=True):\n return super().get_params(deep=deep)","def get_params(self):","def flatten_parameters(self):\n self.encoder_module.rnn.flatten_parameters()\n self.decoder_module.rnn.flatten_parameters()","def _get_orig_params(\n self,\n module: nn.Module,\n ignored_params: Set[nn.Parameter],\n ) -> Iterator[nn.Parameter]:\n param_gen = module.parameters()\n try:\n while True:\n param = next(param_gen)\n if param not in ignored_params and not _is_fsdp_flattened(param):\n yield param\n except StopIteration:\n pass","def get_params(self, deep=False):\n return core.get_params(self)","def get_params(self, deep=False):\n return core.get_params(self)","def get_parameters(self):\n return self.parameters","def get_parameters(self):\n return self.parameters","def get_parameters(self):\n return self.parameters","def get_parameters(self):\n return self.parameters","def get_parameters(self):\n return self.parameters","def _get_parameters(self) -> list:\n return self.parameters","def _get_parameters(self):\n return None","def _flatten_parameters(self):\n [m.flatten_parameters() for m in self._to_flatten]","def parameters(self):\n return self._params","def getParams(self):\n return self.__params","def __parameters__(self) -> tuple[TypeVar, ...]:\n return super().__getattribute__(\"_parameters\")","def get_params(self):\n pass","def _get_params(self):\r\n return self.k._get_params()","def get_params(self):\n return deepcopy(np.hstack([to_numpy(v).flatten() for v in\n self.parameters()]))","def get_params(self, deep=False):\n return {\"alpha\": self.alpha, \"beta\": self.beta, \"gamma\": self.gamma, \"W\": self.W, \"bias\": self.bias, \"add_bias\": self.add_bias, \"opts\": self.opts}","def get_params(self, _deep: bool = True) -> dict:\n return self.params","def parameters(self):\n #print \"in instrument.parameter()\"\n return self._params","def getParameters():\n paramWindDirection,paramWindSpeed,paramWaterHeight,paramRainFall = syncParameters.readParameters(\"./parameters.json\")\n print(\"WindDir: \"+str(paramWindDirection)+\" WindSpd: \"+str(paramWindSpeed)+\" WaterHeight: \"\n +str(paramWaterHeight)+\" RainFall: \"+str(paramRainFall))\n return paramWindDirection,paramWindSpeed,paramWaterHeight,paramRainFall","def parameters(self):\n for parameters in self:\n for parameter in parameters:\n yield parameter","def get_params(self):\n raise NotImplementedError","def params(self) -> Tuple[Parameter, ...]:\n raise NotImplementedError()","def parameters(self):\n return {\"P\": self.P,\n \"T\": self.T}","def get_parameters(self):\n self.unimpl_base_class()","def flatten_parameters(self):\n any_param = next(self.parameters()).data\n if not any_param.is_cuda or not torch.backends.cudnn.is_acceptable(any_param):\n return\n\n # If any parameters alias, we fall back to the slower, copying code path. This is\n # a sufficient check, because overlapping parameter buffers that don't completely\n # alias would break the assumptions of the uniqueness check in\n # Module.named_parameters().\n all_weights = self._flat_weights\n unique_data_ptrs = set(p.data_ptr() for p in all_weights)\n if len(unique_data_ptrs) != len(all_weights):\n return\n\n with torch.cuda.device_of(any_param):\n import torch.backends.cudnn.rnn as rnn\n\n # NB: This is a temporary hack while we still don't have Tensor\n # bindings for ATen functions\n with torch.no_grad():\n # NB: this is an INPLACE function on all_weights, that's why the\n # no_grad() is necessary.\n torch._cudnn_rnn_flatten_weight(\n all_weights, (4 if self.bias else 2),\n self.input_size, rnn.get_cudnn_mode(self.mode), self.hidden_size, self.num_layers,\n self.batch_first, bool(self.bidirectional))","def flatten_parameters(self):\n any_param = next(self.parameters()).data\n if not any_param.is_cuda or not torch.backends.cudnn.is_acceptable(any_param):\n return\n\n # If any parameters alias, we fall back to the slower, copying code path. This is\n # a sufficient check, because overlapping parameter buffers that don't completely\n # alias would break the assumptions of the uniqueness check in\n # Module.named_parameters().\n all_weights = self._flat_weights\n unique_data_ptrs = set(p.data_ptr() for p in all_weights)\n if len(unique_data_ptrs) != len(all_weights):\n return\n\n with torch.cuda.device_of(any_param):\n import torch.backends.cudnn.rnn as rnn\n\n # NB: This is a temporary hack while we still don't have Tensor\n # bindings for ATen functions\n with torch.no_grad():\n # NB: this is an INPLACE function on all_weights, that's why the\n # no_grad() is necessary.\n torch._cudnn_rnn_flatten_weight(\n all_weights, (4 if self.bias else 2),\n self.input_size, rnn.get_cudnn_mode(self.mode), self.hidden_size, self.num_layers,\n self.batch_first, bool(self.bidirectional))","def get_params(self, deep: bool = True) -> Dict[str, Any]:\n return _get_params(self, deep)","def get_params(self):\n return []","def get_params(self):\n return self.w, self.b","def _get_param_to_unflat_param_names(\n model: torch.nn.Module,\n dedup_shared_params: bool = True,\n) -> Dict[torch.nn.Parameter, List[str]]:\n def module_fn(module, prefix, param_to_unflat_param_names):\n # For FSDP modules, only add the entry when considering the contained\n # `FlattenParamsWrapper` to avoid duplication\n if not isinstance(module, FullyShardedDataParallel):\n for param_name, param in module.named_parameters(recurse=False):\n module_prefixed_param_names = (\n param._prefixed_param_names if type(param) is FlatParameter\n else [param_name]\n ) # prefixed from `module`\n fully_prefixed_param_names = [\n clean_tensor_name(prefix + name)\n for name in module_prefixed_param_names\n ] # fully prefixed from the top level including `prefix`\n # If this parameter has already been visited, then it is a\n # shared parameter; then, only take the first parameter name\n is_shared_param = param in param_to_unflat_param_names\n if not is_shared_param:\n param_to_unflat_param_names[param] = fully_prefixed_param_names\n elif not dedup_shared_params:\n param_to_unflat_param_names[param].extend(fully_prefixed_param_names)\n\n def return_fn(param_to_unflat_param_names):\n return param_to_unflat_param_names\n\n param_to_unflat_param_names: Dict[torch.nn.Parameter, List[str]] = {}\n return _apply_to_modules(\n model, module_fn, return_fn, param_to_unflat_param_names,\n )","def get_params(self):\n return self.params","def get_params(self):\n return self.params","def get_params(self):\n return self.params","def getParameters(self):\n\t\td = AdaptiveBatAlgorithm.getParameters(self)\n\t\td.update({\n\t\t\t'A_l': self.A_l,\n\t\t\t'A_u': self.A_u,\n\t\t\t'r_l': self.r_l,\n\t\t\t'r_u': self.r_u,\n\t\t\t'tao_1': self.tao_1,\n\t\t\t'tao_2': self.tao_2\n\t\t})\n\t\treturn d","def parameters(self):","def parameters(self):\n return {\n 'base':self.base.parameters(),\n 'material':[m.parameters() for m in self.material],\n 'fraction':self.fraction,\n }","def get_params(self):\n\n return None","def get_params(self):\n\n return None","def get_params(self):\n\n return None","def get_params (self):\n return self.params","def get_params (self):\n return self.params","def classifyParameters(self):\n\n arguments = []\n options = []\n outputs = []\n for parameter in self.parameters():\n if parameter.channel == 'output' and not (\n parameter.isExternalType() or parameter.typ == 'file'):\n outputs.append(parameter)\n elif parameter.index is not None:\n arguments.append(parameter)\n if parameter.flag is not None or parameter.longflag is not None:\n logger.warning(\"Parameter %s has both index=%d and flag set.\" % (\n parameter.identifier(), parameter.index))\n else:\n options.append(parameter)\n arguments.sort(key = lambda parameter: parameter.index)\n return (arguments, options, outputs)","def get_parameters_form(self):\n return self.parameters","def getParams(self):\n return self.W, self.b","def output_parameters(self):\n output_params = get_data_node(\n 'parameter',\n dict={\n 'stress': self.vasprun_obj.ionic_steps[-1]['stress'],\n 'efermi': self.vasprun_obj.efermi,\n 'energy': self.vasprun_obj.final_energy\n })\n return output_params","def get_parameters(self):\n return self.context.params","def _get_params(self):\r\n return np.hstack((self.k1._get_params(), self.k2._get_params()))","def _get_params(self):\r\n return np.hstack((self.k1._get_params(), self.k2._get_params()))","def parameters(self):\n return []","def _get_parameters(self):\n return (self.SYMBOL, self.parameterArray())","def __returnInitialParametersLocal__(self):\n return self.dmdParams","def parameters(self):\n return NeuralNetwork.flatten([module.parameters() for module in self.modules])","def get_params_snapshot(self):\n ...","def get_params(self, deep=True):\n params = super().get_params()\n\n params['a'] = self._a\n params['eta'] = self._eta\n\n return params","def getParameters(self):\n\n current_params = {'taux': self.taux, 'mu': self.mu, 'G': self.G, 'alpha_0': self.alpha_0,\n 'delta': self.delta, 'p': self.p, 'I0': self.I0, 'kparam': self.kparam}\n\n return (current_params)","def getParameters(self): #$NON-NLS-1$\r","def parameters(self):\n return self.pars","def params(self):\n return tuple(self._params)","def get_parameters(self):\n # Get the parameters from the parent class\n params = super(NREvalSplit, self).get_parameters()\n\n # Add the LP specific parameters\n params.update({\"samp_frac\": self._samp_frac})\n return params","def get_params(self, deep=True):\n res = copy.deepcopy(self.sk_params)\n res.update({\n 'lossfun': self.lossfun,\n 'accfun': self.accfun,\n 'device': self.device,\n })\n if hasattr(self, 'predictor'):\n res.update({'predictor': self.predictor})\n else:\n res.update({'predictor': self.predictor_constructor})\n return res","def get_params(self):\n return {}","def parameters(self) -> PyTree:\n return self._parameters","def getOutputParams(self):\n out = {}\n out[\"g_C\"] = self.ureg.Quantity(self.g_C, self.gBase).to(self.gOutput)\n out[\"gamma_C\"] = self.ureg.Quantity(self.gamma_C,\n self.gammaBase).to(self.gammaOutput)\n out[\"m\"] = self.ureg.Quantity(self.m, self.mBase).to(self.mOutput)\n out[\"charL\"] = self.ureg.Quantity(self.charL,\n self.charLBase).to(self.charLOutput)\n out[\"charT\"] = self.ureg.Quantity(self.charT,\n self.charTBase).to(self.charTOutput)\n out[\"g_R\"] = self.ureg.Quantity(self.g_R, self.gBase).to(self.gOutput)\n out[\"R\"] = self.ureg.Quantity(self.R, self.rBase).to(self.rOutput)\n out[\"gamma_R\"] = self.ureg.Quantity(self.gamma_R,\n self.gammaBase).to(self.gammaOutput)\n if self.singleComp:\n out[\"gamma_nl\"] = self.ureg.Quantity(self.gamma_nl,\n self.gammaNlBase).\\\n to(self.gammaNlOutput)\n return out","def parameters(self) -> Dict[str, Any]:\n return self.data[\"args\"].get(\"parameters\", {})","def __extract_parameters(self, name):\r\n parameters = getattr(self, '_' + name + '_parameters')\r\n result = Parameters(parameters)\r\n for key in result.keys():\r\n result[key] = self.Parameters[key]\r\n return result","def get_params(self):\n return list(self.params.values())","def parameters(self):\n return self._params","def get_params(self):\n return {\n \"nspecies\": self.nspecies,\n \"lmax\": self.lmax,\n \"nmax\": self.nmax,\n \"rcut\": self.rcut,\n \"sigma\": self.sigma,\n \"trans_width\": self.trans_width\n }","def _params(self, obj):\n if isinstance(obj, BaseParameter):\n return [obj]\n elif isinstance(obj, BaseModule):\n return obj.parameters\n elif isinstance(obj, list):\n return self._list_params(obj)\n elif isinstance(obj, dict):\n return self._dict_params(obj)\n else:\n return []","def get_params(self, deep=True):\n return {p: getattr(self, p) for p in self.params}","def get_params(self) -> torch.Tensor:\n params = []\n for pp in list(self.net.parameters()):\n params.append(pp.view(-1))\n return torch.cat(params)","def get_params(self) -> np.array:\n pass","def _get_path_parameters(self) -> Generator[Tuple[str, Type], None, None]:","def get_params(self):\n outputs = ['sample',\n 'ratio_params',\n 'despike_params',\n 'autorange_params',\n 'bkgcorrect_params']\n\n out = {}\n for o in outputs:\n out[o] = getattr(self, o)\n\n out['filter_params'] = self.filt.params\n out['filter_sequence'] = self.filt.sequence\n out['filter_used'] = self.filt.make_keydict()\n\n return out","def get_parameters(self, separate_):\n if separate_:\n return self.F, self.J, self.prox\n else :\n return self.Fone, self.Jone, self.prox","def parameters(self):\n return {\"W\": self.W,\n \"T\": self.T,\n \"P\": self.P}","def parameters(self):\n return self._parameters","def parameters(self):\n return self._parameters","def parameters(self):\n return self._parameters","def parameters(self):\n return self._parameters","def parameters(self):\n return self._parameters","def parameters(self):\n return self._parameters","def parameters(self):\n return self._parameters","def parameters(self):\n return self._parameters","def parameters(self):\n return [p for _, a in vars(self).items() for p in self._params(a)]","def get_params(self):\n params = {}\n for step in self.steps:\n params[step[0]] = step[1].get_params()\n return params","def params(self):\n\t\treturn self.params_","def get_params(self, **params): # pylint: disable=unused-argument\n res = copy.deepcopy(self.sk_params)\n res.update({'build_fn': self.build_fn})\n return res","def get(self):\n return self._params","def parameters(self):\n pass","def generative_parameters(self):\n params = nn.ParameterList()\n if 'parameters' in dir(self.generative_model):\n params.extend(list(self.generative_model.parameters()))\n params.extend(list(self.latent.generative_parameters()))\n return params"],"string":"[\n \"def flatten_parameters(self):\",\n \"def get_params(self, deep=...):\\n ...\",\n \"def get_parameters(self):\\n return(_deepcopy(self.parameters))\",\n \"def get_params(self, deep=True):\\n return super().get_params(deep=deep)\",\n \"def get_params(self):\",\n \"def flatten_parameters(self):\\n self.encoder_module.rnn.flatten_parameters()\\n self.decoder_module.rnn.flatten_parameters()\",\n \"def _get_orig_params(\\n self,\\n module: nn.Module,\\n ignored_params: Set[nn.Parameter],\\n ) -> Iterator[nn.Parameter]:\\n param_gen = module.parameters()\\n try:\\n while True:\\n param = next(param_gen)\\n if param not in ignored_params and not _is_fsdp_flattened(param):\\n yield param\\n except StopIteration:\\n pass\",\n \"def get_params(self, deep=False):\\n return core.get_params(self)\",\n \"def get_params(self, deep=False):\\n return core.get_params(self)\",\n \"def get_parameters(self):\\n return self.parameters\",\n \"def get_parameters(self):\\n return self.parameters\",\n \"def get_parameters(self):\\n return self.parameters\",\n \"def get_parameters(self):\\n return self.parameters\",\n \"def get_parameters(self):\\n return self.parameters\",\n \"def _get_parameters(self) -> list:\\n return self.parameters\",\n \"def _get_parameters(self):\\n return None\",\n \"def _flatten_parameters(self):\\n [m.flatten_parameters() for m in self._to_flatten]\",\n \"def parameters(self):\\n return self._params\",\n \"def getParams(self):\\n return self.__params\",\n \"def __parameters__(self) -> tuple[TypeVar, ...]:\\n return super().__getattribute__(\\\"_parameters\\\")\",\n \"def get_params(self):\\n pass\",\n \"def _get_params(self):\\r\\n return self.k._get_params()\",\n \"def get_params(self):\\n return deepcopy(np.hstack([to_numpy(v).flatten() for v in\\n self.parameters()]))\",\n \"def get_params(self, deep=False):\\n return {\\\"alpha\\\": self.alpha, \\\"beta\\\": self.beta, \\\"gamma\\\": self.gamma, \\\"W\\\": self.W, \\\"bias\\\": self.bias, \\\"add_bias\\\": self.add_bias, \\\"opts\\\": self.opts}\",\n \"def get_params(self, _deep: bool = True) -> dict:\\n return self.params\",\n \"def parameters(self):\\n #print \\\"in instrument.parameter()\\\"\\n return self._params\",\n \"def getParameters():\\n paramWindDirection,paramWindSpeed,paramWaterHeight,paramRainFall = syncParameters.readParameters(\\\"./parameters.json\\\")\\n print(\\\"WindDir: \\\"+str(paramWindDirection)+\\\" WindSpd: \\\"+str(paramWindSpeed)+\\\" WaterHeight: \\\"\\n +str(paramWaterHeight)+\\\" RainFall: \\\"+str(paramRainFall))\\n return paramWindDirection,paramWindSpeed,paramWaterHeight,paramRainFall\",\n \"def parameters(self):\\n for parameters in self:\\n for parameter in parameters:\\n yield parameter\",\n \"def get_params(self):\\n raise NotImplementedError\",\n \"def params(self) -> Tuple[Parameter, ...]:\\n raise NotImplementedError()\",\n \"def parameters(self):\\n return {\\\"P\\\": self.P,\\n \\\"T\\\": self.T}\",\n \"def get_parameters(self):\\n self.unimpl_base_class()\",\n \"def flatten_parameters(self):\\n any_param = next(self.parameters()).data\\n if not any_param.is_cuda or not torch.backends.cudnn.is_acceptable(any_param):\\n return\\n\\n # If any parameters alias, we fall back to the slower, copying code path. This is\\n # a sufficient check, because overlapping parameter buffers that don't completely\\n # alias would break the assumptions of the uniqueness check in\\n # Module.named_parameters().\\n all_weights = self._flat_weights\\n unique_data_ptrs = set(p.data_ptr() for p in all_weights)\\n if len(unique_data_ptrs) != len(all_weights):\\n return\\n\\n with torch.cuda.device_of(any_param):\\n import torch.backends.cudnn.rnn as rnn\\n\\n # NB: This is a temporary hack while we still don't have Tensor\\n # bindings for ATen functions\\n with torch.no_grad():\\n # NB: this is an INPLACE function on all_weights, that's why the\\n # no_grad() is necessary.\\n torch._cudnn_rnn_flatten_weight(\\n all_weights, (4 if self.bias else 2),\\n self.input_size, rnn.get_cudnn_mode(self.mode), self.hidden_size, self.num_layers,\\n self.batch_first, bool(self.bidirectional))\",\n \"def flatten_parameters(self):\\n any_param = next(self.parameters()).data\\n if not any_param.is_cuda or not torch.backends.cudnn.is_acceptable(any_param):\\n return\\n\\n # If any parameters alias, we fall back to the slower, copying code path. This is\\n # a sufficient check, because overlapping parameter buffers that don't completely\\n # alias would break the assumptions of the uniqueness check in\\n # Module.named_parameters().\\n all_weights = self._flat_weights\\n unique_data_ptrs = set(p.data_ptr() for p in all_weights)\\n if len(unique_data_ptrs) != len(all_weights):\\n return\\n\\n with torch.cuda.device_of(any_param):\\n import torch.backends.cudnn.rnn as rnn\\n\\n # NB: This is a temporary hack while we still don't have Tensor\\n # bindings for ATen functions\\n with torch.no_grad():\\n # NB: this is an INPLACE function on all_weights, that's why the\\n # no_grad() is necessary.\\n torch._cudnn_rnn_flatten_weight(\\n all_weights, (4 if self.bias else 2),\\n self.input_size, rnn.get_cudnn_mode(self.mode), self.hidden_size, self.num_layers,\\n self.batch_first, bool(self.bidirectional))\",\n \"def get_params(self, deep: bool = True) -> Dict[str, Any]:\\n return _get_params(self, deep)\",\n \"def get_params(self):\\n return []\",\n \"def get_params(self):\\n return self.w, self.b\",\n \"def _get_param_to_unflat_param_names(\\n model: torch.nn.Module,\\n dedup_shared_params: bool = True,\\n) -> Dict[torch.nn.Parameter, List[str]]:\\n def module_fn(module, prefix, param_to_unflat_param_names):\\n # For FSDP modules, only add the entry when considering the contained\\n # `FlattenParamsWrapper` to avoid duplication\\n if not isinstance(module, FullyShardedDataParallel):\\n for param_name, param in module.named_parameters(recurse=False):\\n module_prefixed_param_names = (\\n param._prefixed_param_names if type(param) is FlatParameter\\n else [param_name]\\n ) # prefixed from `module`\\n fully_prefixed_param_names = [\\n clean_tensor_name(prefix + name)\\n for name in module_prefixed_param_names\\n ] # fully prefixed from the top level including `prefix`\\n # If this parameter has already been visited, then it is a\\n # shared parameter; then, only take the first parameter name\\n is_shared_param = param in param_to_unflat_param_names\\n if not is_shared_param:\\n param_to_unflat_param_names[param] = fully_prefixed_param_names\\n elif not dedup_shared_params:\\n param_to_unflat_param_names[param].extend(fully_prefixed_param_names)\\n\\n def return_fn(param_to_unflat_param_names):\\n return param_to_unflat_param_names\\n\\n param_to_unflat_param_names: Dict[torch.nn.Parameter, List[str]] = {}\\n return _apply_to_modules(\\n model, module_fn, return_fn, param_to_unflat_param_names,\\n )\",\n \"def get_params(self):\\n return self.params\",\n \"def get_params(self):\\n return self.params\",\n \"def get_params(self):\\n return self.params\",\n \"def getParameters(self):\\n\\t\\td = AdaptiveBatAlgorithm.getParameters(self)\\n\\t\\td.update({\\n\\t\\t\\t'A_l': self.A_l,\\n\\t\\t\\t'A_u': self.A_u,\\n\\t\\t\\t'r_l': self.r_l,\\n\\t\\t\\t'r_u': self.r_u,\\n\\t\\t\\t'tao_1': self.tao_1,\\n\\t\\t\\t'tao_2': self.tao_2\\n\\t\\t})\\n\\t\\treturn d\",\n \"def parameters(self):\",\n \"def parameters(self):\\n return {\\n 'base':self.base.parameters(),\\n 'material':[m.parameters() for m in self.material],\\n 'fraction':self.fraction,\\n }\",\n \"def get_params(self):\\n\\n return None\",\n \"def get_params(self):\\n\\n return None\",\n \"def get_params(self):\\n\\n return None\",\n \"def get_params (self):\\n return self.params\",\n \"def get_params (self):\\n return self.params\",\n \"def classifyParameters(self):\\n\\n arguments = []\\n options = []\\n outputs = []\\n for parameter in self.parameters():\\n if parameter.channel == 'output' and not (\\n parameter.isExternalType() or parameter.typ == 'file'):\\n outputs.append(parameter)\\n elif parameter.index is not None:\\n arguments.append(parameter)\\n if parameter.flag is not None or parameter.longflag is not None:\\n logger.warning(\\\"Parameter %s has both index=%d and flag set.\\\" % (\\n parameter.identifier(), parameter.index))\\n else:\\n options.append(parameter)\\n arguments.sort(key = lambda parameter: parameter.index)\\n return (arguments, options, outputs)\",\n \"def get_parameters_form(self):\\n return self.parameters\",\n \"def getParams(self):\\n return self.W, self.b\",\n \"def output_parameters(self):\\n output_params = get_data_node(\\n 'parameter',\\n dict={\\n 'stress': self.vasprun_obj.ionic_steps[-1]['stress'],\\n 'efermi': self.vasprun_obj.efermi,\\n 'energy': self.vasprun_obj.final_energy\\n })\\n return output_params\",\n \"def get_parameters(self):\\n return self.context.params\",\n \"def _get_params(self):\\r\\n return np.hstack((self.k1._get_params(), self.k2._get_params()))\",\n \"def _get_params(self):\\r\\n return np.hstack((self.k1._get_params(), self.k2._get_params()))\",\n \"def parameters(self):\\n return []\",\n \"def _get_parameters(self):\\n return (self.SYMBOL, self.parameterArray())\",\n \"def __returnInitialParametersLocal__(self):\\n return self.dmdParams\",\n \"def parameters(self):\\n return NeuralNetwork.flatten([module.parameters() for module in self.modules])\",\n \"def get_params_snapshot(self):\\n ...\",\n \"def get_params(self, deep=True):\\n params = super().get_params()\\n\\n params['a'] = self._a\\n params['eta'] = self._eta\\n\\n return params\",\n \"def getParameters(self):\\n\\n current_params = {'taux': self.taux, 'mu': self.mu, 'G': self.G, 'alpha_0': self.alpha_0,\\n 'delta': self.delta, 'p': self.p, 'I0': self.I0, 'kparam': self.kparam}\\n\\n return (current_params)\",\n \"def getParameters(self): #$NON-NLS-1$\\r\",\n \"def parameters(self):\\n return self.pars\",\n \"def params(self):\\n return tuple(self._params)\",\n \"def get_parameters(self):\\n # Get the parameters from the parent class\\n params = super(NREvalSplit, self).get_parameters()\\n\\n # Add the LP specific parameters\\n params.update({\\\"samp_frac\\\": self._samp_frac})\\n return params\",\n \"def get_params(self, deep=True):\\n res = copy.deepcopy(self.sk_params)\\n res.update({\\n 'lossfun': self.lossfun,\\n 'accfun': self.accfun,\\n 'device': self.device,\\n })\\n if hasattr(self, 'predictor'):\\n res.update({'predictor': self.predictor})\\n else:\\n res.update({'predictor': self.predictor_constructor})\\n return res\",\n \"def get_params(self):\\n return {}\",\n \"def parameters(self) -> PyTree:\\n return self._parameters\",\n \"def getOutputParams(self):\\n out = {}\\n out[\\\"g_C\\\"] = self.ureg.Quantity(self.g_C, self.gBase).to(self.gOutput)\\n out[\\\"gamma_C\\\"] = self.ureg.Quantity(self.gamma_C,\\n self.gammaBase).to(self.gammaOutput)\\n out[\\\"m\\\"] = self.ureg.Quantity(self.m, self.mBase).to(self.mOutput)\\n out[\\\"charL\\\"] = self.ureg.Quantity(self.charL,\\n self.charLBase).to(self.charLOutput)\\n out[\\\"charT\\\"] = self.ureg.Quantity(self.charT,\\n self.charTBase).to(self.charTOutput)\\n out[\\\"g_R\\\"] = self.ureg.Quantity(self.g_R, self.gBase).to(self.gOutput)\\n out[\\\"R\\\"] = self.ureg.Quantity(self.R, self.rBase).to(self.rOutput)\\n out[\\\"gamma_R\\\"] = self.ureg.Quantity(self.gamma_R,\\n self.gammaBase).to(self.gammaOutput)\\n if self.singleComp:\\n out[\\\"gamma_nl\\\"] = self.ureg.Quantity(self.gamma_nl,\\n self.gammaNlBase).\\\\\\n to(self.gammaNlOutput)\\n return out\",\n \"def parameters(self) -> Dict[str, Any]:\\n return self.data[\\\"args\\\"].get(\\\"parameters\\\", {})\",\n \"def __extract_parameters(self, name):\\r\\n parameters = getattr(self, '_' + name + '_parameters')\\r\\n result = Parameters(parameters)\\r\\n for key in result.keys():\\r\\n result[key] = self.Parameters[key]\\r\\n return result\",\n \"def get_params(self):\\n return list(self.params.values())\",\n \"def parameters(self):\\n return self._params\",\n \"def get_params(self):\\n return {\\n \\\"nspecies\\\": self.nspecies,\\n \\\"lmax\\\": self.lmax,\\n \\\"nmax\\\": self.nmax,\\n \\\"rcut\\\": self.rcut,\\n \\\"sigma\\\": self.sigma,\\n \\\"trans_width\\\": self.trans_width\\n }\",\n \"def _params(self, obj):\\n if isinstance(obj, BaseParameter):\\n return [obj]\\n elif isinstance(obj, BaseModule):\\n return obj.parameters\\n elif isinstance(obj, list):\\n return self._list_params(obj)\\n elif isinstance(obj, dict):\\n return self._dict_params(obj)\\n else:\\n return []\",\n \"def get_params(self, deep=True):\\n return {p: getattr(self, p) for p in self.params}\",\n \"def get_params(self) -> torch.Tensor:\\n params = []\\n for pp in list(self.net.parameters()):\\n params.append(pp.view(-1))\\n return torch.cat(params)\",\n \"def get_params(self) -> np.array:\\n pass\",\n \"def _get_path_parameters(self) -> Generator[Tuple[str, Type], None, None]:\",\n \"def get_params(self):\\n outputs = ['sample',\\n 'ratio_params',\\n 'despike_params',\\n 'autorange_params',\\n 'bkgcorrect_params']\\n\\n out = {}\\n for o in outputs:\\n out[o] = getattr(self, o)\\n\\n out['filter_params'] = self.filt.params\\n out['filter_sequence'] = self.filt.sequence\\n out['filter_used'] = self.filt.make_keydict()\\n\\n return out\",\n \"def get_parameters(self, separate_):\\n if separate_:\\n return self.F, self.J, self.prox\\n else :\\n return self.Fone, self.Jone, self.prox\",\n \"def parameters(self):\\n return {\\\"W\\\": self.W,\\n \\\"T\\\": self.T,\\n \\\"P\\\": self.P}\",\n \"def parameters(self):\\n return self._parameters\",\n \"def parameters(self):\\n return self._parameters\",\n \"def parameters(self):\\n return self._parameters\",\n \"def parameters(self):\\n return self._parameters\",\n \"def parameters(self):\\n return self._parameters\",\n \"def parameters(self):\\n return self._parameters\",\n \"def parameters(self):\\n return self._parameters\",\n \"def parameters(self):\\n return self._parameters\",\n \"def parameters(self):\\n return [p for _, a in vars(self).items() for p in self._params(a)]\",\n \"def get_params(self):\\n params = {}\\n for step in self.steps:\\n params[step[0]] = step[1].get_params()\\n return params\",\n \"def params(self):\\n\\t\\treturn self.params_\",\n \"def get_params(self, **params): # pylint: disable=unused-argument\\n res = copy.deepcopy(self.sk_params)\\n res.update({'build_fn': self.build_fn})\\n return res\",\n \"def get(self):\\n return self._params\",\n \"def parameters(self):\\n pass\",\n \"def generative_parameters(self):\\n params = nn.ParameterList()\\n if 'parameters' in dir(self.generative_model):\\n params.extend(list(self.generative_model.parameters()))\\n params.extend(list(self.latent.generative_parameters()))\\n return params\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73429567","0.6564532","0.6384027","0.6347575","0.633167","0.6293811","0.625885","0.62531525","0.62531525","0.62195283","0.62195283","0.62195283","0.62195283","0.62195283","0.61976695","0.61738086","0.6165213","0.6111482","0.6105472","0.60984695","0.60771704","0.60428274","0.60191834","0.6011697","0.5986069","0.59752446","0.59644246","0.5947318","0.5936935","0.59118986","0.58885413","0.5885972","0.58765554","0.58765554","0.58736676","0.5870331","0.5863591","0.58449185","0.5840624","0.5840624","0.5840624","0.58403057","0.5837136","0.58342427","0.5830814","0.5830814","0.5830814","0.5818572","0.5818572","0.5808964","0.5801915","0.5786126","0.5772587","0.5763832","0.5744111","0.5744111","0.5738364","0.5726549","0.5710463","0.56987184","0.5692775","0.5675691","0.5671702","0.5664135","0.5662709","0.56570804","0.5656281","0.5651865","0.56505483","0.56493306","0.56487435","0.56466264","0.56435734","0.56420267","0.56355035","0.56269586","0.5626628","0.5616217","0.56157434","0.5615526","0.56058717","0.56019557","0.56010085","0.5597155","0.5592793","0.5592793","0.5592793","0.5592793","0.5592793","0.5592793","0.5592793","0.5592793","0.556823","0.55591494","0.55549574","0.55520254","0.5548893","0.5544444","0.5540846"],"string":"[\n \"0.73429567\",\n \"0.6564532\",\n \"0.6384027\",\n \"0.6347575\",\n \"0.633167\",\n \"0.6293811\",\n \"0.625885\",\n \"0.62531525\",\n \"0.62531525\",\n \"0.62195283\",\n \"0.62195283\",\n \"0.62195283\",\n \"0.62195283\",\n \"0.62195283\",\n \"0.61976695\",\n \"0.61738086\",\n \"0.6165213\",\n \"0.6111482\",\n \"0.6105472\",\n \"0.60984695\",\n \"0.60771704\",\n \"0.60428274\",\n \"0.60191834\",\n \"0.6011697\",\n \"0.5986069\",\n \"0.59752446\",\n \"0.59644246\",\n \"0.5947318\",\n \"0.5936935\",\n \"0.59118986\",\n \"0.58885413\",\n \"0.5885972\",\n \"0.58765554\",\n \"0.58765554\",\n \"0.58736676\",\n \"0.5870331\",\n \"0.5863591\",\n \"0.58449185\",\n \"0.5840624\",\n \"0.5840624\",\n \"0.5840624\",\n \"0.58403057\",\n \"0.5837136\",\n \"0.58342427\",\n \"0.5830814\",\n \"0.5830814\",\n \"0.5830814\",\n \"0.5818572\",\n \"0.5818572\",\n \"0.5808964\",\n \"0.5801915\",\n \"0.5786126\",\n \"0.5772587\",\n \"0.5763832\",\n \"0.5744111\",\n \"0.5744111\",\n \"0.5738364\",\n \"0.5726549\",\n \"0.5710463\",\n \"0.56987184\",\n \"0.5692775\",\n \"0.5675691\",\n \"0.5671702\",\n \"0.5664135\",\n \"0.5662709\",\n \"0.56570804\",\n \"0.5656281\",\n \"0.5651865\",\n \"0.56505483\",\n \"0.56493306\",\n \"0.56487435\",\n \"0.56466264\",\n \"0.56435734\",\n \"0.56420267\",\n \"0.56355035\",\n \"0.56269586\",\n \"0.5626628\",\n \"0.5616217\",\n \"0.56157434\",\n \"0.5615526\",\n \"0.56058717\",\n \"0.56019557\",\n \"0.56010085\",\n \"0.5597155\",\n \"0.5592793\",\n \"0.5592793\",\n \"0.5592793\",\n \"0.5592793\",\n \"0.5592793\",\n \"0.5592793\",\n \"0.5592793\",\n \"0.5592793\",\n \"0.556823\",\n \"0.55591494\",\n \"0.55549574\",\n \"0.55520254\",\n \"0.5548893\",\n \"0.5544444\",\n \"0.5540846\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.63266575"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":79097,"cells":{"query":{"kind":"string","value":"Get flatParameters note that getParameters and parameters is not equal in this case getParameters do not get parameters of output module"},"document":{"kind":"string","value":"def getParameters(self):\n params = []\n for m in [self.ix, self.ih, self.fx, self.fh, self.ox, self.oh, self.ux, self.uh]:\n # we do not get param of output module\n l = list(m.parameters())\n params.extend(l)\n\n one_dim = [p.view(p.numel()) for p in params]\n params = F.torch.cat(one_dim)\n return params"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def flatten_parameters(self):","def get_params(self, deep=...):\n ...","def get_parameters(self):\n return(_deepcopy(self.parameters))","def get_params(self, deep=True):\n return super().get_params(deep=deep)","def get_params(self):","def flatten_parameters(self):\n self.encoder_module.rnn.flatten_parameters()\n self.decoder_module.rnn.flatten_parameters()","def _get_orig_params(\n self,\n module: nn.Module,\n ignored_params: Set[nn.Parameter],\n ) -> Iterator[nn.Parameter]:\n param_gen = module.parameters()\n try:\n while True:\n param = next(param_gen)\n if param not in ignored_params and not _is_fsdp_flattened(param):\n yield param\n except StopIteration:\n pass","def get_params(self, deep=False):\n return core.get_params(self)","def get_params(self, deep=False):\n return core.get_params(self)","def get_parameters(self):\n return self.parameters","def get_parameters(self):\n return self.parameters","def get_parameters(self):\n return self.parameters","def get_parameters(self):\n return self.parameters","def get_parameters(self):\n return self.parameters","def _get_parameters(self) -> list:\n return self.parameters","def _get_parameters(self):\n return None","def _flatten_parameters(self):\n [m.flatten_parameters() for m in self._to_flatten]","def parameters(self):\n return self._params","def getParams(self):\n return self.__params","def __parameters__(self) -> tuple[TypeVar, ...]:\n return super().__getattribute__(\"_parameters\")","def get_params(self):\n pass","def _get_params(self):\r\n return self.k._get_params()","def get_params(self):\n return deepcopy(np.hstack([to_numpy(v).flatten() for v in\n self.parameters()]))","def get_params(self, deep=False):\n return {\"alpha\": self.alpha, \"beta\": self.beta, \"gamma\": self.gamma, \"W\": self.W, \"bias\": self.bias, \"add_bias\": self.add_bias, \"opts\": self.opts}","def get_params(self, _deep: bool = True) -> dict:\n return self.params","def parameters(self):\n #print \"in instrument.parameter()\"\n return self._params","def getParameters():\n paramWindDirection,paramWindSpeed,paramWaterHeight,paramRainFall = syncParameters.readParameters(\"./parameters.json\")\n print(\"WindDir: \"+str(paramWindDirection)+\" WindSpd: \"+str(paramWindSpeed)+\" WaterHeight: \"\n +str(paramWaterHeight)+\" RainFall: \"+str(paramRainFall))\n return paramWindDirection,paramWindSpeed,paramWaterHeight,paramRainFall","def parameters(self):\n for parameters in self:\n for parameter in parameters:\n yield parameter","def get_params(self):\n raise NotImplementedError","def params(self) -> Tuple[Parameter, ...]:\n raise NotImplementedError()","def parameters(self):\n return {\"P\": self.P,\n \"T\": self.T}","def get_parameters(self):\n self.unimpl_base_class()","def flatten_parameters(self):\n any_param = next(self.parameters()).data\n if not any_param.is_cuda or not torch.backends.cudnn.is_acceptable(any_param):\n return\n\n # If any parameters alias, we fall back to the slower, copying code path. This is\n # a sufficient check, because overlapping parameter buffers that don't completely\n # alias would break the assumptions of the uniqueness check in\n # Module.named_parameters().\n all_weights = self._flat_weights\n unique_data_ptrs = set(p.data_ptr() for p in all_weights)\n if len(unique_data_ptrs) != len(all_weights):\n return\n\n with torch.cuda.device_of(any_param):\n import torch.backends.cudnn.rnn as rnn\n\n # NB: This is a temporary hack while we still don't have Tensor\n # bindings for ATen functions\n with torch.no_grad():\n # NB: this is an INPLACE function on all_weights, that's why the\n # no_grad() is necessary.\n torch._cudnn_rnn_flatten_weight(\n all_weights, (4 if self.bias else 2),\n self.input_size, rnn.get_cudnn_mode(self.mode), self.hidden_size, self.num_layers,\n self.batch_first, bool(self.bidirectional))","def flatten_parameters(self):\n any_param = next(self.parameters()).data\n if not any_param.is_cuda or not torch.backends.cudnn.is_acceptable(any_param):\n return\n\n # If any parameters alias, we fall back to the slower, copying code path. This is\n # a sufficient check, because overlapping parameter buffers that don't completely\n # alias would break the assumptions of the uniqueness check in\n # Module.named_parameters().\n all_weights = self._flat_weights\n unique_data_ptrs = set(p.data_ptr() for p in all_weights)\n if len(unique_data_ptrs) != len(all_weights):\n return\n\n with torch.cuda.device_of(any_param):\n import torch.backends.cudnn.rnn as rnn\n\n # NB: This is a temporary hack while we still don't have Tensor\n # bindings for ATen functions\n with torch.no_grad():\n # NB: this is an INPLACE function on all_weights, that's why the\n # no_grad() is necessary.\n torch._cudnn_rnn_flatten_weight(\n all_weights, (4 if self.bias else 2),\n self.input_size, rnn.get_cudnn_mode(self.mode), self.hidden_size, self.num_layers,\n self.batch_first, bool(self.bidirectional))","def get_params(self, deep: bool = True) -> Dict[str, Any]:\n return _get_params(self, deep)","def get_params(self):\n return []","def get_params(self):\n return self.w, self.b","def _get_param_to_unflat_param_names(\n model: torch.nn.Module,\n dedup_shared_params: bool = True,\n) -> Dict[torch.nn.Parameter, List[str]]:\n def module_fn(module, prefix, param_to_unflat_param_names):\n # For FSDP modules, only add the entry when considering the contained\n # `FlattenParamsWrapper` to avoid duplication\n if not isinstance(module, FullyShardedDataParallel):\n for param_name, param in module.named_parameters(recurse=False):\n module_prefixed_param_names = (\n param._prefixed_param_names if type(param) is FlatParameter\n else [param_name]\n ) # prefixed from `module`\n fully_prefixed_param_names = [\n clean_tensor_name(prefix + name)\n for name in module_prefixed_param_names\n ] # fully prefixed from the top level including `prefix`\n # If this parameter has already been visited, then it is a\n # shared parameter; then, only take the first parameter name\n is_shared_param = param in param_to_unflat_param_names\n if not is_shared_param:\n param_to_unflat_param_names[param] = fully_prefixed_param_names\n elif not dedup_shared_params:\n param_to_unflat_param_names[param].extend(fully_prefixed_param_names)\n\n def return_fn(param_to_unflat_param_names):\n return param_to_unflat_param_names\n\n param_to_unflat_param_names: Dict[torch.nn.Parameter, List[str]] = {}\n return _apply_to_modules(\n model, module_fn, return_fn, param_to_unflat_param_names,\n )","def get_params(self):\n return self.params","def get_params(self):\n return self.params","def get_params(self):\n return self.params","def getParameters(self):\n\t\td = AdaptiveBatAlgorithm.getParameters(self)\n\t\td.update({\n\t\t\t'A_l': self.A_l,\n\t\t\t'A_u': self.A_u,\n\t\t\t'r_l': self.r_l,\n\t\t\t'r_u': self.r_u,\n\t\t\t'tao_1': self.tao_1,\n\t\t\t'tao_2': self.tao_2\n\t\t})\n\t\treturn d","def parameters(self):","def parameters(self):\n return {\n 'base':self.base.parameters(),\n 'material':[m.parameters() for m in self.material],\n 'fraction':self.fraction,\n }","def get_params(self):\n\n return None","def get_params(self):\n\n return None","def get_params(self):\n\n return None","def get_params (self):\n return self.params","def get_params (self):\n return self.params","def classifyParameters(self):\n\n arguments = []\n options = []\n outputs = []\n for parameter in self.parameters():\n if parameter.channel == 'output' and not (\n parameter.isExternalType() or parameter.typ == 'file'):\n outputs.append(parameter)\n elif parameter.index is not None:\n arguments.append(parameter)\n if parameter.flag is not None or parameter.longflag is not None:\n logger.warning(\"Parameter %s has both index=%d and flag set.\" % (\n parameter.identifier(), parameter.index))\n else:\n options.append(parameter)\n arguments.sort(key = lambda parameter: parameter.index)\n return (arguments, options, outputs)","def get_parameters_form(self):\n return self.parameters","def getParams(self):\n return self.W, self.b","def output_parameters(self):\n output_params = get_data_node(\n 'parameter',\n dict={\n 'stress': self.vasprun_obj.ionic_steps[-1]['stress'],\n 'efermi': self.vasprun_obj.efermi,\n 'energy': self.vasprun_obj.final_energy\n })\n return output_params","def get_parameters(self):\n return self.context.params","def _get_params(self):\r\n return np.hstack((self.k1._get_params(), self.k2._get_params()))","def _get_params(self):\r\n return np.hstack((self.k1._get_params(), self.k2._get_params()))","def parameters(self):\n return []","def _get_parameters(self):\n return (self.SYMBOL, self.parameterArray())","def __returnInitialParametersLocal__(self):\n return self.dmdParams","def parameters(self):\n return NeuralNetwork.flatten([module.parameters() for module in self.modules])","def get_params_snapshot(self):\n ...","def get_params(self, deep=True):\n params = super().get_params()\n\n params['a'] = self._a\n params['eta'] = self._eta\n\n return params","def getParameters(self):\n\n current_params = {'taux': self.taux, 'mu': self.mu, 'G': self.G, 'alpha_0': self.alpha_0,\n 'delta': self.delta, 'p': self.p, 'I0': self.I0, 'kparam': self.kparam}\n\n return (current_params)","def getParameters(self): #$NON-NLS-1$\r","def parameters(self):\n return self.pars","def params(self):\n return tuple(self._params)","def get_parameters(self):\n # Get the parameters from the parent class\n params = super(NREvalSplit, self).get_parameters()\n\n # Add the LP specific parameters\n params.update({\"samp_frac\": self._samp_frac})\n return params","def get_params(self, deep=True):\n res = copy.deepcopy(self.sk_params)\n res.update({\n 'lossfun': self.lossfun,\n 'accfun': self.accfun,\n 'device': self.device,\n })\n if hasattr(self, 'predictor'):\n res.update({'predictor': self.predictor})\n else:\n res.update({'predictor': self.predictor_constructor})\n return res","def get_params(self):\n return {}","def parameters(self) -> PyTree:\n return self._parameters","def getOutputParams(self):\n out = {}\n out[\"g_C\"] = self.ureg.Quantity(self.g_C, self.gBase).to(self.gOutput)\n out[\"gamma_C\"] = self.ureg.Quantity(self.gamma_C,\n self.gammaBase).to(self.gammaOutput)\n out[\"m\"] = self.ureg.Quantity(self.m, self.mBase).to(self.mOutput)\n out[\"charL\"] = self.ureg.Quantity(self.charL,\n self.charLBase).to(self.charLOutput)\n out[\"charT\"] = self.ureg.Quantity(self.charT,\n self.charTBase).to(self.charTOutput)\n out[\"g_R\"] = self.ureg.Quantity(self.g_R, self.gBase).to(self.gOutput)\n out[\"R\"] = self.ureg.Quantity(self.R, self.rBase).to(self.rOutput)\n out[\"gamma_R\"] = self.ureg.Quantity(self.gamma_R,\n self.gammaBase).to(self.gammaOutput)\n if self.singleComp:\n out[\"gamma_nl\"] = self.ureg.Quantity(self.gamma_nl,\n self.gammaNlBase).\\\n to(self.gammaNlOutput)\n return out","def parameters(self) -> Dict[str, Any]:\n return self.data[\"args\"].get(\"parameters\", {})","def __extract_parameters(self, name):\r\n parameters = getattr(self, '_' + name + '_parameters')\r\n result = Parameters(parameters)\r\n for key in result.keys():\r\n result[key] = self.Parameters[key]\r\n return result","def get_params(self):\n return list(self.params.values())","def parameters(self):\n return self._params","def get_params(self):\n return {\n \"nspecies\": self.nspecies,\n \"lmax\": self.lmax,\n \"nmax\": self.nmax,\n \"rcut\": self.rcut,\n \"sigma\": self.sigma,\n \"trans_width\": self.trans_width\n }","def _params(self, obj):\n if isinstance(obj, BaseParameter):\n return [obj]\n elif isinstance(obj, BaseModule):\n return obj.parameters\n elif isinstance(obj, list):\n return self._list_params(obj)\n elif isinstance(obj, dict):\n return self._dict_params(obj)\n else:\n return []","def get_params(self, deep=True):\n return {p: getattr(self, p) for p in self.params}","def get_params(self) -> torch.Tensor:\n params = []\n for pp in list(self.net.parameters()):\n params.append(pp.view(-1))\n return torch.cat(params)","def get_params(self) -> np.array:\n pass","def _get_path_parameters(self) -> Generator[Tuple[str, Type], None, None]:","def get_params(self):\n outputs = ['sample',\n 'ratio_params',\n 'despike_params',\n 'autorange_params',\n 'bkgcorrect_params']\n\n out = {}\n for o in outputs:\n out[o] = getattr(self, o)\n\n out['filter_params'] = self.filt.params\n out['filter_sequence'] = self.filt.sequence\n out['filter_used'] = self.filt.make_keydict()\n\n return out","def get_parameters(self, separate_):\n if separate_:\n return self.F, self.J, self.prox\n else :\n return self.Fone, self.Jone, self.prox","def parameters(self):\n return {\"W\": self.W,\n \"T\": self.T,\n \"P\": self.P}","def parameters(self):\n return self._parameters","def parameters(self):\n return self._parameters","def parameters(self):\n return self._parameters","def parameters(self):\n return self._parameters","def parameters(self):\n return self._parameters","def parameters(self):\n return self._parameters","def parameters(self):\n return self._parameters","def parameters(self):\n return self._parameters","def parameters(self):\n return [p for _, a in vars(self).items() for p in self._params(a)]","def get_params(self):\n params = {}\n for step in self.steps:\n params[step[0]] = step[1].get_params()\n return params","def params(self):\n\t\treturn self.params_","def get_params(self, **params): # pylint: disable=unused-argument\n res = copy.deepcopy(self.sk_params)\n res.update({'build_fn': self.build_fn})\n return res","def get(self):\n return self._params","def parameters(self):\n pass","def generative_parameters(self):\n params = nn.ParameterList()\n if 'parameters' in dir(self.generative_model):\n params.extend(list(self.generative_model.parameters()))\n params.extend(list(self.latent.generative_parameters()))\n return params"],"string":"[\n \"def flatten_parameters(self):\",\n \"def get_params(self, deep=...):\\n ...\",\n \"def get_parameters(self):\\n return(_deepcopy(self.parameters))\",\n \"def get_params(self, deep=True):\\n return super().get_params(deep=deep)\",\n \"def get_params(self):\",\n \"def flatten_parameters(self):\\n self.encoder_module.rnn.flatten_parameters()\\n self.decoder_module.rnn.flatten_parameters()\",\n \"def _get_orig_params(\\n self,\\n module: nn.Module,\\n ignored_params: Set[nn.Parameter],\\n ) -> Iterator[nn.Parameter]:\\n param_gen = module.parameters()\\n try:\\n while True:\\n param = next(param_gen)\\n if param not in ignored_params and not _is_fsdp_flattened(param):\\n yield param\\n except StopIteration:\\n pass\",\n \"def get_params(self, deep=False):\\n return core.get_params(self)\",\n \"def get_params(self, deep=False):\\n return core.get_params(self)\",\n \"def get_parameters(self):\\n return self.parameters\",\n \"def get_parameters(self):\\n return self.parameters\",\n \"def get_parameters(self):\\n return self.parameters\",\n \"def get_parameters(self):\\n return self.parameters\",\n \"def get_parameters(self):\\n return self.parameters\",\n \"def _get_parameters(self) -> list:\\n return self.parameters\",\n \"def _get_parameters(self):\\n return None\",\n \"def _flatten_parameters(self):\\n [m.flatten_parameters() for m in self._to_flatten]\",\n \"def parameters(self):\\n return self._params\",\n \"def getParams(self):\\n return self.__params\",\n \"def __parameters__(self) -> tuple[TypeVar, ...]:\\n return super().__getattribute__(\\\"_parameters\\\")\",\n \"def get_params(self):\\n pass\",\n \"def _get_params(self):\\r\\n return self.k._get_params()\",\n \"def get_params(self):\\n return deepcopy(np.hstack([to_numpy(v).flatten() for v in\\n self.parameters()]))\",\n \"def get_params(self, deep=False):\\n return {\\\"alpha\\\": self.alpha, \\\"beta\\\": self.beta, \\\"gamma\\\": self.gamma, \\\"W\\\": self.W, \\\"bias\\\": self.bias, \\\"add_bias\\\": self.add_bias, \\\"opts\\\": self.opts}\",\n \"def get_params(self, _deep: bool = True) -> dict:\\n return self.params\",\n \"def parameters(self):\\n #print \\\"in instrument.parameter()\\\"\\n return self._params\",\n \"def getParameters():\\n paramWindDirection,paramWindSpeed,paramWaterHeight,paramRainFall = syncParameters.readParameters(\\\"./parameters.json\\\")\\n print(\\\"WindDir: \\\"+str(paramWindDirection)+\\\" WindSpd: \\\"+str(paramWindSpeed)+\\\" WaterHeight: \\\"\\n +str(paramWaterHeight)+\\\" RainFall: \\\"+str(paramRainFall))\\n return paramWindDirection,paramWindSpeed,paramWaterHeight,paramRainFall\",\n \"def parameters(self):\\n for parameters in self:\\n for parameter in parameters:\\n yield parameter\",\n \"def get_params(self):\\n raise NotImplementedError\",\n \"def params(self) -> Tuple[Parameter, ...]:\\n raise NotImplementedError()\",\n \"def parameters(self):\\n return {\\\"P\\\": self.P,\\n \\\"T\\\": self.T}\",\n \"def get_parameters(self):\\n self.unimpl_base_class()\",\n \"def flatten_parameters(self):\\n any_param = next(self.parameters()).data\\n if not any_param.is_cuda or not torch.backends.cudnn.is_acceptable(any_param):\\n return\\n\\n # If any parameters alias, we fall back to the slower, copying code path. This is\\n # a sufficient check, because overlapping parameter buffers that don't completely\\n # alias would break the assumptions of the uniqueness check in\\n # Module.named_parameters().\\n all_weights = self._flat_weights\\n unique_data_ptrs = set(p.data_ptr() for p in all_weights)\\n if len(unique_data_ptrs) != len(all_weights):\\n return\\n\\n with torch.cuda.device_of(any_param):\\n import torch.backends.cudnn.rnn as rnn\\n\\n # NB: This is a temporary hack while we still don't have Tensor\\n # bindings for ATen functions\\n with torch.no_grad():\\n # NB: this is an INPLACE function on all_weights, that's why the\\n # no_grad() is necessary.\\n torch._cudnn_rnn_flatten_weight(\\n all_weights, (4 if self.bias else 2),\\n self.input_size, rnn.get_cudnn_mode(self.mode), self.hidden_size, self.num_layers,\\n self.batch_first, bool(self.bidirectional))\",\n \"def flatten_parameters(self):\\n any_param = next(self.parameters()).data\\n if not any_param.is_cuda or not torch.backends.cudnn.is_acceptable(any_param):\\n return\\n\\n # If any parameters alias, we fall back to the slower, copying code path. This is\\n # a sufficient check, because overlapping parameter buffers that don't completely\\n # alias would break the assumptions of the uniqueness check in\\n # Module.named_parameters().\\n all_weights = self._flat_weights\\n unique_data_ptrs = set(p.data_ptr() for p in all_weights)\\n if len(unique_data_ptrs) != len(all_weights):\\n return\\n\\n with torch.cuda.device_of(any_param):\\n import torch.backends.cudnn.rnn as rnn\\n\\n # NB: This is a temporary hack while we still don't have Tensor\\n # bindings for ATen functions\\n with torch.no_grad():\\n # NB: this is an INPLACE function on all_weights, that's why the\\n # no_grad() is necessary.\\n torch._cudnn_rnn_flatten_weight(\\n all_weights, (4 if self.bias else 2),\\n self.input_size, rnn.get_cudnn_mode(self.mode), self.hidden_size, self.num_layers,\\n self.batch_first, bool(self.bidirectional))\",\n \"def get_params(self, deep: bool = True) -> Dict[str, Any]:\\n return _get_params(self, deep)\",\n \"def get_params(self):\\n return []\",\n \"def get_params(self):\\n return self.w, self.b\",\n \"def _get_param_to_unflat_param_names(\\n model: torch.nn.Module,\\n dedup_shared_params: bool = True,\\n) -> Dict[torch.nn.Parameter, List[str]]:\\n def module_fn(module, prefix, param_to_unflat_param_names):\\n # For FSDP modules, only add the entry when considering the contained\\n # `FlattenParamsWrapper` to avoid duplication\\n if not isinstance(module, FullyShardedDataParallel):\\n for param_name, param in module.named_parameters(recurse=False):\\n module_prefixed_param_names = (\\n param._prefixed_param_names if type(param) is FlatParameter\\n else [param_name]\\n ) # prefixed from `module`\\n fully_prefixed_param_names = [\\n clean_tensor_name(prefix + name)\\n for name in module_prefixed_param_names\\n ] # fully prefixed from the top level including `prefix`\\n # If this parameter has already been visited, then it is a\\n # shared parameter; then, only take the first parameter name\\n is_shared_param = param in param_to_unflat_param_names\\n if not is_shared_param:\\n param_to_unflat_param_names[param] = fully_prefixed_param_names\\n elif not dedup_shared_params:\\n param_to_unflat_param_names[param].extend(fully_prefixed_param_names)\\n\\n def return_fn(param_to_unflat_param_names):\\n return param_to_unflat_param_names\\n\\n param_to_unflat_param_names: Dict[torch.nn.Parameter, List[str]] = {}\\n return _apply_to_modules(\\n model, module_fn, return_fn, param_to_unflat_param_names,\\n )\",\n \"def get_params(self):\\n return self.params\",\n \"def get_params(self):\\n return self.params\",\n \"def get_params(self):\\n return self.params\",\n \"def getParameters(self):\\n\\t\\td = AdaptiveBatAlgorithm.getParameters(self)\\n\\t\\td.update({\\n\\t\\t\\t'A_l': self.A_l,\\n\\t\\t\\t'A_u': self.A_u,\\n\\t\\t\\t'r_l': self.r_l,\\n\\t\\t\\t'r_u': self.r_u,\\n\\t\\t\\t'tao_1': self.tao_1,\\n\\t\\t\\t'tao_2': self.tao_2\\n\\t\\t})\\n\\t\\treturn d\",\n \"def parameters(self):\",\n \"def parameters(self):\\n return {\\n 'base':self.base.parameters(),\\n 'material':[m.parameters() for m in self.material],\\n 'fraction':self.fraction,\\n }\",\n \"def get_params(self):\\n\\n return None\",\n \"def get_params(self):\\n\\n return None\",\n \"def get_params(self):\\n\\n return None\",\n \"def get_params (self):\\n return self.params\",\n \"def get_params (self):\\n return self.params\",\n \"def classifyParameters(self):\\n\\n arguments = []\\n options = []\\n outputs = []\\n for parameter in self.parameters():\\n if parameter.channel == 'output' and not (\\n parameter.isExternalType() or parameter.typ == 'file'):\\n outputs.append(parameter)\\n elif parameter.index is not None:\\n arguments.append(parameter)\\n if parameter.flag is not None or parameter.longflag is not None:\\n logger.warning(\\\"Parameter %s has both index=%d and flag set.\\\" % (\\n parameter.identifier(), parameter.index))\\n else:\\n options.append(parameter)\\n arguments.sort(key = lambda parameter: parameter.index)\\n return (arguments, options, outputs)\",\n \"def get_parameters_form(self):\\n return self.parameters\",\n \"def getParams(self):\\n return self.W, self.b\",\n \"def output_parameters(self):\\n output_params = get_data_node(\\n 'parameter',\\n dict={\\n 'stress': self.vasprun_obj.ionic_steps[-1]['stress'],\\n 'efermi': self.vasprun_obj.efermi,\\n 'energy': self.vasprun_obj.final_energy\\n })\\n return output_params\",\n \"def get_parameters(self):\\n return self.context.params\",\n \"def _get_params(self):\\r\\n return np.hstack((self.k1._get_params(), self.k2._get_params()))\",\n \"def _get_params(self):\\r\\n return np.hstack((self.k1._get_params(), self.k2._get_params()))\",\n \"def parameters(self):\\n return []\",\n \"def _get_parameters(self):\\n return (self.SYMBOL, self.parameterArray())\",\n \"def __returnInitialParametersLocal__(self):\\n return self.dmdParams\",\n \"def parameters(self):\\n return NeuralNetwork.flatten([module.parameters() for module in self.modules])\",\n \"def get_params_snapshot(self):\\n ...\",\n \"def get_params(self, deep=True):\\n params = super().get_params()\\n\\n params['a'] = self._a\\n params['eta'] = self._eta\\n\\n return params\",\n \"def getParameters(self):\\n\\n current_params = {'taux': self.taux, 'mu': self.mu, 'G': self.G, 'alpha_0': self.alpha_0,\\n 'delta': self.delta, 'p': self.p, 'I0': self.I0, 'kparam': self.kparam}\\n\\n return (current_params)\",\n \"def getParameters(self): #$NON-NLS-1$\\r\",\n \"def parameters(self):\\n return self.pars\",\n \"def params(self):\\n return tuple(self._params)\",\n \"def get_parameters(self):\\n # Get the parameters from the parent class\\n params = super(NREvalSplit, self).get_parameters()\\n\\n # Add the LP specific parameters\\n params.update({\\\"samp_frac\\\": self._samp_frac})\\n return params\",\n \"def get_params(self, deep=True):\\n res = copy.deepcopy(self.sk_params)\\n res.update({\\n 'lossfun': self.lossfun,\\n 'accfun': self.accfun,\\n 'device': self.device,\\n })\\n if hasattr(self, 'predictor'):\\n res.update({'predictor': self.predictor})\\n else:\\n res.update({'predictor': self.predictor_constructor})\\n return res\",\n \"def get_params(self):\\n return {}\",\n \"def parameters(self) -> PyTree:\\n return self._parameters\",\n \"def getOutputParams(self):\\n out = {}\\n out[\\\"g_C\\\"] = self.ureg.Quantity(self.g_C, self.gBase).to(self.gOutput)\\n out[\\\"gamma_C\\\"] = self.ureg.Quantity(self.gamma_C,\\n self.gammaBase).to(self.gammaOutput)\\n out[\\\"m\\\"] = self.ureg.Quantity(self.m, self.mBase).to(self.mOutput)\\n out[\\\"charL\\\"] = self.ureg.Quantity(self.charL,\\n self.charLBase).to(self.charLOutput)\\n out[\\\"charT\\\"] = self.ureg.Quantity(self.charT,\\n self.charTBase).to(self.charTOutput)\\n out[\\\"g_R\\\"] = self.ureg.Quantity(self.g_R, self.gBase).to(self.gOutput)\\n out[\\\"R\\\"] = self.ureg.Quantity(self.R, self.rBase).to(self.rOutput)\\n out[\\\"gamma_R\\\"] = self.ureg.Quantity(self.gamma_R,\\n self.gammaBase).to(self.gammaOutput)\\n if self.singleComp:\\n out[\\\"gamma_nl\\\"] = self.ureg.Quantity(self.gamma_nl,\\n self.gammaNlBase).\\\\\\n to(self.gammaNlOutput)\\n return out\",\n \"def parameters(self) -> Dict[str, Any]:\\n return self.data[\\\"args\\\"].get(\\\"parameters\\\", {})\",\n \"def __extract_parameters(self, name):\\r\\n parameters = getattr(self, '_' + name + '_parameters')\\r\\n result = Parameters(parameters)\\r\\n for key in result.keys():\\r\\n result[key] = self.Parameters[key]\\r\\n return result\",\n \"def get_params(self):\\n return list(self.params.values())\",\n \"def parameters(self):\\n return self._params\",\n \"def get_params(self):\\n return {\\n \\\"nspecies\\\": self.nspecies,\\n \\\"lmax\\\": self.lmax,\\n \\\"nmax\\\": self.nmax,\\n \\\"rcut\\\": self.rcut,\\n \\\"sigma\\\": self.sigma,\\n \\\"trans_width\\\": self.trans_width\\n }\",\n \"def _params(self, obj):\\n if isinstance(obj, BaseParameter):\\n return [obj]\\n elif isinstance(obj, BaseModule):\\n return obj.parameters\\n elif isinstance(obj, list):\\n return self._list_params(obj)\\n elif isinstance(obj, dict):\\n return self._dict_params(obj)\\n else:\\n return []\",\n \"def get_params(self, deep=True):\\n return {p: getattr(self, p) for p in self.params}\",\n \"def get_params(self) -> torch.Tensor:\\n params = []\\n for pp in list(self.net.parameters()):\\n params.append(pp.view(-1))\\n return torch.cat(params)\",\n \"def get_params(self) -> np.array:\\n pass\",\n \"def _get_path_parameters(self) -> Generator[Tuple[str, Type], None, None]:\",\n \"def get_params(self):\\n outputs = ['sample',\\n 'ratio_params',\\n 'despike_params',\\n 'autorange_params',\\n 'bkgcorrect_params']\\n\\n out = {}\\n for o in outputs:\\n out[o] = getattr(self, o)\\n\\n out['filter_params'] = self.filt.params\\n out['filter_sequence'] = self.filt.sequence\\n out['filter_used'] = self.filt.make_keydict()\\n\\n return out\",\n \"def get_parameters(self, separate_):\\n if separate_:\\n return self.F, self.J, self.prox\\n else :\\n return self.Fone, self.Jone, self.prox\",\n \"def parameters(self):\\n return {\\\"W\\\": self.W,\\n \\\"T\\\": self.T,\\n \\\"P\\\": self.P}\",\n \"def parameters(self):\\n return self._parameters\",\n \"def parameters(self):\\n return self._parameters\",\n \"def parameters(self):\\n return self._parameters\",\n \"def parameters(self):\\n return self._parameters\",\n \"def parameters(self):\\n return self._parameters\",\n \"def parameters(self):\\n return self._parameters\",\n \"def parameters(self):\\n return self._parameters\",\n \"def parameters(self):\\n return self._parameters\",\n \"def parameters(self):\\n return [p for _, a in vars(self).items() for p in self._params(a)]\",\n \"def get_params(self):\\n params = {}\\n for step in self.steps:\\n params[step[0]] = step[1].get_params()\\n return params\",\n \"def params(self):\\n\\t\\treturn self.params_\",\n \"def get_params(self, **params): # pylint: disable=unused-argument\\n res = copy.deepcopy(self.sk_params)\\n res.update({'build_fn': self.build_fn})\\n return res\",\n \"def get(self):\\n return self._params\",\n \"def parameters(self):\\n pass\",\n \"def generative_parameters(self):\\n params = nn.ParameterList()\\n if 'parameters' in dir(self.generative_model):\\n params.extend(list(self.generative_model.parameters()))\\n params.extend(list(self.latent.generative_parameters()))\\n return params\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73429567","0.6564532","0.6384027","0.6347575","0.633167","0.6293811","0.625885","0.62531525","0.62531525","0.62195283","0.62195283","0.62195283","0.62195283","0.62195283","0.61976695","0.61738086","0.6165213","0.6111482","0.6105472","0.60984695","0.60771704","0.60428274","0.60191834","0.6011697","0.5986069","0.59752446","0.59644246","0.5947318","0.5936935","0.59118986","0.58885413","0.5885972","0.58765554","0.58765554","0.58736676","0.5870331","0.5863591","0.58449185","0.5840624","0.5840624","0.5840624","0.58403057","0.5837136","0.58342427","0.5830814","0.5830814","0.5830814","0.5818572","0.5818572","0.5808964","0.5801915","0.5786126","0.5772587","0.5763832","0.5744111","0.5744111","0.5738364","0.5726549","0.5710463","0.56987184","0.5692775","0.5675691","0.5671702","0.5664135","0.5662709","0.56570804","0.5656281","0.5651865","0.56505483","0.56493306","0.56487435","0.56466264","0.56435734","0.56420267","0.56355035","0.56269586","0.5626628","0.5616217","0.56157434","0.5615526","0.56058717","0.56019557","0.56010085","0.5597155","0.5592793","0.5592793","0.5592793","0.5592793","0.5592793","0.5592793","0.5592793","0.5592793","0.556823","0.55591494","0.55549574","0.55520254","0.5548893","0.5544444","0.5540846"],"string":"[\n \"0.73429567\",\n \"0.6564532\",\n \"0.6384027\",\n \"0.6347575\",\n \"0.633167\",\n \"0.6293811\",\n \"0.625885\",\n \"0.62531525\",\n \"0.62531525\",\n \"0.62195283\",\n \"0.62195283\",\n \"0.62195283\",\n \"0.62195283\",\n \"0.62195283\",\n \"0.61976695\",\n \"0.61738086\",\n \"0.6165213\",\n \"0.6111482\",\n \"0.6105472\",\n \"0.60984695\",\n \"0.60771704\",\n \"0.60428274\",\n \"0.60191834\",\n \"0.6011697\",\n \"0.5986069\",\n \"0.59752446\",\n \"0.59644246\",\n \"0.5947318\",\n \"0.5936935\",\n \"0.59118986\",\n \"0.58885413\",\n \"0.5885972\",\n \"0.58765554\",\n \"0.58765554\",\n \"0.58736676\",\n \"0.5870331\",\n \"0.5863591\",\n \"0.58449185\",\n \"0.5840624\",\n \"0.5840624\",\n \"0.5840624\",\n \"0.58403057\",\n \"0.5837136\",\n \"0.58342427\",\n \"0.5830814\",\n \"0.5830814\",\n \"0.5830814\",\n \"0.5818572\",\n \"0.5818572\",\n \"0.5808964\",\n \"0.5801915\",\n \"0.5786126\",\n \"0.5772587\",\n \"0.5763832\",\n \"0.5744111\",\n \"0.5744111\",\n \"0.5738364\",\n \"0.5726549\",\n \"0.5710463\",\n \"0.56987184\",\n \"0.5692775\",\n \"0.5675691\",\n \"0.5671702\",\n \"0.5664135\",\n \"0.5662709\",\n \"0.56570804\",\n \"0.5656281\",\n \"0.5651865\",\n \"0.56505483\",\n \"0.56493306\",\n \"0.56487435\",\n \"0.56466264\",\n \"0.56435734\",\n \"0.56420267\",\n \"0.56355035\",\n \"0.56269586\",\n \"0.5626628\",\n \"0.5616217\",\n \"0.56157434\",\n \"0.5615526\",\n \"0.56058717\",\n \"0.56019557\",\n \"0.56010085\",\n \"0.5597155\",\n \"0.5592793\",\n \"0.5592793\",\n \"0.5592793\",\n \"0.5592793\",\n \"0.5592793\",\n \"0.5592793\",\n \"0.5592793\",\n \"0.5592793\",\n \"0.556823\",\n \"0.55591494\",\n \"0.55549574\",\n \"0.55520254\",\n \"0.5548893\",\n \"0.5544444\",\n \"0.5540846\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.63266575"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":79098,"cells":{"query":{"kind":"string","value":"Child sum tree LSTM forward function"},"document":{"kind":"string","value":"def forward(self, tree, embs, training = False):\n\n # add singleton dimension for future call to node_forward\n # embs = F.torch.unsqueeze(self.emb(inputs),1)\n\n loss = Var(torch.zeros(1)) # init zero loss\n if self.cudaFlag:\n loss = loss.cuda()\n\n for idx in range(tree.num_children):\n _, child_loss = self.forward(tree.children[idx], embs, training)\n loss = loss + child_loss\n child_c, child_h = self.get_child_states(tree)\n tree.state = self.node_forward(embs[tree.idx-1], child_c, child_h)\n\n if self.output_module != None:\n output = self.output_module.forward(tree.state[1], training)\n tree.output = output\n if training and tree.gold_label != None:\n target = Var(utils.map_label_to_target_sentiment(tree.gold_label))\n if self.cudaFlag:\n target = target.cuda()\n loss = loss + self.criterion(output, target)\n return tree.state, loss"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def forward(self, xs):\n\n xs = torch.split(xs, self.channel, -1)# list of batch, node, featdim\n xs = torch.stack(xs,2)#[batch, nodes, num_layers, num_channels]\n shape = xs.shape\n x = xs.reshape((-1,shape[2],shape[3])) # [ngraph * num_nodes , num_layers, num_channels]\n alpha, _ = self.lstm(x)\n alpha = self.att(alpha).squeeze(-1) # [ngraph * num_nodes, num_layers]\n alpha = torch.softmax(alpha, dim=-1)\n x = (x * alpha.unsqueeze(-1)).sum(dim=1)\n x = x.reshape((shape[0],shape[1],shape[3]))\n return x","def forward(self, X, hx=None):\n outputs = []\n (batch_size, Nseq, Dim) = X.size()\n \n# print (\"Dimensions LSTM_RNN Batch: \", (batch_size, Nseq, Dim))\n for l in range(self.num_layers):\n if (type(hx) == type(None)):\n h_t = torch.zeros(batch_size, self.hidden_size).to(device = Vil.device, dtype = Vil.dtype)\n c_t = torch.zeros(batch_size, self.hidden_size).to(device = Vil.device, dtype = Vil.dtype)\n else:\n h_t = torch.zeros(batch_size, self.hidden_size).to(device = Vil.device, dtype = Vil.dtype)\n c_t = torch.zeros(batch_size, self.hidden_size).to(device = Vil.device, dtype = Vil.dtype)\n setattr(self, 'h_t%i'%(l+1), h_t)\n setattr(self, 'c_t%i'%(l+1), c_t)\n \n # We loop for every element in the chain and for every layer\n\n for i in range(Nseq):\n input_t = X[:,i,:]\n# print (\"Sequence Chunk size: \",input_t.size())\n l = 0\n # First layer we put the input, in the rest we put the propagated states\n h_t, c_t = getattr(self, 'LSTMCell%i'%(l+1))(input_t, (getattr(self, 'h_t%i'%(l+1)), getattr(self, 'c_t%i'%(l+1))))\n setattr(self, 'h_t%i'%(l+1), h_t)\n setattr(self, 'c_t%i'%(l+1), c_t)\n \n for l in range(1,self.num_layers):\n h_t, c_t = getattr(self, 'LSTMCell%i'%(l+1))(h_t, (getattr(self, 'h_t%i'%(l+1)), getattr(self, 'c_t%i'%(l+1))))\n setattr(self, 'h_t%i'%(l+1), h_t)\n setattr(self, 'c_t%i'%(l+1), c_t)\n \n \n # Return the hx and cx of all layers ? for the last sample ?\n outputs = []\n for l in range(self.num_layers):\n outputs.append( [getattr(self, 'h_t%i'%(l+1)), getattr(self, 'c_t%i'%(l+1))])\n\n# outputs = torch.stack(outputs, 1).squeeze(2)\n \n return outputs","def forward(self, x):\n batch_size = x.size(0)\n out,_ = self.lstm(x) #out = batch, seq_len, num_directions * hidden_size\n out1 = out[:, -1, :16] #最后一层正向传播的最后一个timestep\n out2 = out[:, 0, 16:] #最后一层反向传播最后一个timestep\n out = torch.cat((out1,out2), dim=1)\n out = self.fc(out)\n\n return out","def forward(self, x):\n x, self.hidden = self.lstm(x, self.hidden)\n self.detach_hidden()\n x = self.dropout(x)\n x = self.out(x)\n return x","def forward(self, x):\n x = tensor(x).unsqueeze(1)\n x = self.cnn(x)\n\n # LSTM from here\n batch_size = x.shape[0]\n x = x.view(batch_size, x.shape[1] * x.shape[2], x.shape[3])\n x = x.permute(2, 0, 1) # Converting from (B,H,W)->(W,B,H)\n\n output = self.rnn(x)\n return output","def __init__(self, incoming, n_units,\n W_ci=tf.zeros, W_ig=tf.zeros, W_og=tf.zeros, W_fg=tf.zeros,\n b_ci=tf.zeros, b_ig=tf.zeros, b_og=tf.zeros, b_fg=tf.zeros,\n a_ci=tf.tanh, a_ig=tf.sigmoid, a_og=tf.sigmoid, a_fg=tf.sigmoid, a_out=tf.identity,\n c_init=tf.zeros, h_init=tf.zeros, learn_c_init=False, learn_h_init=False, forgetgate=True,\n output_dropout=False, store_states=False, return_states=False, precomp_fwds=False,\n tickerstep_biases=None, learn_tickerstep_biases=True, name='LSTM'):\n super(LSTMLayer, self).__init__()\n with tf.variable_scope(name) as self.layer_scope:\n self.incoming, self.incoming_shape = get_input(incoming)\n self.n_units = n_units\n self.lstm_inlets = ['ci', 'ig', 'og', 'fg']\n if return_states:\n store_states = True\n \n #\n # Initialize weights and biases\n #\n \n # Turn W inits into lists [forward_pass, backward_pass]\n W_ci, W_ig, W_og, W_fg = [v[:2] if isinstance(v, list) else [v, v] for v in [W_ci, W_ig, W_og, W_fg]]\n \n # Make W and b tf variables\n W_ci, W_ig, W_og, W_fg = [\n [tofov(v[0], shape=[self.incoming_shape[-1], n_units], var_params=dict(name=n + '_fwd')),\n tofov(v[1], shape=[n_units, n_units], var_params=dict(name=n + '_bwd'))]\n for v, n in zip([W_ci, W_ig, W_og, W_fg], ['W_ci', 'W_ig', 'W_og', 'W_fg'])]\n b_ci, b_ig, b_og, b_fg = [tofov(v, shape=[n_units], var_params=dict(name=n)) for v, n in\n zip([b_ci, b_ig, b_og, b_fg], ['b_ci', 'b_ig', 'b_og', 'b_fg'])]\n \n # Pack weights for fwd and bwd connections\n W_fwd_conc = tf.concat(axis=1, values=[W[0] for W in [W_ci, W_ig, W_og, W_fg]])\n W_bwd_conc = tf.concat(axis=1, values=[W[1] for W in [W_ci, W_ig, W_og, W_fg]])\n \n if not forgetgate:\n print(\"Warning: Setting forgetgate to 0 has not been tested yet, please set the W and b manually \"\n \"to not-trainable tensorflow variables!\")\n \n def a_fg(x):\n return tf.ones(x.get_shape().as_list())\n \n # Initialize bias for tickersteps\n if tickerstep_biases is not None:\n self.W_tickers = OrderedDict(zip_longest(self.lstm_inlets,\n [tofov(tickerstep_biases, shape=[n_units],\n var_params=dict(name='W_tickers_' + g,\n trainable=learn_tickerstep_biases))\n for g in self.lstm_inlets]))\n else:\n self.W_tickers = None\n \n #\n # Create mask for output dropout\n # apply dropout to n_units dimension of outputs, keeping dropout mask the same for all samples,\n # sequence positions, and pixel coordinates\n #\n output_shape = self.get_output_shape()\n if output_dropout:\n out_do_mask = tf.ones(shape=[output_shape[0], output_shape[-1]],\n dtype=tf.float32)\n out_do_mask = tf.nn.dropout(out_do_mask, keep_prob=1. - output_dropout,\n noise_shape=[1, output_shape[-1]])\n \n def out_do(x):\n \"\"\"Function for applying dropout mask to outputs\"\"\"\n if output_dropout:\n return out_do_mask * x\n else:\n return x\n \n # Redefine a_out to include dropout (sneaky, sneaky)\n a_out_nodropout = a_out\n \n def a_out(x):\n return a_out_nodropout(out_do(x))\n \n #\n # Handle initializations for h (hidden states) and c (cell states) as Variable\n #\n h_init = out_do(tofov(h_init, shape=[output_shape[0], output_shape[-1]],\n var_params=dict(name='h_init', trainable=learn_h_init)))\n c_init = tofov(c_init, shape=[output_shape[0], output_shape[-1]],\n var_params=dict(name='h_init', trainable=learn_c_init))\n \n # Initialize lists to store LSTM activations and cell states later\n h = [h_init]\n c = [c_init]\n \n self.precomp_fwds = precomp_fwds\n self.store_states = store_states\n self.return_states = return_states\n \n self.W_fwd = OrderedDict(zip(self.lstm_inlets, [W[0] for W in [W_ci, W_ig, W_og, W_fg]]))\n self.W_bwd = OrderedDict(zip(self.lstm_inlets, [W[1] for W in [W_ci, W_ig, W_og, W_fg]]))\n \n self.W_fwd_conc = W_fwd_conc\n self.W_bwd_conc = W_bwd_conc\n self.a = OrderedDict(zip(self.lstm_inlets, [a_ci, a_ig, a_og, a_fg]))\n self.a['out'] = a_out\n self.b = OrderedDict(zip(self.lstm_inlets, [b_ci, b_ig, b_og, b_fg]))\n self.h = h\n self.c = c\n self.external_rec = None\n \n self.ig = []\n self.og = []\n self.ci = []\n self.fg = []\n \n self.out = tf.expand_dims(h_init, 1)\n self.name = name","def __init__(self, input_size, hidden_size, num_layers, hierarchy_depth,\n dropout):\n super().__init__()\n\n self.hierarchy_depth = hierarchy_depth\n self.lstm = nn.LSTM(\n input_size=input_size,\n hidden_size=hidden_size,\n num_layers=num_layers,\n batch_first=True,\n dropout=dropout)\n self.linear1 = nn.Linear(hidden_size + 2 * hierarchy_depth - 2, 256)\n self.linear2 = nn.Linear(256, 256)\n self.linear3 = nn.Linear(256, 1)","def forward(self,x):\n \n out,_ = self.lstm(x,self.hidden)\n out = out.detach()\n x = out[:,-1,:][-1]\n x = self.relu(x)\n if self.stochastic:\n x= x+ (x- self.memory[0]).detach()* torch.rand(x.shape) * self.sigmoid(self.SM.gamma[0])\n self.memory[0] = x.clone().detach()\n\n x = self.relu(self.layer1(x))\n if self.stochastic:\n x= x+ (x- self.memory[1]).detach()* torch.rand(x.shape) * self.sigmoid(self.SM.gamma[1])\n self.memory[1] = x.clone().detach()\n\n x = self.relu(self.layer2(x))\n if self.stochastic:\n x= x+ (x- self.memory[2]).detach()* torch.rand(x.shape) * self.sigmoid(self.SM.gamma[2])\n self.memory[2] = x.clone().detach()\n\n x = self.relu(self.layer3(x))\n if self.stochastic:\n x= x+ (x- self.memory[3]).detach()* torch.rand(x.shape) * self.sigmoid(self.SM.gamma[3])\n self.memory[3] = x.clone().detach()\n\n x = self.relu(self.layer4(x))\n return x","def forward_rnn(self, inputs, state, seq_lens):\n x = nn.functional.relu(self.fc1(inputs))\n lstm_out = self.lstm(\n x, [torch.unsqueeze(state[0], 0),\n torch.unsqueeze(state[1], 0)])\n action_out = self.action_branch(lstm_out[0])\n self._cur_value = torch.reshape(self.value_branch(lstm_out[0]), [-1])\n return action_out, [\n torch.squeeze(lstm_out[1][0], 0),\n torch.squeeze(lstm_out[1][1], 0)\n ]","def forward(self, inputs):\n layer_multiplier = 2\n if self.bidirectional == False:\n layer_multiplier = 1\n \n if torch.cuda.is_available():\n #c0 = Variable(torch.rand(self.lstm.num_layers*2, self.batch_size, self.lstm.hidden_size),requires_grad=False).cuda()\n c0 = Variable(torch.rand(self.lstm.num_layers*layer_multiplier, 1, self.lstm.hidden_size),requires_grad=False).cuda()\n #h0 = Variable(torch.rand(self.lstm.num_layers*2, self.batch_size, self.lstm.hidden_size),requires_grad=False).cuda()\n h0 = Variable(torch.rand(self.lstm.num_layers*layer_multiplier, 1, self.lstm.hidden_size),requires_grad=False).cuda()\n else:\n #c0 = Variable(torch.rand(self.lstm.num_layers*2, self.batch_size, self.lstm.hidden_size),requires_grad=False).cuda()\n c0 = Variable(torch.rand(self.lstm.num_layers*layer_multiplier, 1, self.lstm.hidden_size),requires_grad=False)\n #h0 = Variable(torch.rand(self.lstm.num_layers*2, self.batch_size, self.lstm.hidden_size),requires_grad=False).cuda()\n h0 = Variable(torch.rand(self.lstm.num_layers*layer_multiplier, 1, self.lstm.hidden_size),requires_grad=False)\n #print(\"c0 \", c0.shape, \" h0 \", h0.shape)\n output, (hn, cn) = self.lstm(inputs, (h0, c0))\n #print( \"inputs.shape \", inputs.shape, output.shape )\n \n if self.second_lstm is not None:\n if torch.cuda.is_available():\n #c0 = Variable(torch.rand(self.lstm.num_layers*2, self.batch_size, self.lstm.hidden_size),requires_grad=False).cuda()\n c0 = Variable(torch.rand(self.second_lstm.num_layers*2, 1, self.second_lstm.hidden_size),requires_grad=False).cuda()\n #h0 = Variable(torch.rand(self.lstm.num_layers*2, self.batch_size, self.lstm.hidden_size),requires_grad=False).cuda()\n h0 = Variable(torch.rand(self.second_lstm.num_layers*2, 1, self.second_lstm.hidden_size),requires_grad=False).cuda()\n else:\n #c0 = Variable(torch.rand(self.lstm.num_layers*2, self.batch_size, self.lstm.hidden_size),requires_grad=False).cuda()\n c0 = Variable(torch.rand(self.second_lstm.num_layers*2, 1, self.second_lstm.hidden_size),requires_grad=False)\n #h0 = Variable(torch.rand(self.lstm.num_layers*2, self.batch_size, self.lstm.hidden_size),requires_grad=False).cuda()\n h0 = Variable(torch.rand(self.second_lstm.num_layers*2, 1, self.second_lstm.hidden_size),requires_grad=False)\n #print(\"c0 \", c0.shape, \" h0 \", h0.shape)\n output, (hn, cn) = self.second_lstm(output, (h0, c0))\n \n return output, hn, cn","def forward(self, s):\n # -> batch_size x seq_len\n # apply the embedding layer that maps each token to its embedding\n # dim: batch_size x seq_len x embedding_dim\n s = self.embedding(s)\n\n # run the LSTM along the sentences of length seq_len\n # dim: batch_size x seq_len x lstm_hidden_dim\n s, _ = self.lstm(s)\n\n # make the Variable contiguous in memory (a PyTorch artefact)\n s = s.contiguous()\n\n # reshape the Variable so that each row contains one token\n # dim: batch_size*seq_len x lstm_hidden_dim\n s = s.view(-1, s.shape[2])\n\n # apply the fully connected layer and obtain the output (before softmax) for each token\n s = self.fc(s) # dim: batch_size*seq_len x num_tags\n s = self.fc2(s)\n s = self.fc3(s)\n\n # apply log softmax on each token's output (this is recommended over applying softmax\n # since it is numerically more stable)\n return F.log_softmax(s, dim=1) # dim: batch_size*seq_len x num_tags","def __init__(self,feature,hidden_unit, D_in, D_out):\n super(cnn_lstm, self).__init__()\n self.model_ft = models.alexnet(pretrained=True)\n # print (model_ft)\n\n self.num_ftrs = self.model_ft.classifier[6].in_features\n self.feature_model = list(self.model_ft.classifier.children())\n self.feature_model.pop()\n self.feature_model.pop()\n # feature_model.append(nn.Linear(num_ftrs, 3))\n self.feature_model.append(nn.Linear(self.num_ftrs, 1046))\n # self.feature_model.append(nn.Linear(self.num_ftrs, 524))\n self.feature_model.append(nn.Linear(1046, 100))\n # self.feature_model.append(nn.Linear(524, 100))\n\n self.model_ft.classifier = nn.Sequential(*self.feature_model)\n\n self.rnn = nn.LSTM(feature,hidden_unit,batch_first=True).cuda()\n self.linear = torch.nn.Linear(D_in, D_out).cuda()","def forward(self, x):\n # Set initial states\n h0_variable = torch.zeros(self.num_layers * 2, x.size(0), self.hidden_size).to(self.device)\n c0_variable = torch.zeros(self.num_layers * 2, x.size(0), self.hidden_size).to(self.device)\n\n # Forward propagate LSTM\n out, _ = self.lstm(x, (h0_variable, c0_variable))\n\n # Decode the hidden state of the last time step\n out = nn.Softmax(dim=2)(self.fc(out))\n return out","def forward(self, x):\r\n h_0 = torch.zeros(\r\n self.num_layers, x.size(0), self.hidden_size).to(device)\r\n\r\n c_0 = torch.zeros(\r\n self.num_layers, x.size(0), self.hidden_size).to(device)\r\n\r\n # Propagate input through LSTM\r\n ula, (h_out, _) = self.lstm(x, (h_0, c_0))\r\n\r\n h_out = h_out.view(-1, self.hidden_size)\r\n\r\n out = self.fc(h_out)\r\n\r\n return out","def forward(self, x):\r\n \r\n out, self.hidden_state = self.lstm(\r\n x, self.hidden_state)\r\n \r\n self.hidden_state = tuple(\r\n [h.detach() for h in self.hidden_state])\r\n \r\n out = self.linear(out)\r\n \r\n # Add the average of the last two points in the chunk to the\r\n # output value so that the model doesn't have to predict\r\n # the actual next value in the sequence, but just the change\r\n # from the last two points. This makes the predictions more \r\n # likely to be close to the previous value, which is expected\r\n # for smoothly changing data like EXAFS.\r\n return out.squeeze()+x[:,:,-2:].mean(dim=-1)","def forward(self, input=None):\n self._repackage()\n if (input is not None) and (self.result is None):\n if self.G.ntype == \"lstm\":\n self.result, both = self.node(input, (self.hidden, self.state))\n self.hidden, self.state = both\n else:\n self.result, self.hidden = self.node(input, self.hidden)\n\n # Pull the input from previous network layers\n elif self.result is None:\n in_result = []\n for n in self.input:\n in_result.append( n() )\n\n # Concatenate input along the dim input_size\n if self.G.ntype == \"lstm\":\n self.result, both = self.node(torch.cat(in_result, 2), (self.hidden, self.state))\n self.hidden, self.state = both\n else:\n self.result, self.hidden = self.node(torch.cat(in_result, 2), self.hidden)\n\n return self.result.view(*self.G.d_out)","def forward(self, prev_state, obs_t):\r\n # Use your network to compute qvalues for given state\r\n #print(state_t.shape)\r\n h = self.conv(obs_t)\r\n\r\n h = h.view(h.size(0), -1)\r\n\r\n new_state = h_new, c_new = self.lstm(h, prev_state)\r\n advantage = self.adv(h_new)\r\n value = self.val(h_new)\r\n\r\n\r\n adv_mean = torch.mean(advantage, dim=1, keepdim=True)\r\n qvalues = value + advantage - adv_mean\r\n\r\n return new_state, qvalues","def apply_lstm(x, seq_len):\n return cudnn_layers.stacked_bilstm(\n input_emb=x,\n input_len=seq_len,\n hidden_size=FLAGS.lstm_dim,\n num_layers=1,\n dropout_ratio=0.0,\n mode=tf_estimator.ModeKeys.TRAIN,\n use_cudnn=None)","def __init__(self, incoming, n_units,\n W_ci=tf.zeros, W_ig=tf.zeros, W_og=tf.zeros, W_fg=tf.zeros,\n b_ci=tf.zeros, b_ig=tf.zeros, b_og=tf.zeros, b_fg=tf.zeros,\n a_ci=tf.tanh, a_ig=tf.sigmoid, a_og=tf.sigmoid, a_fg=tf.sigmoid, a_out=tf.identity,\n c_init=tf.zeros, h_init=tf.zeros, learn_c_init=False, learn_h_init=False, forgetgate=True,\n output_dropout=False, store_states=False, return_states=False, precomp_fwds=False,\n tickerstep_biases=None, learn_tickerstep_biases=True, name='LSTM'):\n super(LSTMLayerGetNetInput, self).__init__()\n with tf.variable_scope(name) as self.layer_scope:\n self.incoming, self.incoming_shape = get_input(incoming)\n self.n_units = n_units\n self.lstm_inlets = ['ci', 'ig', 'og', 'fg']\n if return_states:\n store_states = True\n \n #\n # Initialize weights and biases\n #\n \n # Turn W inits into lists [forward_pass, backward_pass]\n W_ci, W_ig, W_og, W_fg = [v[:2] if isinstance(v, list) else [v, v] for v in [W_ci, W_ig, W_og, W_fg]]\n \n # Make W and b tf variables\n W_ci, W_ig, W_og, W_fg = [\n [tofov(v[0], shape=[self.incoming_shape[-1], n_units], var_params=dict(name=n + '_fwd')),\n tofov(v[1], shape=[n_units, n_units], var_params=dict(name=n + '_bwd'))]\n for v, n in zip([W_ci, W_ig, W_og, W_fg], ['W_ci', 'W_ig', 'W_og', 'W_fg'])]\n b_ci, b_ig, b_og, b_fg = [tofov(v, shape=[n_units], var_params=dict(name=n)) for v, n in\n zip([b_ci, b_ig, b_og, b_fg], ['b_ci', 'b_ig', 'b_og', 'b_fg'])]\n \n # Pack weights for fwd and bwd connections\n W_fwd_conc = tf.concat(axis=1, values=[W[0] for W in [W_ci, W_ig, W_og, W_fg]])\n W_bwd_conc = tf.concat(axis=1, values=[W[1] for W in [W_ci, W_ig, W_og, W_fg]])\n \n if not forgetgate:\n print(\"Warning: Setting forgetgate to 0 has not been tested yet, please set the W and b manually \"\n \"to not-trainable tensorflow variables!\")\n \n def a_fg(x):\n return tf.ones(x.get_shape().as_list())\n \n # Initialize bias for tickersteps\n if tickerstep_biases is not None:\n self.W_tickers = OrderedDict(zip_longest(self.lstm_inlets,\n [tofov(tickerstep_biases, shape=[n_units],\n var_params=dict(name='W_tickers_' + g,\n trainable=learn_tickerstep_biases))\n for g in self.lstm_inlets]))\n else:\n self.W_tickers = None\n \n #\n # Create mask for output dropout\n # apply dropout to n_units dimension of outputs, keeping dropout mask the same for all samples,\n # sequence positions, and pixel coordinates\n #\n output_shape = self.get_output_shape()\n if output_dropout:\n out_do_mask = tf.ones(shape=[output_shape[0], output_shape[-1]],\n dtype=tf.float32)\n out_do_mask = tf.nn.dropout(out_do_mask, keep_prob=1. - output_dropout,\n noise_shape=[1, output_shape[-1]])\n \n def out_do(x):\n \"\"\"Function for applying dropout mask to outputs\"\"\"\n if output_dropout:\n return out_do_mask * x\n else:\n return x\n \n # Redefine a_out to include dropout (sneaky, sneaky)\n a_out_nodropout = a_out\n \n def a_out(x):\n return a_out_nodropout(out_do(x))\n \n #\n # Handle initializations for h (hidden states) and c (cell states) as Variable\n #\n h_init = out_do(tofov(h_init, shape=[output_shape[0], output_shape[-1]],\n var_params=dict(name='h_init', trainable=learn_h_init)))\n c_init = tofov(c_init, shape=[output_shape[0], output_shape[-1]],\n var_params=dict(name='h_init', trainable=learn_c_init))\n \n # Initialize lists to store LSTM activations and cell states later\n h = [h_init]\n c = [c_init]\n \n self.precomp_fwds = precomp_fwds\n self.store_states = store_states\n self.return_states = return_states\n \n self.W_fwd = OrderedDict(zip(self.lstm_inlets, [W[0] for W in [W_ci, W_ig, W_og, W_fg]]))\n self.W_bwd = OrderedDict(zip(self.lstm_inlets, [W[1] for W in [W_ci, W_ig, W_og, W_fg]]))\n \n self.W_fwd_conc = W_fwd_conc\n self.W_bwd_conc = W_bwd_conc\n self.a = OrderedDict(zip(self.lstm_inlets, [a_ci, a_ig, a_og, a_fg]))\n self.a['out'] = a_out\n self.b = OrderedDict(zip(self.lstm_inlets, [b_ci, b_ig, b_og, b_fg]))\n self.h = h\n self.c = c\n self.external_rec = None\n \n self.ig = []\n self.og = []\n self.ci = []\n self.fg = []\n \n self.out = tf.expand_dims(h_init, 1)\n self.name = name\n \n self.cur_net_fwd = dot_product(tf.zeros(self.incoming_shape[:1] + self.incoming_shape[2:]),\n tf.zeros(self.W_fwd_conc.shape.as_list()))","def forward(self, x, hidden):\n emb_x = self.emb_layer(x)\n lstm_out, hidden = self.lstm(emb_x, hidden)\n if self.bidirectional:\n # separate to forward and backward\n # following code reshapes LSTM output to:\n # (batch size, seq length, num directions, hidden dimensions)\n # where direction '0' is forward and direction '1' is backward\n lstm_out = lstm_out.contiguous().view(-1, self.seq_len, 2, self.hidden_dim)\n # get backward output in first node\n lstm_out_bw = lstm_out[:, 0, 1, :]\n # get forward output in last node\n lstm_out_fw = lstm_out[:, -1, 0, :]\n # we may simple concatenate forward & backward outputs,\n # or add them, multiply or average; in this case i used average\n lstm_out = torch.add(input=lstm_out_bw, alpha=1, other=lstm_out_fw)\n lstm_out = torch.div(lstm_out, 2)\n else:\n lstm_out = lstm_out[:, -1]\n \n assert lstm_out.shape[-1] == self.hidden_dim, (lstm_out.shape, self.hidden_dim)\n lstm_out = lstm_out.contiguous().view(-1, self.hidden_dim)\n \n d_out = self.dropout(lstm_out)\n fc_out = self.output_layer(d_out)\n sig_out = torch.sigmoid(fc_out)\n \n # return last sigmoid output and hidden state\n return sig_out, hidden","def __init__(self, incoming, n_units,\n W_ci=tf.zeros, W_ig=tf.zeros, W_og=tf.zeros, W_fg=tf.zeros,\n b_ci=tf.zeros, b_ig=tf.zeros, b_og=tf.zeros, b_fg=tf.zeros,\n a_ci=tf.tanh, a_ig=tf.sigmoid, a_og=tf.sigmoid, a_fg=tf.sigmoid, a_out=tf.identity,\n c_init=tf.zeros, h_init=tf.zeros, learn_c_init=False, learn_h_init=False, forgetgate=True,\n output_dropout=False, store_states=False, return_states=False, precomp_fwds=False,\n tickerstep_biases=None, learn_tickerstep_biases=True, name='LSTM'):\n super(LSTMLayerSetNetInput, self).__init__()\n with tf.variable_scope(name) as self.layer_scope:\n self.incoming, self.incoming_shape = get_input(incoming)\n self.n_units = n_units\n self.lstm_inlets = ['ci', 'ig', 'og', 'fg']\n if return_states:\n store_states = True\n \n # Make W and b tf variables\n W_ci, W_ig, W_og, W_fg = [\n tofov(v, shape=[n_units, n_units], var_params=dict(name=n + '_bwd'))\n for v, n in zip([W_ci, W_ig, W_og, W_fg], ['W_ci', 'W_ig', 'W_og', 'W_fg'])]\n b_ci, b_ig, b_og, b_fg = [tofov(v, shape=[n_units], var_params=dict(name=n)) for v, n in\n zip([b_ci, b_ig, b_og, b_fg], ['b_ci', 'b_ig', 'b_og', 'b_fg'])]\n \n # Pack weights for bwd connections\n W_bwd_conc = tf.concat(axis=1, values=[W_ci, W_ig, W_og, W_fg])\n \n if not forgetgate:\n print(\"Warning: Setting forgetgate to 0 has not been tested yet, please set the W and b manually \"\n \"to not-trainable tensorflow variables!\")\n \n def a_fg(x):\n return tf.ones(x.get_shape().as_list())\n \n # Initialize bias for tickersteps\n if tickerstep_biases is not None:\n self.W_tickers = OrderedDict(zip_longest(self.lstm_inlets,\n [tofov(tickerstep_biases, shape=[n_units],\n var_params=dict(name='W_tickers_' + g,\n trainable=learn_tickerstep_biases))\n for g in self.lstm_inlets]))\n else:\n self.W_tickers = None\n \n #\n # Create mask for output dropout\n # apply dropout to n_units dimension of outputs, keeping dropout mask the same for all samples,\n # sequence positions, and pixel coordinates\n #\n output_shape = self.get_output_shape()\n if output_dropout:\n out_do_mask = tf.ones(shape=[output_shape[0], output_shape[-1]],\n dtype=tf.float32)\n out_do_mask = tf.nn.dropout(out_do_mask, keep_prob=1. - output_dropout,\n noise_shape=[1, output_shape[-1]])\n \n def out_do(x):\n \"\"\"Function for applying dropout mask to outputs\"\"\"\n if output_dropout:\n return out_do_mask * x\n else:\n return x\n \n # Redefine a_out to include dropout (sneaky, sneaky)\n a_out_nodropout = a_out\n \n def a_out(x):\n return a_out_nodropout(out_do(x))\n \n #\n # Handle initializations for h (hidden states) and c (cell states) as Variable\n #\n h_init = out_do(tofov(h_init, shape=[output_shape[0], output_shape[-1]],\n var_params=dict(name='h_init', trainable=learn_h_init)))\n c_init = tofov(c_init, shape=[output_shape[0], output_shape[-1]],\n var_params=dict(name='h_init', trainable=learn_c_init))\n \n # Initialize lists to store LSTM activations and cell states later\n h = [h_init]\n c = [c_init]\n \n self.precomp_fwds = precomp_fwds\n self.store_states = store_states\n self.return_states = return_states\n \n self.W_fwd = OrderedDict(zip(self.lstm_inlets, [None, None, None, None]))\n self.W_bwd = OrderedDict(zip(self.lstm_inlets, [W_ci, W_ig, W_og, W_fg]))\n \n self.W_fwd_conc = None\n self.W_bwd_conc = W_bwd_conc\n self.a = OrderedDict(zip(self.lstm_inlets, [a_ci, a_ig, a_og, a_fg]))\n self.a['out'] = a_out\n self.b = OrderedDict(zip(self.lstm_inlets, [b_ci, b_ig, b_og, b_fg]))\n self.h = h\n self.c = c\n self.external_rec = None\n \n self.ig = []\n self.og = []\n self.ci = []\n self.fg = []\n \n self.out = tf.expand_dims(h_init, 1)\n self.name = name","def forward(self, inputs, mode):\n self.hidden = self.init_hidden() \n\n if mode == 'a':\n\n embedding_word = self.embedding(inputs).view(self.embedding.shape.size())\n lstm_out, self.hidden = self.lstm_words(embedding_word.view(len(inputs), 1, -1), self.hidden)\n softmax_out = self.softmax(self.fc(lstm_out)) \n\n if mode == 'b':\n \n embed_chars = self.embedding_chars(inputs).view(self.embedding_chars.shape.size()) \n lstm_out_chars, self.hidden = self.lstm_chars(embed_chars.view(len(inputs), 1, -1),self.hidden) \n softmax_out = self.softmax(self.fc(lstm_out_chars))\n\n if mode == 'c': \n\n embedding_prefix = self.embeds_prefix(inputs[0]).view(self.embeds_prefix.shape.size())\n lstm_out_prefix, self.hidden = self.lstm_prefix(embedding_prefix.view(len(inputs[0]), 1, -1), self.hidden)\n embedding_suffix = self.embeds_suffix(inputs[1]).view(self.embeds_suffix.shape.size())\n lstm_out_suffix, self.hidden = self.lstm_suffix(embedding_suffix.view(len(inputs[1]), 1, -1), self.hidden)\n lstm_out = lstm_out_prefix+lstm_out_suffix\n softmax_out = self.softmax(self.fc(lstm_out)) \n\n if mode == 'd': \n\n embedding_c_words = self.embedding_concat_words(inputs[0]).view(self.embedding_concat_words.shape.size())\n embedding_c_chars = self.embedding_concat_chars(inputs[1]).view(self.embedding_concat_chars.shape.size())\n concat_input = torch.cat((embedding_c_words, embedding_c_chars),1)\n lstm_out, self.hidden = self.lstm_concat(concat_input.view(100 , 1, -1), self.hidden)\n softmax_out = self.softmax(self.fc(lstm_out)) \n\n return softmax_out, self.hidden","def LSTM_train(X_train, Y_train, X_dev, Y_dev, R_train, R_dev, hyperparams):","def forward(self, state):\n x = F.relu(self.input(state))\n for layer in self.layers:\n x = F.relu(layer(x))\n if self.duel:\n # Value function estimator\n val = F.relu(self.val_fc_input(x))\n val = self.val_fc_output(val)\n # Advantage function estimator\n adv = F.relu(self.adv_fc_input(x))\n adv = self.adv_fc_output(adv)\n # Subtract mean so that V and A are uniquely identifiable for a given Q\n return val + adv - adv.mean(1).unsqueeze(1).expand(state.size(0), self.action_size)\n else:\n return self.output(x)","def forward(self, inputs):\n # unpack\n x, lengths = pad_packed_sequence(inputs, batch_first=True)\n # x is (batch, slen)\n x = self.embed(x) # x is (batch, seq, dim_e)\n # but we need x to be (slen, batch, dim_e)\n x = x.transpose(0, 1)\n\n # rnn\n x = pack_padded_sequence(x, lengths, batch_first=False)\n x, (_, _) = self.lstm(x)\n # x is (slen, batch, num_directions * hidden_size)\n x, lengths = pad_packed_sequence(x, batch_first=False)\n # turn into batch first (batch, slen, num_dirs * hiddden)\n # and then (batch, num_dirs * hidden, slen)\n x = x.transpose(0, 1).transpose(1, 2)\n x = F.relu(x)\n x = F.max_pool1d(x, x.size(2)) # (batch, num_dirs * hidden, 1)\n x = x.squeeze(2)\n\n # do some dropout\n x = self.dropout(x)\n # map to classes\n x = self.output(x)\n return x","def forward(self, X, A, beta=1, print_output=False):\n assert X.size(0) == A.size(0) + 1, print('the seq length of X and A are wrong')\n kl_loss = 0 # KL divergence term\n Ell_loss = 0 # expected log likelihood term\n batch_size = X.size(1)\n\n if len(X.size()) != 3:\n print('The input data matrix should be the shape of [seq_length, batch_size, input_dim]')\n\n X = X.to(self.device)\n A = A.to(self.device)\n\n # container\n states = torch.zeros(A.size(0), A.size(1), self.state_size).to(self.device) # [seq-1, batch, state]\n rnn_hiddens = torch.zeros(A.size(0), A.size(1), self.hidden_size).to(self.device) # [seq-1, batch, hidden]\n\n # initialising state and rnn hidden state\n # state = torch.zeros(X.size(1), self.state_size).to(self.device)\n rnn_hidden = self.init_h(X[0]).to(self.device) # [batch, hidden]\n if self.mode == 'LSTM':\n rnn_hidden_c = torch.zeros_like(rnn_hidden).to(self.device) # [batch, hidden]\n\n # temp_prior = self.hidden_prior(rnn_hidden) #[batch, state]\n temp_prior = rnn_hidden\n prior_mean = self.prior_mean(temp_prior) # [batch, state]\n prior_sigma = torch.exp(self.prior_sigma(temp_prior)) # [batch, state]\n state = self.reparametrise(prior_mean, prior_sigma) # [batch, state]\n\n # rnn_hidden = torch.zeros(X.size(1), self.hidden_size).to(self.device)\n\n # emission_mean = X[0]\n for t in range(1, X.size()[\n 0]): # for each time step, compute the free energy for each batch of data (start from the second hid state)\n if self.mode == 'LSTM':\n next_state_prior_m, next_state_prior_sigma, rnn_hidden, rnn_hidden_c = self.prior(state,\n A[t - 1].unsqueeze(\n -1),\n rnn_hidden,\n rnn_hidden_c)\n else:\n next_state_prior_m, next_state_prior_sigma, rnn_hidden = self.prior(state, A[t - 1].unsqueeze(-1),\n rnn_hidden)\n\n next_state_post_m, next_state_post_sigma = self.posterior(rnn_hidden, X[t])\n state = self.reparametrise(next_state_post_m, next_state_post_sigma) # [batch, state_size]\n states[t - 1] = state\n rnn_hiddens[t - 1] = rnn_hidden\n next_state_prior = Normal(next_state_prior_m, next_state_prior_sigma)\n next_state_post = Normal(next_state_post_m, next_state_post_sigma)\n\n # kl = kl_divergence(next_state_prior, next_state_post).sum(dim=1) #[batch]\n kl = kl_divergence(next_state_post, next_state_prior).sum(dim=1) # [batch]\n\n kl_loss += kl.mean()\n kl_loss /= A.size(0)\n\n # compute nll\n\n # flatten state\n flatten_states = states.view(-1, self.state_size)\n flatten_rnn_hiddens = rnn_hiddens.view(-1, self.hidden_size)\n flatten_x_mean, flatten_x_sigma = self.obs_model(flatten_states, flatten_rnn_hiddens)\n\n nll = self.batched_gaussian_ll(flatten_x_mean, flatten_x_sigma, X[1:, :, :].reshape(-1, self.output_size))\n nll = nll.mean()\n\n FE = nll - kl_loss\n\n if print_output:\n # print('ELL loss=', Ell_loss, 'KL loss=', kl_loss)\n print('Free energy of this batch = {}. Nll loss = {}. KL div = {}.'.format(float(FE.data)\n , float(nll.data),\n float(kl_loss.data)))\n\n return FE, nll, kl_loss","def lstm_forward(x, h0, Wx, Wh, b):\n h, cache = None, None\n #############################################################################\n # TODO: Implement the forward pass for an LSTM over an entire timeseries. #\n # You should use the lstm_step_forward function that you just defined. #\n #############################################################################\n\n N,T,D = x.shape\n N,H = h0.shape\n prev_h = h0\n prev_c = np.zeros((N, H))\n\n h = np.zeros((N, T, H))\n cache = list()\n\n for t in range(T):\n next_h, next_c, t_cache = lstm_step_forward(x[:,t,:],prev_h,prev_c,Wx,Wh,b)\n prev_h = next_h\n prev_c = next_c\n h[:,t,:] = next_h\n cache.append(t_cache)\n ##############################################################################\n # END OF YOUR CODE #\n ##############################################################################\n\n return h, cache","def the_nn_article(input_size, dropout):\n \n class Model(nn.Module):\n def __init__(self):\n super(Model, self).__init__()\n \n # Defining layers\n self.hidden_size = 256\n self.first_layer = 512\n self.second_layer = 1024\n self.n_layers = 2\n self.bidirectional = True\n self.dropout = dropout\n \n # RNN Layer\n self.rnn = nn.LSTM(input_size = input_size, hidden_size = self.hidden_size, \n num_layers = self.n_layers, batch_first = True, \n bidirectional = self.bidirectional, dropout = self.dropout)\n \n self.fc1 = nn.Linear(self.first_layer, self.second_layer)\n self.fc2 = nn.Linear(self.second_layer, 3)\n \n def forward(self, x):\n batch_size = x.size(0)\n \n #Initializing hidden state for first input using method defined below\n hidden = self.init_hidden(batch_size, self.hidden_size)\n \n # Find sequence lengths (for packing)\n x_lengths = self.find_lengths(x)\n \n # Pack sequences\n x = torch.nn.utils.rnn.pack_padded_sequence(x, x_lengths, batch_first=True, enforce_sorted=False)\n\n # Run the network\n out, hidden = self.rnn(x, hidden)\n \n # Unpack the sequences again\n out, _ = torch.nn.utils.rnn.pad_packed_sequence(out, batch_first=True)\n\n # Run through the linear layer\n out = F.relu(self.fc1(out))\n out = F.relu(self.fc2(out))\n \n # Perform log_softmax on output (WORSE PERFORMANCE!)\n #x = F.log_softmax(x, dim = 2)\n\n return out, hidden\n \n def init_hidden(self, batch_size, hidden_size):\n # This method generates the first hidden state of zeros which we'll use in the forward pass\n \n hidden = (torch.zeros(2*self.n_layers, batch_size, self.hidden_size),\n torch.zeros(2*self.n_layers, batch_size, self.hidden_size))\n \n return hidden\n \n def find_lengths(self, input_seq):\n # Find seq-lengths of each sequence (used to pack sequences)\n x_lengths = []\n for seq in input_seq:\n for idx, vec in enumerate(seq):\n if sum(vec).item() != 1:\n x_lengths.append(idx)\n break\n if idx == 752:\n x_lengths.append(len(seq)) \n return x_lengths\n \n net = Model()\n return net","def forward(self, x):\n #delete all cts\n #self.cts = [self.cts[-1]]\n \n #forward\n length, batch, dim = x.shape\n res = []\n res.append(self.one_step(x[0], torch.zeros((batch, self.latent_size), dtype=torch.float)))\n\n for i in range(1,length):\n res.append(self.one_step(x[i], res[i-1]))\n\n return torch.stack(res)","def forward(self, x):\r\n out = self.conv(x) # out with shape\r\n out, _ = self.lstm(out.permute(2, 0, 1, 3, 4).contiguous().view(self.seq_len, -1, 64 * 1 * 4))\r\n out = torch.mean(out.permute(1, 0, 2), 1) # [batch, num_directions * hidden_size]\r\n if self.embed:\r\n return out\r\n else:\r\n logits = self.linear(out)\r\n return logits, out","def __init__(self, input_dim, hidden_dim, output_dim):\r\n super(LstmEstimator, self).__init__()\r\n \r\n # The LSTM takes track features as inputs, and outputs hidden states\r\n # with dimensionality hidden_dim\r\n self.lstm = nn.LSTM(input_dim, hidden_dim)\r\n \r\n self.hidden2target = nn.Linear(hidden_dim, output_dim)","def forward_trajectory(self,x0,U,predictive_var = False):\n ns = np.shape(x0)[0]\n nu, T = np.shape(U) \n \n x_ii = x0.T\n \n \n \n \n grad_state = np.zeros((T,ns,ns))\n grad_control = np.zeros((T,ns,nu))\n states = np.zeros((T,ns))\n variances = np.zeros((T,ns))\n\n\n for ii in range(T):\n \n #state_action = x_ii\n state_action = np.append(x_ii,U[:,ii]).reshape((1,-1))\n print(np.shape(state_action))\n\n \n if predictive_var:\n new_state_grads,new_state,new_state_var = self.predictive_gradients(state_action,predictive_var = True)\n variances[ii] = new_state_var\n else:\n \n new_state_grads,new_state = self.predictive_gradients(state_action,predictive_var = False)\n print(new_state_grads)\n print(new_state)\n grad_state[ii,:,:] = new_state_grads[:,np.arange(ns)]\n grad_control[ii,:,:] = new_state_grads[:,np.arange(ns+1,ns+nu)]\n\n states[ii,:] = new_state\n\n x_ii = new_state.T\n \n if predictive_var:\n return grad_state,grad_control,states,variances\n \n return grad_state,grad_control,states","def __call__(self, inputs, state):\n with tf.variable_scope(\"BayesLSTMCell\"):\n if self.w is None:\n\n# size = inputs.get_shape()[-1].value\n \n print ([\"------- Size input LSTM: \", inputs.shape])\n print ([\"------- Dim input specified \", self.X_dim])\n# print ([\"num units LSTM: \", self.num_units])\n \n self.w = VI.sample_posterior((self.X_dim + self.num_units, 4 * self.num_units),\n name=self.n + \"_weights\",\n prior=self.prior,\n is_training=self.is_training)\n \n self.b = VI.sample_posterior((4 * self.num_units, 1),\n name=self.n + \"_biases\",\n prior=self.prior,\n is_training=self.is_training)\n\n # Get the cell and hidden state from the previous cell [C_t-1, h_t-1]\n C_t_prev , h_t_prev = state\n #Vector concatenation of previous hidden state and embedded inputs\n concat_inputs_hidden = tf.concat([inputs, h_t_prev], 1)\n # Compute the Z = Wx + b for each of the 4 networks at once !\n gate_inputs = tf.nn.bias_add(tf.matmul(concat_inputs_hidden, self.w), tf.squeeze(self.b))\n \n # Split data up for the 4 gates\n # i = input_gate, j = new_input, f = forget_gate, o = output_gate\n i, j, f, o = tf.split(value=gate_inputs, num_or_size_splits=4, axis=1)\n\n # Compute the new cell \n C_t = (C_t_prev * tf.sigmoid(f + self._forget_bias) + tf.sigmoid(i)*self._activation(j))\n h_t = self._activation(C_t) * tf.sigmoid(o)\n \n #Create tuple of the new state\n State_t = LSTMStateTuple(C_t, h_t)\n\n return h_t, State_t","def forward(self, state):\r\n x = F.relu(self.linear1(state))\r\n x = F.relu(self.linear2(x))\r\n #x = torch.tanh(self.linear3(x))\r\n #x = F.relu(self.linear3(x))\r\n #x = nn.LeakyReLU(self.linear3(x), negative_slope=0.1)# .negativ_slope nur für leakyReLU relevant\r\n x = F.leaky_relu(self.linear3(x), 0.1)\r\n #x = F.softmax(self.linear3(x), dim=0)\r\n \r\n return x#.negativ_slope","def forward(self, X, X_lens):\n\n\t\t# get the batch size and sequence length (max length of the batch)\n\t\t# dim of X: batch_size x batch_max_len x input feature vec dim\n\t\tbatch_size, seq_len, _ = X.size()\n\n\t\t###Your code here --\n\t\t# Get the output of LSTM - (output dim: batch_size x batch_max_len x lstm_hidden_dim)\n\t\thid, _ = self.lstm(X)\n\t\t# print('hid \\n{}'.format(hid))\n\n\t\t# reshape (before passing to linear layer) so that each row contains one token\n\t\t# essentially, flatten the output of LSTM\n\t\t# dim will become batch_size*batch_max_len x lstm_hidden_dim\n\t\thid_flat = hid.contiguous().view(hid.shape[0] * hid.shape[1], hid.shape[2])\n\t\t# print('hid_flat \\n{}'.format(hid_flat))\n\n\t\t# Get logits from the final linear layer\n\t\tlogits = self.hidden_to_label(hid_flat)\n\t\t# print('logits \\n {}'.format(logits))\n\t\t# print('logits shape {}, hid shape {}, hid_flat shape {}'.format(logits.shape, hid.shape, hid_flat.shape))\n\t\t# --shape of logits -> (batch_size, seq_len, self.n_output)\n\t\treturn logits","def __init__(self, incoming, n_units, W_ci, W_ig, W_og, W_fg,\n b_ci=tf.zeros, b_ig=tf.zeros, b_og=tf.zeros, b_fg=tf.zeros,\n a_ci=tf.tanh, a_ig=tf.sigmoid, a_og=tf.sigmoid, a_fg=tf.sigmoid, a_out=tf.nn.elu,\n c_init=tf.zeros, h_init=tf.zeros, learn_c_init=False, learn_h_init=False, forgetgate=True, comb='add',\n store_states=False, return_states=False, output_dropout=False, precomp_fwds=True, W_red_rec=None,\n a_reduce_recurrents=None, tickerstep_biases=None, learn_tickerstep_biases=True,\n dilation_rate=(1, 1), name='ConvLSTMLayer'):\n super(ConvLSTMLayer, self).__init__()\n with tf.variable_scope(name) as self.layer_scope:\n self.incoming, self.incoming_shape = get_input(incoming)\n self.n_units = n_units\n self.lstm_inlets = ['ci', 'ig', 'og', 'fg']\n if return_states:\n store_states = True\n \n #\n # Initialize weights and biases\n #\n \n # Turn W inits into lists [forward_pass, backward_pass]\n W_ci, W_ig, W_og, W_fg = [v[:2] if isinstance(v, list) else [v, v] for v in [W_ci, W_ig, W_og, W_fg]]\n \n # Check if feature dimensions to produce agree for all weight windows with n_units\n W_dims = [[w[0].get_shape().as_list()[3], w[1].get_shape().as_list()[3]] for w in [W_ci, W_ig, W_og, W_fg]]\n W_dims = np.array(W_dims).flatten()\n if np.any(W_dims != n_units):\n raise ValueError(\"Feature dimensions to produce must agree with n_units!\")\n \n # TODO: make all gates optional (list with keys and function for splitting)\n if not forgetgate:\n def a_fg(x):\n return tf.ones(x.get_shape().as_list())\n \n # Make W and b tf variables\n W_ci, W_ig, W_og, W_fg = [[tofov(w, shape=None, var_params=dict(name=n + suffix)) for w, suffix in\n zip(v, ['_fwd', '_bwd'])] for v, n in\n zip([W_ci, W_ig, W_og, W_fg], ['W_ci', 'W_ig', 'W_og', 'W_fg'])]\n b_ci, b_ig, b_og, b_fg = [tofov(b, shape=[n_units], var_params=dict(name=n)) for b, n in\n zip([b_ci, b_ig, b_og, b_fg], ['b_ci', 'b_ig', 'b_og', 'b_fg'])]\n \n # Pack weights for fwd and bwd connections by concatenating them at sliding mask feature dimension\n # TODO: enable parallel calculation on multi-gpu\n W_fwd_conc = tf.concat(axis=3, values=[W[0] for W in [W_ci, W_ig, W_og, W_fg]], name='W_fwd_conc')\n W_bwd_conc = tf.concat(axis=3, values=[W[1] for W in [W_ci, W_ig, W_og, W_fg]], name='W_bwd_conc')\n \n # Initialize kernel for reducing recurrent features\n self.reduce_recurrents = None\n self.W_red_rec = W_red_rec\n if a_reduce_recurrents is not None:\n self.W_red_rec = tofov(W_red_rec, var_params=dict(name='W_red_rec'))\n \n def reduce_recurrents(h_prev):\n \"\"\"Reduces features of internal recurrent connections h_prev\"\"\"\n return a_reduce_recurrents(conv2d(h_prev, self.W_red_rec))\n \n self.reduce_recurrents = reduce_recurrents\n \n # Initialize bias for tickersteps\n if tickerstep_biases is not None:\n self.W_tickers = OrderedDict(zip_longest(self.lstm_inlets,\n [tofov(tickerstep_biases, shape=[n_units],\n var_params=dict(name='W_tickers_' + g,\n trainable=learn_tickerstep_biases))\n for g in self.lstm_inlets]))\n else:\n self.W_tickers = None\n \n #\n # Create mask for output dropout\n # apply dropout to n_units dimension of outputs, keeping dropout mask the same for all samples,\n # sequence positions, and pixel coordinates\n #\n output_shape = self.get_output_shape()\n if output_dropout:\n out_do_mask = tf.ones(shape=[output_shape[0], output_shape[2], output_shape[3], output_shape[4]],\n dtype=tf.float32, name='out_do_mask')\n out_do_mask = tf.nn.dropout(out_do_mask, keep_prob=1. - output_dropout,\n noise_shape=[1, 1, 1, output_shape[4]])\n \n def out_do(x):\n \"\"\"Function for applying dropout mask to outputs\"\"\"\n if output_dropout:\n return out_do_mask * x\n else:\n return x\n \n # Redefine a_out to include dropout (sneaky, sneaky)\n a_out_nodropout = a_out\n \n def a_out(x):\n return a_out_nodropout(out_do(x))\n \n #\n # Handle initializations for h (outputs) and c (cell states) as Variable if overwriteable or tensor if not\n # shape=(samples, x, y, n_units)\n #\n h_init = out_do(tofov(h_init, shape=[output_shape[0], output_shape[2], output_shape[3], output_shape[4]],\n var_params=dict(trainable=learn_h_init)))\n c_init = tofov(c_init, shape=[output_shape[0], output_shape[2], output_shape[3], output_shape[4]],\n var_params=dict(trainable=learn_c_init))\n \n # Initialize lists to store LSTM activations and cell states\n h = [h_init] # [-1, x, y, n_units]\n c = [c_init] # [-1, x, y, n_units]\n \n self.precomp_fwds = precomp_fwds\n self.store_states = store_states\n self.return_states = return_states\n \n self.W_fwd = OrderedDict(zip(self.lstm_inlets, [W[0] for W in [W_ci, W_ig, W_og, W_fg]]))\n self.W_bwd = OrderedDict(zip(self.lstm_inlets, [W[1] for W in [W_ci, W_ig, W_og, W_fg]]))\n \n self.W_fwd_conc = W_fwd_conc\n self.W_bwd_conc = W_bwd_conc\n self.a = OrderedDict(ci=a_ci, ig=a_ig, og=a_og, fg=a_fg, out=a_out)\n self.b = OrderedDict(ci=b_ci, ig=b_ig, og=b_og, fg=b_fg)\n self.h = h\n self.c = c\n self.comb = comb\n self.max_seq_len = None\n self.external_rec = None\n \n self.dilation_rate = dilation_rate\n \n self.out = tf.expand_dims(h_init, 1)\n self.name = name","def forward(self, inputs):\n batch_size = len(inputs.batch_sizes)\n # unpack\n x, lengths = pad_packed_sequence(inputs, batch_first=True)\n # x is (batch, slen)\n batch_size = x.size(0)\n x = self.embed(x) # x is (batch, seq, dim_e)\n # but we need x to be (slen, batch, dim_e)\n x = x.transpose(0, 1)\n\n # rnn\n x = pack_padded_sequence(x, lengths, batch_first=False)\n _, (x, _) = self.lstm(x) # we want x=$h_(t=slen)$ (last hidden output)\n # we have x as (num_directions=2, batch, hidden)\n # we transpose it to (batch, num_direction, hidden)\n # than we view it as (batch, 1, hidden * 2) and finally we\n # squeeze it to (batch, hidden * 2) because we wanted to have\n # the directions concatenated as a single feature vector (per input)\n x = x.transpose(0, 1).contiguous().view(batch_size, 1, -1).squeeze(1)\n # we need to have squeeze(dim=1) because of the batch_size=1 case\n\n # do some dropout\n x = self.dropout(x)\n # map to classes\n x = self.output(x)\n return x","def forward(self, input: torch.Tensor) -> torch.Tensor:\n x = input\n for block in self.blocks:\n x = block(x)\n x = self.final_linear(x.flatten(1))\n\n return x","def forward_train(self, *args, **kwargs):\n pass","def forward(self, state):\n #pass\n #forward through each layer in \"hidden layer\", with ReLU activation unit between them\n for linear in self.hidden_layers:\n state = F.relu(linear(state))\n \n state = self.output(state)\n return state#F.log_softmax(state, dim=1)","def forward(self, sequence):\n\n seq_len = len(sequence)\n batch_size = sequence[0].size(0)\n state_fwd = self.fwd_rnn.init_state(batch_size, [self.height, self.width])\n state_bwd = self.bwd_rnn.init_state(batch_size, [self.height, self.width])\n\n outputs_fwd = []\n outputs_bwd = []\n for t in range(seq_len):\n t_fwd, t_bwd = t, seq_len - t - 1\n output_fwd, state_fwd = self.fwd_rnn(sequence[t_fwd], state_fwd)\n output_bwd, state_bwd = self.bwd_rnn(sequence[t_bwd], state_bwd)\n\n outputs_fwd += [output_fwd]\n outputs_bwd += [output_bwd]\n\n outputs_bwd.reverse()\n output = [torch.cat([outputs_fwd[t], outputs_bwd[t]], dim=1) for t in range(seq_len)]\n\n return output","def forward(self, inputs):\n # unpack\n x, lengths = pad_packed_sequence(inputs, batch_first=True)\n # x is (batch, slen)\n x = embedded_dropout(self.embed, x,\n dropout=self.dropout_e if self.training else 0)\n # x is (batch, seq, dim_e)\n # but we need x to be (slen, batch, dim_e)\n x = x.transpose(0, 1)\n\n # rnn\n x = pack_padded_sequence(x, lengths, batch_first=False)\n x, (_, _) = self.lstm(x)\n # x is (slen, batch, num_directions * hidden_size)\n x, lengths = pad_packed_sequence(x, batch_first=False)\n rnn_out = x\n # turn into batch first (batch, slen, num_dirs * hiddden)\n # and then (batch, num_dirs * hidden, slen)\n x = x.transpose(0, 1).transpose(1, 2)\n x = F.relu(x)\n x = F.max_pool1d(x, x.size(2)) # (batch, num_dirs * hidden, 1)\n x = x.squeeze(2)\n\n # do some dropout\n x = self.dropout(x)\n # map to classes\n x = self.output(x)\n return x, rnn_out","def forward(self, state):\n x = state\n for layer in self.linear_layers[:-1]:\n x = F.relu(layer(x))\n x = self.linear_layers[-1](x)\n return x","def relu_forward_hook_function(module, ten_in, ten_out):\n self.forward_relu_outputs.append(ten_out)","def relu_forward_hook_function(module, ten_in, ten_out):\n self.forward_relu_outputs.append(ten_out)","def relu_forward_hook_function(module, ten_in, ten_out):\n self.forward_relu_outputs.append(ten_out)","def relu_forward_hook_function(module, ten_in, ten_out):\n self.forward_relu_outputs.append(ten_out)","def relu_forward_hook_function(module, ten_in, ten_out):\n self.forward_relu_outputs.append(ten_out)","def model_RNN(x_train, y_train, x_test=None, y_test=None, kwargs={}):\n \"\"\"\n Notes on Input shape\n 3D tensor with shape (batch_size, timesteps, input_dim).\n https://keras.io/layers/recurrent/\n LSTMs in Keras are typically used on 3d data (batch dimension, timesteps, features).\n LSTM without return_sequences will output (batch dimension, output features)\n LSTM with return_sequences will output (batch dimension, timesteps, output features)\n Basic timeseries data has an input shape (number of sequences, steps, features). Target is (number of sequences, steps, targets). Use an LSTM with return_sequences.\n \"\"\"\n ######## RELU??? DropOut\n # create and fit the LSTM network\n # input_shape = Lookback x Features\n verbose = kwargs.get('verbose',False)\n layers = kwargs.get('layers', 1 )\n nodes = kwargs.get('nodes', None)\n\n if nodes is None or nodes==0 or nodes==[0]:\n nodes = [np.shape(x_train)[1]]\n elif isinstance(nodes, (int, np.integer)): # turn int to list\n nodes = [nodes]\n\n if layers > 1 and len(nodes) < layers:\n nodes = list(np.pad(nodes,[0,layers-len(nodes)], mode='constant',constant_values=nodes[-1]))\n\n ndim = np.max([2,len(np.shape(x_train))]) # Min 2D\n if ndim==2:\n input_shape=(x_train.shape[1],)\n else:\n input_shape=(x_train.shape[1],x_train.shape[2])\n if kwargs.get('learning_rate', False):\n lr = kwargs.get('learning_rate')\n else:\n lr = False\n\n if np.ndim(y_train)==1:\n n_out = 1 #e.g. forecast y as float, just 1 step ahead.\n else:\n n_out = np.shape(y_train)[1] #e.g. onehot encoded, or n-steps ahead.\n\n dropout = kwargs.get('dropout',0) # dropout rate between 0 and 1.\n stateful = kwargs.get('stateful',True)\n if stateful: #RNN needs fixed batch - consider using static_index\n batch_shape = (kwargs.get('batch_size',1234),) + input_shape\n actvn = kwargs.get('actvn','tanh')\n actvl = kwargs.get('actvl','sigmoid')\n if verbose and not actvn == 'tanh': print('tanh activation recommended for LSTM but you are using',actvn)\n\n model=[]\n model = Sequential() # https://keras.io/models/sequential/\n model.reset_states() # ?useful for batch training RNN... perhaps inside batched loop\n #TODO? model.add(Embedding(max_features, output_dim=n_out))\n\n if layers>1:\n for n in range(1,layers):\n if kwargs.get('verbose'): print('+adding extra layer')\n if stateful: #switch between batch_ and input_shape\n model.add(LSTM(nodes[layers-1], batch_input_shape=batch_shape, return_sequences=True, activation=actvn, stateful=stateful))\n else:\n model.add(LSTM(nodes[layers-1], input_shape=input_shape, return_sequences=True, activation=actvn, stateful=stateful))\n if kwargs.get('bnorm', False):\n model.add(keras.layers.normalization.BatchNormalization())\n # TODO find out about time lock dropout\n if dropout:\n model.add(Dropout(dropout)) #(c.f. Regularisation of Betas)\n\n # Single layer or last layer of RNN\n if stateful:\n model.add(LSTM(nodes[layers-1], batch_input_shape=batch_shape, return_sequences=False, activation=actvn, stateful=stateful))\n else:\n model.add(LSTM(nodes[layers-1], input_shape=input_shape, return_sequences=False, activation=actvn, stateful=stateful))\n\n #model.add(Flatten()) # Req'd if last layer return_sequences=True\n #model.add(Dense(nodes[layers-1]**2, activation=actvl))\n model.add(Dense(n_out, activation=actvl))\n\n #defaults = keras.optimizers.Nadam(lr=0.002, beta_1=0.9, beta_2=0.999, epsilon=None, schedule_decay=0.004)\n if hasattr(kwargs,'optimizer'):\n optimizer = kwargs['optimizer']\n elif lr:\n optimizer = keras.optimizers.Nadam(lr=lr, beta_1=0.9, beta_2=0.999, epsilon=1e-8, schedule_decay=0.004)\n else:\n optimizer = keras.optimizers.Nadam(lr=0.002, beta_1=0.9, beta_2=0.999, epsilon=1e-8,schedule_decay=0.004)\n optimizer = 'adam'\n\n if is_bool_dtype(y_train):\n model.compile(loss='binary_crossentropy', optimizer=optimizer)\n if is_categorical_dtype(y_train) or kwargs.get('onehot',False):\n #TODO Multiple Category\n model.compile(loss='categorical_crossentropy', optimizer=optimizer)\n else:\n model.compile(loss='mean_squared_error', optimizer=optimizer)\n\n if verbose > 1:\n model.summary()\n print(\"Inputs: {}\".format(model.input_shape))\n print(\"Outputs: {}\".format(model.output_shape))\n print(\"Actual input: {}\".format(x_train.shape))\n print(\"Actual output: {}\".format(y_train.shape))\n print('Model Loss: ' + model.loss)\n\n # For compatability with other models;\n model.score = model.evaluate\n\n return model #self.model=model","def bi_lstm(X_inputs):\n # X_inputs.shape = [batchsize, timestep_size] -> inputs.shape = [batchsize, timestep_size, embedding_size]\n log(\"embedding\")\n log(embedding)\n log(X_inputs)\n log(\"X_inputs\")\n inputs = tf.nn.embedding_lookup(embedding, X_inputs) \n \n # ** 1.构建前向后向多层 LSTM\n cell_fw = rnn.MultiRNNCell([lstm_cell() for _ in range(layer_num)], state_is_tuple=True)\n cell_bw = rnn.MultiRNNCell([lstm_cell() for _ in range(layer_num)], state_is_tuple=True)\n \n # ** 2.初始状态\n initial_state_fw = cell_fw.zero_state(batch_size, tf.float32)\n initial_state_bw = cell_bw.zero_state(batch_size, tf.float32) \n \n # 下面两部分是等价的\n # **************************************************************\n # ** 把 inputs 处理成 rnn.static_bidirectional_rnn 的要求形式\n # ** 文档说明\n # inputs: A length T list of inputs, each a tensor of shape\n # [batch_size, input_size], or a nested tuple of such elements.\n # *************************************************************\n # Unstack to get a list of 'n_steps' tensors of shape (batch_size, n_input)\n # inputs.shape = [batchsize, timestep_size, embedding_size] -> timestep_size tensor, each_tensor.shape = [batchsize, embedding_size]\n # inputs = tf.unstack(inputs, timestep_size, 1)\n # ** 3.bi-lstm 计算（tf封装） 一般采用下面 static_bidirectional_rnn 函数调用。\n # 但是为了理解计算的细节，所以把后面的这段代码进行展开自己实现了一遍。\n# try:\n# outputs, _, _ = rnn.static_bidirectional_rnn(cell_fw, cell_bw, inputs, \n# initial_state_fw = initial_state_fw, initial_state_bw = initial_state_bw, dtype=tf.float32)\n# except Exception: # Old TensorFlow version only returns outputs not states\n# outputs = rnn.static_bidirectional_rnn(cell_fw, cell_bw, inputs, \n# initial_state_fw = initial_state_fw, initial_state_bw = initial_state_bw, dtype=tf.float32)\n# output = tf.reshape(tf.concat(outputs, 1), [-1, hidden_size * 2])\n # ***********************************************************\n \n # ***********************************************************\n # ** 3. bi-lstm 计算（展开）\n with tf.variable_scope('bidirectional_rnn'):\n # *** 下面，两个网络是分别计算 output 和 state \n # Forward direction\n outputs_fw = list()\n state_fw = initial_state_fw\n with tf.variable_scope('fw'):\n for timestep in range(timestep_size):\n if timestep > 0:\n tf.get_variable_scope().reuse_variables()\n (output_fw, state_fw) = cell_fw(inputs[:, timestep, :], state_fw)\n outputs_fw.append(output_fw)\n \n # backward direction\n outputs_bw = list()\n state_bw = initial_state_bw\n with tf.variable_scope('bw') as bw_scope:\n inputs = tf.reverse(inputs, [1])\n for timestep in range(timestep_size):\n if timestep > 0:\n tf.get_variable_scope().reuse_variables()\n (output_bw, state_bw) = cell_bw(inputs[:, timestep, :], state_bw)\n outputs_bw.append(output_bw)\n # *** 然后把 output_bw 在 timestep 维度进行翻转\n # outputs_bw.shape = [timestep_size, batch_size, hidden_size]\n outputs_bw = tf.reverse(outputs_bw, [0])\n # 把两个oupputs 拼成 [timestep_size, batch_size, hidden_size*2]\n output = tf.concat([outputs_fw, outputs_bw], 2)\n output = tf.transpose(output, perm=[1,0,2])\n output = tf.reshape(output, [-1, hidden_size*2])\n # ***********************************************************\n return output # [-1, hidden_size*2]","def set_model(self, n_lstm_layers=3, n_lstm_nodes=150, n_dense_1=1, n_nodes_dense_1=300, n_dense_2=4, n_nodes_dense_2=200, dropout_rate=0.1, learning_rate=0.001, batch_norm=True, batch_momentum=0.99):\n\n input_objects = keras.layers.Input(shape=(len(self.low_level_vars), len(self.low_level_vars[0])), name='input_objects') \n input_global = keras.layers.Input(shape=(len(self.high_level_vars),), name='input_global')\n lstm = input_objects\n decay = 0.2\n for i_layer in range(n_lstm_layers):\n #lstm = keras.layers.LSTM(n_lstm_nodes, activation='tanh', kernel_regularizer=keras.regularizers.l2(decay), recurrent_regularizer=keras.regularizers.l2(decay), bias_regularizer=keras.regularizers.l2(decay), return_sequences=(i_layer!=(n_lstm_layers-1)), name='lstm_{}'.format(i_layer))(lstm)\n lstm = keras.layers.LSTM(n_lstm_nodes, activation='tanh', return_sequences=(i_layer!=(n_lstm_layers-1)), name='lstm_{}'.format(i_layer))(lstm)\n\n #inputs to dense layers are output of lstm and global-event variables. Also batch norm the FC layers\n dense = keras.layers.concatenate([input_global, lstm])\n for i in range(n_dense_1):\n dense = keras.layers.Dense(n_nodes_dense_1, activation='relu', kernel_initializer='he_uniform', name = 'dense1_%d' % i)(dense)\n if batch_norm:\n dense = keras.layers.BatchNormalization(name = 'dense_batch_norm1_%d' % i)(dense)\n dense = keras.layers.Dropout(rate = dropout_rate, name = 'dense_dropout1_%d' % i)(dense)\n\n for i in range(n_dense_2):\n dense = keras.layers.Dense(n_nodes_dense_2, activation='relu', kernel_initializer='he_uniform', name = 'dense2_%d' % i)(dense)\n #add droput and norm if not on last layer\n if batch_norm and i < (n_dense_2 - 1):\n dense = keras.layers.BatchNormalization(name = 'dense_batch_norm2_%d' % i)(dense) \n if i < (n_dense_2 - 1):\n dense = keras.layers.Dropout(rate = dropout_rate, name = 'dense_dropout2_%d' % i)(dense)\n\n output = keras.layers.Dense(1, activation = 'sigmoid', name = 'output')(dense)\n #optimiser = keras.optimizers.Nadam(lr = learning_rate)\n optimiser = keras.optimizers.Adam(lr = learning_rate)\n\n model = keras.models.Model(inputs = [input_global, input_objects], outputs = [output])\n model.compile(optimizer = optimiser, loss = 'binary_crossentropy')\n self.model = model","def forward(self, x):\n # x = state\n \n x = F.relu(self.input(x))\n x = self.output(x)\n \n return x","def _lstm_unroll_base(num_lstm_layer, seq_len, num_hidden):\n param_cells = []\n last_states = []\n for i in range(num_lstm_layer):\n param_cells.append(LSTMParam(i2h_weight=mx.sym.Variable(\"l%d_i2h_weight\" % i),\n i2h_bias=mx.sym.Variable(\"l%d_i2h_bias\" % i),\n h2h_weight=mx.sym.Variable(\"l%d_h2h_weight\" % i),\n h2h_bias=mx.sym.Variable(\"l%d_h2h_bias\" % i)))\n state = LSTMState(c=mx.sym.Variable(\"l%d_init_c\" % i),\n h=mx.sym.Variable(\"l%d_init_h\" % i))\n last_states.append(state)\n assert len(last_states) == num_lstm_layer\n\n # embedding layer\n data = mx.sym.Variable('data')\n wordvec = mx.sym.SliceChannel(data=data, num_outputs=seq_len, squeeze_axis=1)\n\n hidden_all = []\n for seqidx in range(seq_len):\n hidden = wordvec[seqidx]\n for i in range(num_lstm_layer):\n next_state = _lstm(\n num_hidden=num_hidden,\n indata=hidden,\n prev_state=last_states[i],\n param=param_cells[i],\n seqidx=seqidx,\n layeridx=i)\n hidden = next_state.h\n last_states[i] = next_state\n hidden_all.append(hidden)\n\n hidden_concat = mx.sym.Concat(*hidden_all, dim=0)\n pred_fc = mx.sym.FullyConnected(data=hidden_concat, num_hidden=11, name=\"pred_fc\")\n return pred_fc","def forward_tensor(self, x):\n pass","def forward(self, input_tensor):\n rv = torch.randn(input_tensor.size(), device=self.device) * 0.02\n intermediate = input_tensor + rv\n for module in self.down:\n intermediate = module(intermediate)\n rv = torch.randn(intermediate.size(), device=self.device) * 0.02 + 1\n intermediate *= rv\n\n intermediate = intermediate.view(-1, self.width)\n\n for module in self.classifier:\n intermediate = module(intermediate)\n\n return intermediate","def forward(self, x):\n\n def run0(x, dummy):\n lout1 = self.lconv1(x)\n out1 = self.conv1(lout1)\n lout2 = self.lconv2(out1 + lout1)\n out2 = self.conv2(lout2)\n lout3 = self.lconv3(out2 + lout2)\n out3 = self.conv3(lout3)\n lout4 = self.lconv4(out3 + lout3)\n out4 = self.conv4(lout4)\n lout5 = self.lconv5(out4 + lout4)\n out5 = self.conv5(lout5)\n lout6 = self.lconv6(out5 + lout5)\n out6 = self.conv6(lout6)\n lout7 = self.lconv7(out6 + lout6)\n out7 = self.conv7(lout7)\n mat = out7[:, :, :, None] + out7[:, :, None, :]\n cur = mat\n if self.num_1d:\n output1d = self.final_1d(out7)\n return cur, output1d\n else:\n return cur\n\n dummy = torch.Tensor(1)\n dummy.requires_grad = True\n if self.num_1d:\n cur, output1d = checkpoint(run0, x, dummy)\n else:\n cur = checkpoint(run0, x, dummy)\n\n def run1(cur):\n first = True\n for lm, m in zip(self.lconvtwos[:7], self.convtwos[:7]):\n if first:\n cur = lm(cur)\n\n first = False\n else:\n cur = lm(cur) + cur\n cur = m(cur) + cur\n return cur\n\n def run2(cur):\n for lm, m in zip(self.lconvtwos[7:13], self.convtwos[7:13]):\n cur = lm(cur) + cur\n cur = m(cur) + cur\n return cur\n\n def run3(cur):\n for lm, m in zip(self.lconvtwos[13:], self.convtwos[13:]):\n cur = lm(cur) + cur\n cur = m(cur) + cur\n\n cur = self.final(cur)\n cur = 0.5 * cur + 0.5 * cur.transpose(2, 3)\n return cur\n\n cur = checkpoint(run1, cur)\n cur = checkpoint(run2, cur)\n cur = checkpoint(run3, cur)\n\n if self.num_1d:\n return cur, output1d\n else:\n return cur","def forward(self, state, action): \n ##x = F.relu(self.fc1(state)) \n x = F.relu(self.bn1(self.fc1(state))) \n x = torch.cat([x, action], dim=1)\n x = F.relu(self.fc2(x))\n x = self.fc3(x)\n return x","def lstm_step_backward(dnext_h, dnext_c, cache):\n dx, dh, dc, dWx, dWh, db = None, None, None, None, None, None\n #############################################################################\n # TODO: Implement the backward pass for a single timestep of an LSTM. #\n # #\n # HINT: For sigmoid and tanh you can compute local derivatives in terms of #\n # the output value from the nonlinearity. #\n #############################################################################\n\n x, i, f, o, g, prev_h, next_h, prev_c, next_c, Wx, Wh, b = cache\n\n #next_h = o * tanh(next_c)\n #next_c = f *prev_c + i*g\n # derivative of next_c with respect to h\n tanh_nc = np.tanh(next_c)\n dnext_c_h = (1- tanh_nc*tanh_nc) *o*dnext_h\n dc = dnext_c_h + dnext_c\n di = g * dc\n df = prev_c * dc\n do = np.tanh(next_c) * dnext_h\n dg = i * dc\n\n # i = sigmoid(z) -> dz = (1-i)(i) di; di is the\n dz_i = (1-i)*(i) * di\n dz_f = (1-f)*(f) * df\n dz_o = (1-o)*(o) * do\n dz_g = (1-g*g) * dg\n\n dz = np.hstack((dz_i,dz_f,dz_o,dz_g)).T\n\n dx = np.dot(Wx, dz).T\n dprev_h = np.dot(Wh,dz).T\n dprev_c = f * dc\n dWx = np.dot(dz, x).T\n dWh = np.dot(dz, prev_h).T\n db = np.sum(dz, axis=1)\n\n ##############################################################################\n # END OF YOUR CODE #\n ##############################################################################\n return dx, dprev_h, dprev_c, dWx, dWh, db","def apply_highway_lstm(x, seq_len):\n lstm_out = apply_lstm(x, seq_len)\n proj = ops.affine(x, FLAGS.lstm_dim * 4, \"w\", bias_name=\"b\")\n gate, transform = tf.split(proj, 2, 2)\n gate = tf.sigmoid(gate)\n transform = tf.tanh(transform)\n return lstm_out * gate + (1 - gate) * transform","def forward(\n self,\n x,\n mats_dict,\n lidar_depth,\n timestamps=None,\n ):\n if self.is_train_depth and self.training:\n x = self.backbone(x, mats_dict, lidar_depth, timestamps)\n preds = self.head(x)\n return preds\n else:\n x = self.backbone(x, mats_dict, lidar_depth, timestamps)\n preds = self.head(x)\n return preds","def forward(self, src, device):\n\n src = torch.as_tensor(src).float().to(device)\n\n\n # Set initial hidden and cell states \n h0 = torch.zeros(self.num_layers, src.shape[0], self.hidden_dim).to(device)\n c0 = torch.zeros(self.num_layers, src.shape[0], self.hidden_dim).to(device)\n\n # shape of lstm_out: [batch_size, input_size, hidden_dim]\n # shape of self.hidden: (a, b), where a and b both have shape (num_layers, batch_size, hidden_dim).\n lstm_out, self.hidden = self.lstm(src, (h0, c0)) \n \n # Only take the output from the final timetep\n # Can pass on the entirety of lstm_out to the next layer if it is a seq2seq prediction\n #print(lstm_out.size())\n y_pred = self.linear(lstm_out[:, -1, :].view(src.shape[0], -1))\n return y_pred","def forward(self, feature_indices, feature_values):\n self.A_=torch.sparse.FloatTensor(self.edge_indices,self.edge_weights,torch.Size([self.args.nu,self.args.nu])).to(self.device)\n feature=torch.sparse.FloatTensor(feature_indices,feature_values,torch.Size([self.args.nu,self.args.ne])).to(self.device).to_dense()\n #B=feature @ feature.t()\n #B=B-torch.diagflat(torch.diagonal(B)) \n #B=B+torch.eye(B.shape[0]).to(self.device)\n # B=torch.max(B-5,torch.zeros(B.shape[0],B.shape[0]).to(self.device))\n #print(B.max())\n # B=B/B.max()\n # B=torch.ceil(B/20.0)\n # B=torch.clamp(B-10,0,1)\n # np.savetxt(\"adja.txt\",torch.sum(B[:,0:3999],1).cpu().numpy(),fmt=\"%1.0f\")\n #degree=torch.sum(B,1)\n # print(degree) \n #D=torch.sqrt(torch.diagflat(1.0/degree))\n # B=D @ B @ D\n \n latent_features_1 = self.layer_1(feature)\n latent_features_1 = torch.nn.functional.relu(latent_features_1)\n latent_features_1 = torch.nn.functional.dropout(latent_features_1, p = self.args.dropout, training = self.training)\n latent_features_2 = self.layer_2(latent_features_1)\n #latent_features_2=torch.spmm(self.A_,latent_features_2)\n #for i in range(50):\n # latent_features_2=torch.spmm(self.A_,latent_features_2)\n localized_predictions=latent_features_2\n \n \n self.predictions = torch.nn.functional.log_softmax(localized_predictions , dim=1)\n return self.predictions","def forward(self, x):\n for task_module_name in self.task_module_name_path[self.task_idx]:\n for layer in self.task_modules[task_module_name]:\n x = layer(x)\n #x = self.task_modules[task_module_name](x)\n x = x.view(x.size(0), -1)\n x = self.classification_layers[str(self.task_idx)](x)\n return x","def forward(self, inp, state_0):\n next_inp = inp.view(1, -1)\n next_state = state_0\n outputs = []\n for i in range(self.seq_len):\n out, next_state = self.model(next_inp, next_state)\n outputs.append(out)\n next_inp = torch.argmax(out, dim=-1)\n\n return torch.cat(outputs, dim=0), next_state","def forward(self, x_data, state):\n #=====[ Step 1: Compute q(z|x) - encoding step, get z ]=====\n # Forward encoding\n for i in range(x_data.shape[0]):\n x = Variable(x_data[i].reshape((1, x_data.shape[1])))\n h_in = self.recog_x_h(x) + self.recog_h_h(state['h_rec'])\n c_t, h_t = F.lstm(state['c_rec'], h_in)\n state.update({'c_rec':c_t, 'h_rec':h_t})\n # Compute q_mean and q_log_sigma\n q_mean = self.recog_mean( state['h_rec'] )\n q_log_sigma = 0.5 * self.recog_log_sigma( state['h_rec'] )\n # Compute KL divergence based on q_mean and q_log_sigma\n KLD = -0.0005 * F.sum(1 + q_log_sigma - q_mean**2 - F.exp(q_log_sigma))\n # Compute as q_mean + noise*exp(q_log_sigma)\n eps = Variable(np.random.normal(0, 1, q_log_sigma.data.shape ).astype(np.float32))\n z = q_mean + F.exp(q_log_sigma) * eps\n\n #=====[ Step 2: Compute p(x|z) - decoding step ]=====\n # Initial step\n output = []\n h_in = self.gen_z_h(z)\n c_t, h_t = F.lstm(state['c_gen'], h_in)\n state.update({'c_gen':c_t, 'h_gen':h_t})\n rec_loss = Variable(np.zeros((), dtype=np.float32))\n for i in range(x_data.shape[0]):\n # Get output and loss\n x_t = self.output(h_t)\n output.append(x_t.data)\n rec_loss += self.loss_func(x_t, Variable(x_data[i].reshape((1, x_data.shape[1]))))\n # Get next hidden state\n h_in = self.gen_x_h(x_t) + self.gen_h_h(state['h_gen'])\n c_t, h_t = F.lstm(state['c_gen'], h_in)\n state.update({'c_gen':c_t, 'h_gen':h_t})\n\n #=====[ Step 3: Compute KL-Divergence based on all terms ]=====\n return output, rec_loss, KLD, state","def forward(self, observation: Tensor) -> Tensor:\n pass","def relu_forward_hook_function(module, ten_in, ten_out):\n self.forward_relu_outputs.append(ten_out)","def forward(self, nodes_batch):\n lower_layer_nodes = list(nodes_batch) # node idx\n\n nodes_batch_layers = [(lower_layer_nodes,)]\n\n for i in range(self.num_layers):\n lower_layer_neighs, lower_layer_nodes = self._get_unique_neighs_list(lower_layer_nodes,\n num_sample=self.num_neighbor_samples)\n # lower_layer_neighs: list(list())\n # lower_layer_nodes: list(nodes of next layer)\n nodes_batch_layers.insert(0, (lower_layer_nodes, lower_layer_neighs))\n\n all_nodes = np.unique([int(n) for n in list(chain(*[layer[0] for layer in nodes_batch_layers]))])\n all_nodes_idx = dict([(node, idx) for idx, node in enumerate(all_nodes)])\n\n all_neigh_nodes = pad_sequence([self.nodes_tokenized[node] for node in all_nodes], padding_value=1).transpose(0,\n 1)[\n :, :MAX_SEQ_LENGTH].to(self.device)\n\n pre_hidden_embs = self.get_roberta_embs(\n all_neigh_nodes\n )\n\n # (num_all_node, emb_size)\n\n for layer_idx in range(1, self.num_layers + 1):\n this_layer_nodes = nodes_batch_layers[layer_idx][0] # all nodes in this layer\n neigh_nodes, neighbors_list = nodes_batch_layers[layer_idx - 1] # previous layer\n # list(), list(list())\n\n aggregate_feats = self.aggregate(neighbors_list, pre_hidden_embs, all_nodes_idx)\n # (this_layer_nodes_num, emb_size)\n\n sage_layer = getattr(self, 'sage_layer' + str(layer_idx))\n\n cur_hidden_embs = sage_layer(self_feats=pre_hidden_embs[[all_nodes_idx[int(n)] for n in this_layer_nodes]],\n # pre_hidden_embs[layer_nodes],\n aggregate_feats=aggregate_feats)\n\n # cur_hidden_embs = torch.cat([pre_hidden_embs[[all_nodes_idx[int(n)] for n in this_layer_nodes]].unsqueeze(1), \n # aggregate_feats.unsqueeze(1)], dim=1) # (b_s, 2, emb_size)\n # cur_hidden_embs = torch.mean(cur_hidden_embs, dim=1)\n\n pre_hidden_embs[[all_nodes_idx[int(n)] for n in this_layer_nodes]] = cur_hidden_embs\n\n # (input_batch_node_size, emb_size)\n # output the embeddings of the input nodes\n return pre_hidden_embs[[all_nodes_idx[int(n)] for n in nodes_batch]]","def forward(self, state):\n \n for linear in self.hidden_layers:\n state = F.relu(linear(state))\n \n return self.output(state)","def forward(self, input):\n\n # transform input into matrix of vectors [Batch, 784]\n input = input.view(-1, 784).to(self.device)\n\n # full pass\n mean, std = self.encoder(input)\n z = self.reparameterize(mean, std)\n output = self.decoder(z)\n\n # calculate each part of the loss\n reg_loss = self.reg_loss(mean, std)\n recon_loss = self.recon_loss(input, output)\n\n # avarage over batch\n average_negative_elbo = torch.mean(reg_loss + recon_loss, dim=0)\n return average_negative_elbo","def forward(self, inputs):\n\n # Concatenate LSTM hidden state vectors into one large vector,\n # which will be then used for prediction\n aggregated = []\n cnt = 0\n for state, (lstm_cell, lstm_state) in enumerate(zip(self.lstm_cell_list, self.lstm_state_list)):\n lstm_state = lstm_cell(inputs[:, state, :, :].view(inputs.shape[0], -1), lstm_state)\n aggregated.append(lstm_state[1] * self.imp_weights[cnt])\n cnt += 1\n aggregated = torch.cat(aggregated, dim=1)\n\n # Calculate predictions\n pred = F.relu(self.pred_mlp_l1(aggregated))\n pred = self.pred_mlp_l2(pred)\n\n return pred","def __init__(self, name, params, load_model):\n\n super(MDN_RNN, self).__init__(name, params, load_model)\n self.name = name\n self.type = 'MDN RNN'\n if load_model != False:\n self.load_model(load_model)\n else:\n self.params = params\n self.z_size = self.params['z_size']\n self.action_size = self.params['action_size']\n self.hidden_size = self.params['hidden_size']\n self.gaussian_size = self.params['gaussian_size']\n self.stacked_layers = self.params['stacked_layers']\n self.learning_rate = self.params['learning_rate']\n self.grad_clip = self.params['grad_clip']\n self.batch_size = self.params['batch_size']\n self.device = self.get_device()\n \n self.lstm = nn.LSTM(self.z_size + self.action_size, self.hidden_size, self.stacked_layers, batch_first = True)\n self.fc1 = nn.Linear(self.hidden_size, self.gaussian_size * self.z_size)\n self.fc2 = nn.Linear(self.hidden_size, self.gaussian_size * self.z_size)\n self.fc3 = nn.Linear(self.hidden_size, self.gaussian_size * self.z_size)\n \n if load_model != False:\n self.load_state_dict(self.weights)\n \n print(self, \"\\n\\n\")","def forward(self, graph, x):\n graph_id = graph.graph_node_id\n batch_size = graph_id.max() + 1\n h = (\n paddle.zeros((self.n_layers, batch_size, self.input_dim)),\n paddle.zeros((self.n_layers, batch_size, self.input_dim)), )\n q_star = paddle.zeros((batch_size, self.output_dim))\n for _ in range(self.n_iters):\n q, h = self.lstm(q_star.unsqueeze(0), h)\n q = q.reshape((batch_size, self.input_dim))\n e = (x * q.index_select(\n graph_id, axis=0)).sum(axis=-1, keepdim=True)\n a = segment_softmax(e, graph_id)\n r = segment_sum(a * x, graph_id)\n q_start = paddle.concat([q, r], axis=-1)\n\n return q_start","def forward(self, sequence):\n seq_len = len(sequence)\n batch_size = sequence[0].size(0)\n state_bwd = self.bwd_rnn.init_state(batch_size, [self.height, self.width])\n\n outputs_bwd = []\n for t in range(seq_len):\n t_bwd = seq_len - t - 1\n output_bwd, state_bwd = self.bwd_rnn(sequence[t_bwd], state_bwd)\n outputs_bwd += [output_bwd]\n\n outputs_bwd.reverse()\n return outputs_bwd","def forward(self, input_var: Tensor, hidden: Optional[HiddenDict] = None, **additional: Dict) -> RecurrentOutput:\n ...","def lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b):\n next_h, next_c, cache = None, None, None\n #############################################################################\n # TODO: Implement the forward pass for a single timestep of an LSTM. #\n # You may want to use the numerically stable sigmoid implementation above. #\n #############################################################################\n N,H = prev_h.shape\n z_all = np.dot(x, Wx) + np.dot(prev_h, Wh) + b\n z_i = z_all[:,:H]; z_f=z_all[:,H:2*H]; z_o = z_all[:,2*H:3*H]; z_g=z_all[:,3*H:4*H]\n i = sigmoid(z_i)\n f = sigmoid(z_f)\n o = sigmoid(z_o)\n g = np.tanh(z_g)\n next_c = f * prev_c + i * g\n next_h = o * np.tanh(next_c)\n cache = (x, i, f, o, g, prev_h, next_h, prev_c, next_c, Wx, Wh, b)\n\n ##############################################################################\n # END OF YOUR CODE #\n ##############################################################################\n\n return next_h, next_c, cache","def forward(self, state):\n x = state.unsqueeze(1)\n x = F.relu(self.cnl1(x))\n x = F.relu(self.cnl2(x))\n x = F.relu(self.cnl3(x))\n x = x.view(x.shape[0], -1) # flatten\n x = F.relu(self.dense1(x))\n x = self.out(x)\n return x","def lstm_forward(self, x, parameters):\n\n #Accepting, x.shape = n_x, m, T_x \n #Let's make sure we are getting input of correct dimensions\n assert(self.nx == x.shape[0])\n assert(self.T_x == x.shape[2])\n \n #writing shorter variables to handle easily\n n_a, m = self.UNITS, x.shape[1]\n\n # Initialize \"caches\", which will track the list of all the caches\n caches = []\n\n # Initialize a_next and c_next\n a_next = np.zeros((n_a,m)) \n c_next = np.zeros(a_next.shape)\n \n # loop over all time-steps\n for t in range(self.T_x):\n # Update next hidden state, next memory state, compute the prediction, get the cache \n a_next, c_next, cache = self.lstm_cell_forward(x[:,:,t], a_next, c_next, parameters)\n # Append the cache into caches \n caches.append(cache)\n \n # store values needed for backward propagation in cache\n caches = (caches, x)\n\n #since only the last activation is of our concern\n return a_next, caches","def forward(self, state, action):\r\n \r\n x = torch.cat([state, action], 1) ##### fixed dim ändern\r\n x = F.relu(self.linear1(x))\r\n x = F.relu(self.linear2(x))\r\n x = self.linear3(x)\r\n\r\n return x","def __init__(self, embed_size, hidden_size, vocab_size, num_layers): #(512,1024,29,1)\r\n super(DecoderRNN, self).__init__()\r\n self.embed = nn.Embedding(vocab_size, embed_size)#(29,512)\r\n self.lstm = nn.LSTM(embed_size, hidden_size, num_layers, batch_first=True) #(512,1024,1)\r\n self.linear = nn.Linear(hidden_size, vocab_size)#(1024,29)\r\n self.init_weights()","def __init__(self, vocab_size, output_size, embedding_dim, hidden_dim, n_layers, drop_prob=0.7):\n super(SentimentLSTM, self).__init__()\n\n self.output_size = output_size\n self.n_layers = n_layers\n self.hidden_dim = hidden_dim\n\n\n # define all layers\n self.embed = nn.Embedding(vocab_size,embedding_dim)\n self.lstm = nn.LSTM(embedding_dim,hidden_dim,n_layers,dropout=drop_prob,batch_first=True)\n self.fc = nn.Linear(hidden_dim,output_size)\n self.sigmoid = nn.Sigmoid()\n self.drp = nn.Dropout(p=0.7)","def local_trend_rnn(features, labels, mode, params):\n\n ''' set up variables & parameters'''\n # get parameters & super parameters\n length = params['length']\n batch_size = params['batch_size']\n state_size = params['state_size']\n drop_rate = params['drop_rate']\n attention_size = params['attention_size']\n learning_rate = params['learning_rate']\n\n # get training features and label\n local_prices = features['local_prices'] # [b, n, 1]\n local_events = features['local_events'] # [b, n, d]\n\n ''' building basic model structure'''\n # inner trend capture\n price_trend_capture = DynamicLstm(batch_size=batch_size, state_size=state_size,\n keep_rate=1 - drop_rate, variable_scope=\"price_trend_capture\")\n price_trend_h_vec = price_trend_capture.run(local_prices) # [b, n, h]\n\n # event trend capture\n event_trend_capture = DynamicLstm(batch_size=batch_size, state_size=state_size,\n keep_rate=1 - drop_rate, variable_scope=\"event_trend_capture\")\n event_trend_h_vec = event_trend_capture.run(local_events) # [b, n, h]\n\n ''' combine price trend and event trend '''\n hybrid_trend = tf.concat([price_trend_h_vec, event_trend_h_vec], axis=2) # [b, n, 2h]\n hybrid_trend_capture = DynamicLstm(batch_size=batch_size, state_size=state_size,\n keep_rate=1 - drop_rate, variable_scope=\"hybrid_trend_capture\")\n hybrid_trend_h_vec = hybrid_trend_capture.run(hybrid_trend) # [b, n, h]\n\n ''' generate final prediction '''\n output_dense = tf.layers.Dense(units=1, name=\"output_dense\")\n hybrid_attention = AttentionLayer(attention_size=attention_size, name=\"hybrid_attention\")\n values = output_dense(hybrid_attention.run(hybrid_trend_h_vec)) # [b, 1]\n\n ''' config '''\n # Compute predictions.\n if mode == tf.estimator.ModeKeys.PREDICT:\n predictions = {'values': values}\n return tf.estimator.EstimatorSpec(mode, predictions=predictions)\n\n # Compute loss.\n loss = tf.losses.mean_squared_error(labels, values)\n\n # Compute evaluation metrics.\n mse = tf.metrics.mean_squared_error(labels=labels, predictions=values, name='MSE')\n metrics = {'MSE': mse}\n tf.summary.scalar('mean_squared_error', loss)\n\n if mode == tf.estimator.ModeKeys.EVAL:\n return tf.estimator.EstimatorSpec(\n mode, loss=loss, eval_metric_ops=metrics)\n\n # Create training op.\n assert mode == tf.estimator.ModeKeys.TRAIN\n optimizer = tf.train.AdagradOptimizer(learning_rate=learning_rate)\n train_op = optimizer.minimize(loss, global_step=tf.train.get_global_step())\n return tf.estimator.EstimatorSpec(mode, loss=loss, train_op=train_op)","def forward(self,\n *args,\n inputs: torch.nn.Module,\n step_fn: torch.nn.Module, ) -> torch.Tensor:\n timestep = 0\n hidden = inputs\n # halting_prob_cumulation: (batch, seq_len)\n halting_prob_cumulation = hidden.new_zeros(hidden.size()[:-1]).float()\n\n while timestep < self._max_computing_time and \"TODO: exit if all place exhausted\":\n # current all alive tokens, which need further computation\n # alive_mask: (batch, seq_len)\n alive_mask: torch.Tensor = halting_prob_cumulation < 1.\n alive_mask = alive_mask.float()\n\n # halting_prob: (batch, seq_len) <- (batch, seq_len, 1)\n halting_prob = self._halting_fn(hidden).squeeze(-1)\n\n # temp_cumulation: (batch, seq_len)\n temp_cumulation = halting_prob * alive_mask + halting_prob_cumulation\n\n # mask to the newly halted tokens, which is exhausted at the current timestep of computation\n # new_halted: (batch, seq_len)\n new_halted = (temp_cumulation > self._threshold).float()\n remainder = 1. - halting_prob_cumulation + 1.e-10\n\n # all tokens that survives from the current timestep's computation\n # alive_mask: (batch, seq_len)\n alive_mask = (1 - new_halted) * alive_mask\n\n halting_prob_cumulation += halting_prob * alive_mask\n # cumulations for newly halted positions will reach 1.0 after adding up remainder at the current timestep\n halting_prob_cumulation += remainder * new_halted\n\n step_out = step_fn(hidden, *args, timestep)\n timestep += 1\n state_update_weight = alive_mask.unsqueeze(-1)\n hidden = state_update_weight * step_out + (1 - state_update_weight) * hidden\n\n return hidden","def lstm_backward(dh, cache):\n dx, dh_prev, dWx, dWh, db = None, None, None, None, None\n #############################################################################\n # TODO: Implement the backward pass for an LSTM over an entire timeseries. #\n # You should use the lstm_step_backward function that you just defined. #\n #############################################################################\n\n N,T,H = dh.shape\n tmp_x = cache[T-1][0]\n D = tmp_x.shape[1]\n # cache is a list of these values -- so cache[0] is\n # x, i, f, o, g, prev_h, next_h, prev_c, next_c, Wx, Wh, b = cache\n dnext_h = dh\n\n dx = np.zeros((N,T,D))\n dh_prev = np.zeros((N,H))\n dc_prev = np.zeros((N,H))\n dWx = np.zeros((D,4*H))\n dWh = np.zeros((H,4*H))\n db = np.zeros((4*H))\n\n for t in reversed(range(0,T)):\n # current gradient at timestep is the upstream gradient (provided as input)\n # this may be coming from the Y as in the min_char_rnn.py (see line 59)\n # + downstream gradient provided by rnn_step_backward.\n dh_curr = dh[:,t,:] + dh_prev\n dx_, dh_prev, dc_prev, dWx_, dWh_, db_ = lstm_step_backward(dh_curr, dc_prev, cache[t])\n dWx += dWx_\n dWh += dWh_\n db += db_\n dx[:,t,:]=dx_\n\n ##############################################################################\n # END OF YOUR CODE #\n ##############################################################################\n\n return dx, dh_prev, dWx, dWh, db","def L_model_forward(X, parameters):\n pass","def __init__(self, input_size=1, hidden_layer_size=100, aux_features_size=31, output_size=1):\n super().__init__()\n self.hidden_layer_size = hidden_layer_size # TODO [tuning] different size (?)\n\n # TODO [tuning] BiLSTM (?)\n self.lstm = nn.LSTM(input_size=input_size, hidden_size=hidden_layer_size, batch_first=True)\n self.linear_aux = nn.Linear(aux_features_size, hidden_layer_size, bias=True) # TODO try with bias=False (?)\n self.linear = nn.Linear(hidden_layer_size, output_size, bias=True) # TODO try with bias=False (?)","def forward(self, input):\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n assert input.shape[1] == self.n_neurons, \"The shape of the input tensor is not correct.\"\n\n bn_fct = CustomBatchNormManualFunction()\n out = bn_fct.apply(input, self.gamma, self.beta, self.eps)\n ########################\n # END OF YOUR CODE #\n #######################\n\n return out","def forwardPropagation(self, inputs, label):\n node_hidden = np.dot(inputs, self.input_W)\n node_hidden = np.add(node_hidden, self.input_B)\n node_hidden = np.maximum(0, node_hidden)\n node_output = np.dot(node_hidden, self.hidden_W)\n node_output = np.add(node_output, self.hidden_B)\n #print(node_output)\n exp_node_output = np.exp(node_output)\n node_output = exp_node_output / np.sum(exp_node_output, axis=1, keepdims=True)\n #print(node_output)\n #node_output = self.softmax(node_output)\n loss = np.sum(-np.log(node_output[range(inputs.shape[0]),label]))/(inputs.shape[0])+0.5 * self.regularizer*np.sum(self.input_W *self.input_W)+0.5 * self.regularizer*np.sum(self.hidden_W *self.hidden_W)\n \"\"\"Loss= Input data loss + Loss correction by penalizing the loss, here we use 0.2 as an experimental value\"\"\"\n #loss = np.sum(-np.log(node_output[range(inputs.shape[0]), label])) / (inputs.shape[0]) + 0.2 * self.regularizer * np.sum(self.input_W ^ 2) + 0.2 * self.regularizer * np.sum(self.hidden_W ^ 2)\n return loss, node_hidden, node_output","def forward(inputs,weights,function=sigmoid,step=-1):\n if step == 0:\n return inputs\n elif step == -1:\n step = len(weights) #go to output layer \n output = np.append(1, inputs)\n for i in range(step):\n output = np.append(1, function(np.dot(weights[i], output))) #calculating activation\n return output[1:]","def conv_step(self, parent_node_embedding, children_embedding, children_index, node_dim, w_t, w_r, w_l, b_conv):\n with tf.compat.v1.name_scope('conv_step'):\n # nodes is shape (batch_size x max_tree_size x node_dim)\n # children is shape (batch_size x max_tree_size x max_children)\n\n with tf.compat.v1.name_scope('trees'):\n \n # add a 4th dimension to the parent nodes tensor\n # nodes is shape (batch_size x max_tree_size x 1 x node_dim)\n parent_node_embedding = tf.expand_dims(parent_node_embedding, axis=2)\n # tree_tensor is shape\n # (batch_size x max_tree_size x max_children + 1 x node_dim)\n tree_tensor = tf.concat([parent_node_embedding, children_embedding], axis=2, name='trees')\n\n with tf.compat.v1.name_scope('coefficients'):\n # coefficient tensors are shape (batch_size x max_tree_size x max_children + 1)\n c_t = self.eta_t(children_index)\n c_r = self.eta_r(children_index, c_t)\n c_l = self.eta_l(children_index, c_t, c_r)\n\n # concatenate the position coefficients into a tensor\n # (batch_size x max_tree_size x max_children + 1 x 3)\n coef = tf.stack([c_t, c_r, c_l], axis=3, name='coef')\n\n with tf.compat.v1.name_scope('weights'):\n # stack weight matrices on top to make a weight tensor\n # (3, node_dim, conv_output_dim)\n weights = tf.stack([w_t, w_r, w_l], axis=0)\n\n with tf.compat.v1.name_scope('combine'):\n batch_size = tf.shape(input=children_index)[0]\n max_tree_size = tf.shape(input=children_index)[1]\n max_children = tf.shape(input=children_index)[2]\n\n # reshape for matrix multiplication\n x = batch_size * max_tree_size\n y = max_children + 1\n result = tf.reshape(tree_tensor, (x, y, node_dim))\n coef = tf.reshape(coef, (x, y, 3))\n result = tf.matmul(result, coef, transpose_a=True)\n result = tf.reshape(result, (batch_size, max_tree_size, 3, node_dim))\n\n # output is (batch_size, max_tree_size, conv_output_dim)\n result = tf.tensordot(result, weights, [[2, 3], [0, 1]])\n\n # output is (batch_size, max_tree_size, conv_output_dim)\n\n # output = tf.nn.tanh(result + b_conv, name='conv')\n output = tf.nn.leaky_relu(result + b_conv)\n # output = tf.compat.v1.nn.swish(result + b_conv)\n # output = tf.layers.batch_normalization(output, training=self.placeholders['is_training'])\n output_drop_out = tf.nn.dropout(output, rate=self.placeholders[\"dropout_rate\"]) # DROP-OUT here\n return output_drop_out","def lstm_model(input_size, output_size, embedding, num_nodes, num_unrollings, batch_size,\n learning_rate, exp_decay = None, gradient_max_value = 1.25, dropout_prob = 0.0):\n\n graph = tf.Graph()\n with graph.as_default():\n # [ix, fx, cx, ox]\n x_mat = training.utils.gaussian_weights_variable([input_size, 4*num_nodes])\n # [im, fm, cm, om]\n o_mat = training.utils.gaussian_weights_variable([num_nodes, 4*num_nodes])\n # [ib, fb, cb, ob]\n b_vec = tf.Variable(tf.zeros([1, 4*num_nodes]))\n\n # Variables saving state across unrollings.\n saved_output = tf.Variable(tf.zeros([batch_size, num_nodes]), trainable=False)\n saved_state = tf.Variable(tf.zeros([batch_size, num_nodes]), trainable=False)\n # Classifier weights and biases.\n w = training.utils.gaussian_weights_variable([num_nodes, output_size])\n b = tf.Variable(tf.zeros([output_size]))\n\n # Definition of the cell computation.\n def lstm_cell(i, o, state):\n \"\"\"Create a LSTM cell. See e.g.: http://arxiv.org/pdf/1402.1128v1.pdf\n Note that in this formulation, we omit the various connections between the\n previous state and the gates.\"\"\"\n mult = tf.matmul(i, x_mat) + tf.matmul(o, o_mat) + b_vec\n\n input_gate = tf.sigmoid(mult[:, 0:num_nodes])\n forget_gate = tf.sigmoid(mult[:, num_nodes:2*num_nodes])\n state = forget_gate * state + input_gate * tf.tanh(mult[:, 2*num_nodes:3*num_nodes])\n output_gate = tf.sigmoid(mult[:, 3*num_nodes:4*num_nodes])\n return output_gate * tf.tanh(state), state\n\n # Input data.\n before_embedding_size = input_size\n if embedding is not None:\n before_embedding_size = embedding.shape[0]\n\n train_data = list()\n for _ in range(num_unrollings + 1):\n train_data.append(\n tf.placeholder(tf.float32, shape=[batch_size, before_embedding_size]))\n train_inputs = train_data[:num_unrollings]\n train_labels = train_data[1:] # Labels are inputs shifted by one time step.\n\n # Unrolled LSTM loop.\n outputs = list()\n output = saved_output\n state = saved_state\n for i in train_inputs:\n if embedding is not None:\n # Converting the input to the embedding.\n indices = tf.argmax(i, 1)\n i = tf.nn.embedding_lookup(embedding, indices)\n # Dropout is only applied to inputs, not to recurrent connections.\n i = tf.nn.dropout(i, 1 - dropout_prob)\n output, state = lstm_cell(i, output, state)\n outputs.append(output)\n\n # State saving across unrollings.\n with tf.control_dependencies([saved_output.assign(output),\n saved_state.assign(state)]):\n # Classifier.\n # Dropout is also applied to the output of the LSTM cell, only when\n # used for the projection, as it is not recurrent.\n outputs = tf.concat(0, outputs)\n outputs = tf.nn.dropout(outputs, 1 - dropout_prob)\n logits = tf.nn.xw_plus_b(outputs, w, b)\n loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(\n logits, tf.concat(0, train_labels)))\n\n # Optimizer.\n global_step = tf.Variable(0)\n\n if exp_decay is not None:\n learning_rate = tf.train.exponential_decay(\n learning_rate, global_step,\n exp_decay['decay_steps'], exp_decay['decay_rate'], exp_decay['staircase'])\n\n optimizer = tf.train.GradientDescentOptimizer(learning_rate)\n # Clipping to avoid exploding gradient.\n gradients, v = zip(*optimizer.compute_gradients(loss))\n gradients, _ = tf.clip_by_global_norm(gradients, gradient_max_value)\n optimizer = optimizer.apply_gradients(zip(gradients, v), global_step=global_step)\n\n # Predictions.\n train_prediction = tf.nn.softmax(logits)\n\n # Sampling and validation eval: batch 1, no unrolling.\n sample_input_ph = tf.placeholder(tf.float32, shape=[1, before_embedding_size])\n saved_sample_output = tf.Variable(tf.zeros([1, num_nodes]))\n saved_sample_state = tf.Variable(tf.zeros([1, num_nodes]))\n reset_sample_state = tf.group(\n saved_sample_output.assign(tf.zeros([1, num_nodes])),\n saved_sample_state.assign(tf.zeros([1, num_nodes])))\n\n sample_input = sample_input_ph\n if embedding is not None:\n indices = tf.argmax(sample_input_ph, 1)\n sample_input = tf.nn.embedding_lookup(embedding, indices)\n\n sample_output, sample_state = lstm_cell(\n sample_input, saved_sample_output, saved_sample_state)\n with tf.control_dependencies([saved_sample_output.assign(sample_output),\n saved_sample_state.assign(sample_state)]):\n sample_prediction = tf.nn.softmax(tf.nn.xw_plus_b(sample_output, w, b))\n\n tf_graph = {\n 'graph': graph,\n 'data_ph': train_data,\n 'sample_ph': sample_input_ph }\n tf_predictions = [train_prediction, sample_prediction]\n\n return tf_graph, optimizer, loss, tf_predictions, reset_sample_state","def forward(self, model, sample, reduce=True):\n # print('sample',sample)\n vad, asr = False, False\n assert len(set(sample['task'])) == 1\n task = sample['task'][0]\n assert task == 'vad'\n vad = True\n net_output = model(**sample['net_input'])\n\n logits_vad = net_output['encoder_seq_out']\n features = net_output['features']\n ts_embedding = net_output['ts_embedding']\n\n ori_targets = model.get_targets(sample, net_output)\n ts_targets = sample[\"target_ts\"]\n non_padding_mask = ~net_output[\"padding_mask\"]\n input_lengths = non_padding_mask.long().sum(-1)\n #targets = ts_targets.expand(logits_vad.size(0), logits_vad.size(1))\n targets = ts_targets\n\n targets = targets.contiguous().view(-1).long()\n # targets = model.get_targets(sample, net_output).view(-1).long()\n lprobs = F.softmax(logits_vad, dim=-1, dtype=torch.float32)\n\n\n if vad:\n loss_ts_vad = self.criterion_ts_vad(logits_vad.view(-1, logits_vad.size(-1)), targets)\n contrasitive_loss = self.contrastive_loss(features.contiguous().view(-1, features.size(-1)), ts_embedding.contiguous().view(-1, ts_embedding.size(-1)), targets)\n\n loss = loss_ts_vad + contrasitive_loss\n else:\n print('batch error', targets)\n sys.exit()\n\n target_lengths = sample[\"target_lengths\"]\n\n ntokens = len(targets)\n sample_size = 1 # sample['target'].size(0) if self.sentence_avg else ntokens #sample['ntokens']\n\n logging_output = {\n 'loss': loss.data,\n }\n\n if vad:\n logging_output['loss_vad'] = loss.data\n preds = logits_vad.view(-1, logits_vad.size(-1)).argmax(dim=-1)\n #sil_cnt = (targets == 2).sum()\n ts_cnt = (targets == 0).sum()\n pred_ts_cnt = (preds == 0).sum()\n #assert sil_cnt + sp_cnt == len(targets)\n #assert sil_cnt + sp_cnt == len(preds)\n\n try:\n logging_output['n_pred_ts'] = pred_ts_cnt\n logging_output['n_ts'] = ts_cnt\n\n logging_output['ncorrect_vad'] = (preds == targets).sum()\n logging_output['ncorrect_ts'] = ((preds == 0) & (targets == 0)).sum()\n # print(111111,logging_output['ncorrect_sil']/sil_cnt,logging_output['ncorrect_sp']/sp_cnt)\n # print(1111,sil_cnt,sp_cnt,((preds == 1) & (targets == 1)).sum(),((preds == 0) & (targets == 0)).sum())\n except:\n print('vad sample_size error')\n logging_output['ncorrect_vad'] = 0\n logging_output['nsentences_vad'] = sample['target'].size(0)\n logging_output['sample_size_vad'] = sample_size\n logging_output['ntokens_vad'] = ntokens\n logging_output[\"c_errors\"] = 0\n logging_output[\"c_total\"] = 0\n\n return loss, sample_size, logging_output","def forward(self, inputs, hidden):\n batch_size = inputs[0].size(1)\n\n embed_sum = None\n for feat, layer in zip(inputs, self.fcs):\n if embed_sum is None:\n embed_sum = layer(feat.view(-1, feat.size(2)))\n else:\n embed_sum = embed_sum + layer(feat.view(-1, feat.size(2)))\n # import pdb; pdb.set_trace()\n embeds = self.relu1(embed_sum)\n embeds = self.bn1(embeds)\n\n # re-expand the network outputs 6\n embeds = embeds.view(-1, batch_size, self.hidden_dim)\n lstm_out, hidden = self.lstm(embeds, hidden)\n out = self.fc2(lstm_out.view(-1, lstm_out.size(2)))\n out = out.view(-1, batch_size, self.output_dim)\n out = self.sigmoid(out)\n return out, hidden","def forward(self, inputs, hidden):\n batch_size = inputs[0].size(1)\n\n embed_sum = None\n for feat, layer in zip(inputs, self.fcs):\n if embed_sum is None:\n embed_sum = layer(feat.view(-1, feat.size(2)))\n else:\n embed_sum = embed_sum + layer(feat.view(-1, feat.size(2)))\n # import pdb; pdb.set_trace()\n embeds = self.relu1(embed_sum)\n embeds = self.bn1(embeds)\n\n # re-expand the network outputs 6\n embeds = embeds.view(-1, batch_size, self.hidden_dim)\n lstm_out, hidden = self.lstm(embeds, hidden)\n out = self.fc2(lstm_out.view(-1, lstm_out.size(2)))\n out = out.view(-1, batch_size, self.output_dim)\n out = self.sigmoid(out)\n return out, hidden","def forward(self, features, features_lengths, spkids):\n pass","def forward(self, x):\n #print('output of fetures.children() : %s'%str([i for i in self.features.children()]))\n #print(\"shape of input is %s\" % str(x.size()))\n for layer_no, layer in enumerate(self.features.children()):\n\n if layer_no is 23:\n y = layer(x)\n if layer_no is 33:\n z = layer(x)\n x = layer(x)\n\n #print('debug')\n #print('layer info: %s'%str(layer))\n #print(\"shape of x is %s\" % str(x.size()))\n\n x = self.conv1D_downstream1(x)\n x = self.conv1D_downstream2(x)\n x = self.upsample_1(x)\n\n z = self.conv1D_pool4(z)\n y = self.conv1D_pool3(y)\n #print('debug')\n #print(\"shape of x is %s\"%str(x.size()))\n #print(\"shape of z is %s\" % str(z.size()))\n\n if x.size() is not z.size():\n x = nn.functional.interpolate(x,size = (z.size()[2],z.size()[3]), mode = 'nearest')\n x = x+ z\n x = self.upsample_2(x)\n x = x+y\n x = self.upsample_3(x)\n\n return x","def forward(self, input, hidden):\r\n output, hidden = self.rnn(input, hidden)\r\n output = f.log_softmax(self.out(output.squeeze(1)), 1)\r\n return output, hidden","def MultiLSTM(inputs,weights):\n w_kernel = weights['w_kernel']\n w_recurrent = weights['w_recurrent']\n w_bias = weights['w_bias']\n T = inputs.shape[-2]\n H = []\n for t in range(T):\n if t > 0:\n z = tf.einsum('knx,xj->knj',inputs[:,:,t,:],w_kernel) + tf.einsum('knl,lj->knj',h,w_recurrent) + tf.expand_dims(w_bias,0)\n else:\n z = tf.einsum('knx,xj->knj',inputs[:,:,t,:],w_kernel) + tf.expand_dims(w_bias,0)\n i,f,o,u = tf.split(z,4,axis=-1)\n i = tf.sigmoid(i) #input gate\n f = tf.sigmoid(f + 1.0) #forget gate\n o = tf.sigmoid(o) #output gate\n u = tf.tanh(u) #information let in by input gate\n if t > 0:\n c = f * c + i * u\n else:\n c = i * u\n h = o * tf.tanh(c)\n H.append(h)\n H = tf.stack(H,-2)\n return(H)","def forward(self, state):\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n x = F.relu(self.fc3(x))\n return self.fc4(x)","def forward(self, feature_indices, feature_values):\n \n \n #feature_values = torch.nn.functional.dropout(feature_values, p = self.args.dropout, training = self.training)\n feature=torch.sparse.FloatTensor(feature_indices,feature_values,torch.Size([self.args.nu,self.args.ne])).to(self.device).float()\n latent_features_1 = torch.nn.functional.relu(self.layer_1(feature))\n latent_features_1 = torch.nn.functional.dropout(latent_features_1, p = self.args.dropout, training = self.training)\n latent_features_2 = self.layer_2(latent_features_1)\n\n if self.args.model==\"exact\": \n self.predictions = torch.mm(torch.nn.functional.dropout(self.propagator, p = self.args.dropout, training = self.training), latent_features_2)\n else:\n localized_predictions = latent_features_2\n edge_weights = torch.nn.functional.dropout(self.edge_weights, p = self.args.dropout, training = self.training)\n self.A_=torch.sparse.FloatTensor(self.edge_indices,self.edge_weights,torch.Size([self.args.nu,self.args.nu])).to(self.device).float()\n for iteration in range(self.args.iter_time): \n localized_predictions = (1-self.args.alpha)*torch.spmm(self.A_, localized_predictions)+self.args.alpha*latent_features_2\n self.predictions = localized_predictions \n \n self.predictions = torch.nn.functional.log_softmax(self.predictions , dim=1)\n return self.predictions"],"string":"[\n \"def forward(self, xs):\\n\\n xs = torch.split(xs, self.channel, -1)# list of batch, node, featdim\\n xs = torch.stack(xs,2)#[batch, nodes, num_layers, num_channels]\\n shape = xs.shape\\n x = xs.reshape((-1,shape[2],shape[3])) # [ngraph * num_nodes , num_layers, num_channels]\\n alpha, _ = self.lstm(x)\\n alpha = self.att(alpha).squeeze(-1) # [ngraph * num_nodes, num_layers]\\n alpha = torch.softmax(alpha, dim=-1)\\n x = (x * alpha.unsqueeze(-1)).sum(dim=1)\\n x = x.reshape((shape[0],shape[1],shape[3]))\\n return x\",\n \"def forward(self, X, hx=None):\\n outputs = []\\n (batch_size, Nseq, Dim) = X.size()\\n \\n# print (\\\"Dimensions LSTM_RNN Batch: \\\", (batch_size, Nseq, Dim))\\n for l in range(self.num_layers):\\n if (type(hx) == type(None)):\\n h_t = torch.zeros(batch_size, self.hidden_size).to(device = Vil.device, dtype = Vil.dtype)\\n c_t = torch.zeros(batch_size, self.hidden_size).to(device = Vil.device, dtype = Vil.dtype)\\n else:\\n h_t = torch.zeros(batch_size, self.hidden_size).to(device = Vil.device, dtype = Vil.dtype)\\n c_t = torch.zeros(batch_size, self.hidden_size).to(device = Vil.device, dtype = Vil.dtype)\\n setattr(self, 'h_t%i'%(l+1), h_t)\\n setattr(self, 'c_t%i'%(l+1), c_t)\\n \\n # We loop for every element in the chain and for every layer\\n\\n for i in range(Nseq):\\n input_t = X[:,i,:]\\n# print (\\\"Sequence Chunk size: \\\",input_t.size())\\n l = 0\\n # First layer we put the input, in the rest we put the propagated states\\n h_t, c_t = getattr(self, 'LSTMCell%i'%(l+1))(input_t, (getattr(self, 'h_t%i'%(l+1)), getattr(self, 'c_t%i'%(l+1))))\\n setattr(self, 'h_t%i'%(l+1), h_t)\\n setattr(self, 'c_t%i'%(l+1), c_t)\\n \\n for l in range(1,self.num_layers):\\n h_t, c_t = getattr(self, 'LSTMCell%i'%(l+1))(h_t, (getattr(self, 'h_t%i'%(l+1)), getattr(self, 'c_t%i'%(l+1))))\\n setattr(self, 'h_t%i'%(l+1), h_t)\\n setattr(self, 'c_t%i'%(l+1), c_t)\\n \\n \\n # Return the hx and cx of all layers ? for the last sample ?\\n outputs = []\\n for l in range(self.num_layers):\\n outputs.append( [getattr(self, 'h_t%i'%(l+1)), getattr(self, 'c_t%i'%(l+1))])\\n\\n# outputs = torch.stack(outputs, 1).squeeze(2)\\n \\n return outputs\",\n \"def forward(self, x):\\n batch_size = x.size(0)\\n out,_ = self.lstm(x) #out = batch, seq_len, num_directions * hidden_size\\n out1 = out[:, -1, :16] #最后一层正向传播的最后一个timestep\\n out2 = out[:, 0, 16:] #最后一层反向传播最后一个timestep\\n out = torch.cat((out1,out2), dim=1)\\n out = self.fc(out)\\n\\n return out\",\n \"def forward(self, x):\\n x, self.hidden = self.lstm(x, self.hidden)\\n self.detach_hidden()\\n x = self.dropout(x)\\n x = self.out(x)\\n return x\",\n \"def forward(self, x):\\n x = tensor(x).unsqueeze(1)\\n x = self.cnn(x)\\n\\n # LSTM from here\\n batch_size = x.shape[0]\\n x = x.view(batch_size, x.shape[1] * x.shape[2], x.shape[3])\\n x = x.permute(2, 0, 1) # Converting from (B,H,W)->(W,B,H)\\n\\n output = self.rnn(x)\\n return output\",\n \"def __init__(self, incoming, n_units,\\n W_ci=tf.zeros, W_ig=tf.zeros, W_og=tf.zeros, W_fg=tf.zeros,\\n b_ci=tf.zeros, b_ig=tf.zeros, b_og=tf.zeros, b_fg=tf.zeros,\\n a_ci=tf.tanh, a_ig=tf.sigmoid, a_og=tf.sigmoid, a_fg=tf.sigmoid, a_out=tf.identity,\\n c_init=tf.zeros, h_init=tf.zeros, learn_c_init=False, learn_h_init=False, forgetgate=True,\\n output_dropout=False, store_states=False, return_states=False, precomp_fwds=False,\\n tickerstep_biases=None, learn_tickerstep_biases=True, name='LSTM'):\\n super(LSTMLayer, self).__init__()\\n with tf.variable_scope(name) as self.layer_scope:\\n self.incoming, self.incoming_shape = get_input(incoming)\\n self.n_units = n_units\\n self.lstm_inlets = ['ci', 'ig', 'og', 'fg']\\n if return_states:\\n store_states = True\\n \\n #\\n # Initialize weights and biases\\n #\\n \\n # Turn W inits into lists [forward_pass, backward_pass]\\n W_ci, W_ig, W_og, W_fg = [v[:2] if isinstance(v, list) else [v, v] for v in [W_ci, W_ig, W_og, W_fg]]\\n \\n # Make W and b tf variables\\n W_ci, W_ig, W_og, W_fg = [\\n [tofov(v[0], shape=[self.incoming_shape[-1], n_units], var_params=dict(name=n + '_fwd')),\\n tofov(v[1], shape=[n_units, n_units], var_params=dict(name=n + '_bwd'))]\\n for v, n in zip([W_ci, W_ig, W_og, W_fg], ['W_ci', 'W_ig', 'W_og', 'W_fg'])]\\n b_ci, b_ig, b_og, b_fg = [tofov(v, shape=[n_units], var_params=dict(name=n)) for v, n in\\n zip([b_ci, b_ig, b_og, b_fg], ['b_ci', 'b_ig', 'b_og', 'b_fg'])]\\n \\n # Pack weights for fwd and bwd connections\\n W_fwd_conc = tf.concat(axis=1, values=[W[0] for W in [W_ci, W_ig, W_og, W_fg]])\\n W_bwd_conc = tf.concat(axis=1, values=[W[1] for W in [W_ci, W_ig, W_og, W_fg]])\\n \\n if not forgetgate:\\n print(\\\"Warning: Setting forgetgate to 0 has not been tested yet, please set the W and b manually \\\"\\n \\\"to not-trainable tensorflow variables!\\\")\\n \\n def a_fg(x):\\n return tf.ones(x.get_shape().as_list())\\n \\n # Initialize bias for tickersteps\\n if tickerstep_biases is not None:\\n self.W_tickers = OrderedDict(zip_longest(self.lstm_inlets,\\n [tofov(tickerstep_biases, shape=[n_units],\\n var_params=dict(name='W_tickers_' + g,\\n trainable=learn_tickerstep_biases))\\n for g in self.lstm_inlets]))\\n else:\\n self.W_tickers = None\\n \\n #\\n # Create mask for output dropout\\n # apply dropout to n_units dimension of outputs, keeping dropout mask the same for all samples,\\n # sequence positions, and pixel coordinates\\n #\\n output_shape = self.get_output_shape()\\n if output_dropout:\\n out_do_mask = tf.ones(shape=[output_shape[0], output_shape[-1]],\\n dtype=tf.float32)\\n out_do_mask = tf.nn.dropout(out_do_mask, keep_prob=1. - output_dropout,\\n noise_shape=[1, output_shape[-1]])\\n \\n def out_do(x):\\n \\\"\\\"\\\"Function for applying dropout mask to outputs\\\"\\\"\\\"\\n if output_dropout:\\n return out_do_mask * x\\n else:\\n return x\\n \\n # Redefine a_out to include dropout (sneaky, sneaky)\\n a_out_nodropout = a_out\\n \\n def a_out(x):\\n return a_out_nodropout(out_do(x))\\n \\n #\\n # Handle initializations for h (hidden states) and c (cell states) as Variable\\n #\\n h_init = out_do(tofov(h_init, shape=[output_shape[0], output_shape[-1]],\\n var_params=dict(name='h_init', trainable=learn_h_init)))\\n c_init = tofov(c_init, shape=[output_shape[0], output_shape[-1]],\\n var_params=dict(name='h_init', trainable=learn_c_init))\\n \\n # Initialize lists to store LSTM activations and cell states later\\n h = [h_init]\\n c = [c_init]\\n \\n self.precomp_fwds = precomp_fwds\\n self.store_states = store_states\\n self.return_states = return_states\\n \\n self.W_fwd = OrderedDict(zip(self.lstm_inlets, [W[0] for W in [W_ci, W_ig, W_og, W_fg]]))\\n self.W_bwd = OrderedDict(zip(self.lstm_inlets, [W[1] for W in [W_ci, W_ig, W_og, W_fg]]))\\n \\n self.W_fwd_conc = W_fwd_conc\\n self.W_bwd_conc = W_bwd_conc\\n self.a = OrderedDict(zip(self.lstm_inlets, [a_ci, a_ig, a_og, a_fg]))\\n self.a['out'] = a_out\\n self.b = OrderedDict(zip(self.lstm_inlets, [b_ci, b_ig, b_og, b_fg]))\\n self.h = h\\n self.c = c\\n self.external_rec = None\\n \\n self.ig = []\\n self.og = []\\n self.ci = []\\n self.fg = []\\n \\n self.out = tf.expand_dims(h_init, 1)\\n self.name = name\",\n \"def __init__(self, input_size, hidden_size, num_layers, hierarchy_depth,\\n dropout):\\n super().__init__()\\n\\n self.hierarchy_depth = hierarchy_depth\\n self.lstm = nn.LSTM(\\n input_size=input_size,\\n hidden_size=hidden_size,\\n num_layers=num_layers,\\n batch_first=True,\\n dropout=dropout)\\n self.linear1 = nn.Linear(hidden_size + 2 * hierarchy_depth - 2, 256)\\n self.linear2 = nn.Linear(256, 256)\\n self.linear3 = nn.Linear(256, 1)\",\n \"def forward(self,x):\\n \\n out,_ = self.lstm(x,self.hidden)\\n out = out.detach()\\n x = out[:,-1,:][-1]\\n x = self.relu(x)\\n if self.stochastic:\\n x= x+ (x- self.memory[0]).detach()* torch.rand(x.shape) * self.sigmoid(self.SM.gamma[0])\\n self.memory[0] = x.clone().detach()\\n\\n x = self.relu(self.layer1(x))\\n if self.stochastic:\\n x= x+ (x- self.memory[1]).detach()* torch.rand(x.shape) * self.sigmoid(self.SM.gamma[1])\\n self.memory[1] = x.clone().detach()\\n\\n x = self.relu(self.layer2(x))\\n if self.stochastic:\\n x= x+ (x- self.memory[2]).detach()* torch.rand(x.shape) * self.sigmoid(self.SM.gamma[2])\\n self.memory[2] = x.clone().detach()\\n\\n x = self.relu(self.layer3(x))\\n if self.stochastic:\\n x= x+ (x- self.memory[3]).detach()* torch.rand(x.shape) * self.sigmoid(self.SM.gamma[3])\\n self.memory[3] = x.clone().detach()\\n\\n x = self.relu(self.layer4(x))\\n return x\",\n \"def forward_rnn(self, inputs, state, seq_lens):\\n x = nn.functional.relu(self.fc1(inputs))\\n lstm_out = self.lstm(\\n x, [torch.unsqueeze(state[0], 0),\\n torch.unsqueeze(state[1], 0)])\\n action_out = self.action_branch(lstm_out[0])\\n self._cur_value = torch.reshape(self.value_branch(lstm_out[0]), [-1])\\n return action_out, [\\n torch.squeeze(lstm_out[1][0], 0),\\n torch.squeeze(lstm_out[1][1], 0)\\n ]\",\n \"def forward(self, inputs):\\n layer_multiplier = 2\\n if self.bidirectional == False:\\n layer_multiplier = 1\\n \\n if torch.cuda.is_available():\\n #c0 = Variable(torch.rand(self.lstm.num_layers*2, self.batch_size, self.lstm.hidden_size),requires_grad=False).cuda()\\n c0 = Variable(torch.rand(self.lstm.num_layers*layer_multiplier, 1, self.lstm.hidden_size),requires_grad=False).cuda()\\n #h0 = Variable(torch.rand(self.lstm.num_layers*2, self.batch_size, self.lstm.hidden_size),requires_grad=False).cuda()\\n h0 = Variable(torch.rand(self.lstm.num_layers*layer_multiplier, 1, self.lstm.hidden_size),requires_grad=False).cuda()\\n else:\\n #c0 = Variable(torch.rand(self.lstm.num_layers*2, self.batch_size, self.lstm.hidden_size),requires_grad=False).cuda()\\n c0 = Variable(torch.rand(self.lstm.num_layers*layer_multiplier, 1, self.lstm.hidden_size),requires_grad=False)\\n #h0 = Variable(torch.rand(self.lstm.num_layers*2, self.batch_size, self.lstm.hidden_size),requires_grad=False).cuda()\\n h0 = Variable(torch.rand(self.lstm.num_layers*layer_multiplier, 1, self.lstm.hidden_size),requires_grad=False)\\n #print(\\\"c0 \\\", c0.shape, \\\" h0 \\\", h0.shape)\\n output, (hn, cn) = self.lstm(inputs, (h0, c0))\\n #print( \\\"inputs.shape \\\", inputs.shape, output.shape )\\n \\n if self.second_lstm is not None:\\n if torch.cuda.is_available():\\n #c0 = Variable(torch.rand(self.lstm.num_layers*2, self.batch_size, self.lstm.hidden_size),requires_grad=False).cuda()\\n c0 = Variable(torch.rand(self.second_lstm.num_layers*2, 1, self.second_lstm.hidden_size),requires_grad=False).cuda()\\n #h0 = Variable(torch.rand(self.lstm.num_layers*2, self.batch_size, self.lstm.hidden_size),requires_grad=False).cuda()\\n h0 = Variable(torch.rand(self.second_lstm.num_layers*2, 1, self.second_lstm.hidden_size),requires_grad=False).cuda()\\n else:\\n #c0 = Variable(torch.rand(self.lstm.num_layers*2, self.batch_size, self.lstm.hidden_size),requires_grad=False).cuda()\\n c0 = Variable(torch.rand(self.second_lstm.num_layers*2, 1, self.second_lstm.hidden_size),requires_grad=False)\\n #h0 = Variable(torch.rand(self.lstm.num_layers*2, self.batch_size, self.lstm.hidden_size),requires_grad=False).cuda()\\n h0 = Variable(torch.rand(self.second_lstm.num_layers*2, 1, self.second_lstm.hidden_size),requires_grad=False)\\n #print(\\\"c0 \\\", c0.shape, \\\" h0 \\\", h0.shape)\\n output, (hn, cn) = self.second_lstm(output, (h0, c0))\\n \\n return output, hn, cn\",\n \"def forward(self, s):\\n # -> batch_size x seq_len\\n # apply the embedding layer that maps each token to its embedding\\n # dim: batch_size x seq_len x embedding_dim\\n s = self.embedding(s)\\n\\n # run the LSTM along the sentences of length seq_len\\n # dim: batch_size x seq_len x lstm_hidden_dim\\n s, _ = self.lstm(s)\\n\\n # make the Variable contiguous in memory (a PyTorch artefact)\\n s = s.contiguous()\\n\\n # reshape the Variable so that each row contains one token\\n # dim: batch_size*seq_len x lstm_hidden_dim\\n s = s.view(-1, s.shape[2])\\n\\n # apply the fully connected layer and obtain the output (before softmax) for each token\\n s = self.fc(s) # dim: batch_size*seq_len x num_tags\\n s = self.fc2(s)\\n s = self.fc3(s)\\n\\n # apply log softmax on each token's output (this is recommended over applying softmax\\n # since it is numerically more stable)\\n return F.log_softmax(s, dim=1) # dim: batch_size*seq_len x num_tags\",\n \"def __init__(self,feature,hidden_unit, D_in, D_out):\\n super(cnn_lstm, self).__init__()\\n self.model_ft = models.alexnet(pretrained=True)\\n # print (model_ft)\\n\\n self.num_ftrs = self.model_ft.classifier[6].in_features\\n self.feature_model = list(self.model_ft.classifier.children())\\n self.feature_model.pop()\\n self.feature_model.pop()\\n # feature_model.append(nn.Linear(num_ftrs, 3))\\n self.feature_model.append(nn.Linear(self.num_ftrs, 1046))\\n # self.feature_model.append(nn.Linear(self.num_ftrs, 524))\\n self.feature_model.append(nn.Linear(1046, 100))\\n # self.feature_model.append(nn.Linear(524, 100))\\n\\n self.model_ft.classifier = nn.Sequential(*self.feature_model)\\n\\n self.rnn = nn.LSTM(feature,hidden_unit,batch_first=True).cuda()\\n self.linear = torch.nn.Linear(D_in, D_out).cuda()\",\n \"def forward(self, x):\\n # Set initial states\\n h0_variable = torch.zeros(self.num_layers * 2, x.size(0), self.hidden_size).to(self.device)\\n c0_variable = torch.zeros(self.num_layers * 2, x.size(0), self.hidden_size).to(self.device)\\n\\n # Forward propagate LSTM\\n out, _ = self.lstm(x, (h0_variable, c0_variable))\\n\\n # Decode the hidden state of the last time step\\n out = nn.Softmax(dim=2)(self.fc(out))\\n return out\",\n \"def forward(self, x):\\r\\n h_0 = torch.zeros(\\r\\n self.num_layers, x.size(0), self.hidden_size).to(device)\\r\\n\\r\\n c_0 = torch.zeros(\\r\\n self.num_layers, x.size(0), self.hidden_size).to(device)\\r\\n\\r\\n # Propagate input through LSTM\\r\\n ula, (h_out, _) = self.lstm(x, (h_0, c_0))\\r\\n\\r\\n h_out = h_out.view(-1, self.hidden_size)\\r\\n\\r\\n out = self.fc(h_out)\\r\\n\\r\\n return out\",\n \"def forward(self, x):\\r\\n \\r\\n out, self.hidden_state = self.lstm(\\r\\n x, self.hidden_state)\\r\\n \\r\\n self.hidden_state = tuple(\\r\\n [h.detach() for h in self.hidden_state])\\r\\n \\r\\n out = self.linear(out)\\r\\n \\r\\n # Add the average of the last two points in the chunk to the\\r\\n # output value so that the model doesn't have to predict\\r\\n # the actual next value in the sequence, but just the change\\r\\n # from the last two points. This makes the predictions more \\r\\n # likely to be close to the previous value, which is expected\\r\\n # for smoothly changing data like EXAFS.\\r\\n return out.squeeze()+x[:,:,-2:].mean(dim=-1)\",\n \"def forward(self, input=None):\\n self._repackage()\\n if (input is not None) and (self.result is None):\\n if self.G.ntype == \\\"lstm\\\":\\n self.result, both = self.node(input, (self.hidden, self.state))\\n self.hidden, self.state = both\\n else:\\n self.result, self.hidden = self.node(input, self.hidden)\\n\\n # Pull the input from previous network layers\\n elif self.result is None:\\n in_result = []\\n for n in self.input:\\n in_result.append( n() )\\n\\n # Concatenate input along the dim input_size\\n if self.G.ntype == \\\"lstm\\\":\\n self.result, both = self.node(torch.cat(in_result, 2), (self.hidden, self.state))\\n self.hidden, self.state = both\\n else:\\n self.result, self.hidden = self.node(torch.cat(in_result, 2), self.hidden)\\n\\n return self.result.view(*self.G.d_out)\",\n \"def forward(self, prev_state, obs_t):\\r\\n # Use your network to compute qvalues for given state\\r\\n #print(state_t.shape)\\r\\n h = self.conv(obs_t)\\r\\n\\r\\n h = h.view(h.size(0), -1)\\r\\n\\r\\n new_state = h_new, c_new = self.lstm(h, prev_state)\\r\\n advantage = self.adv(h_new)\\r\\n value = self.val(h_new)\\r\\n\\r\\n\\r\\n adv_mean = torch.mean(advantage, dim=1, keepdim=True)\\r\\n qvalues = value + advantage - adv_mean\\r\\n\\r\\n return new_state, qvalues\",\n \"def apply_lstm(x, seq_len):\\n return cudnn_layers.stacked_bilstm(\\n input_emb=x,\\n input_len=seq_len,\\n hidden_size=FLAGS.lstm_dim,\\n num_layers=1,\\n dropout_ratio=0.0,\\n mode=tf_estimator.ModeKeys.TRAIN,\\n use_cudnn=None)\",\n \"def __init__(self, incoming, n_units,\\n W_ci=tf.zeros, W_ig=tf.zeros, W_og=tf.zeros, W_fg=tf.zeros,\\n b_ci=tf.zeros, b_ig=tf.zeros, b_og=tf.zeros, b_fg=tf.zeros,\\n a_ci=tf.tanh, a_ig=tf.sigmoid, a_og=tf.sigmoid, a_fg=tf.sigmoid, a_out=tf.identity,\\n c_init=tf.zeros, h_init=tf.zeros, learn_c_init=False, learn_h_init=False, forgetgate=True,\\n output_dropout=False, store_states=False, return_states=False, precomp_fwds=False,\\n tickerstep_biases=None, learn_tickerstep_biases=True, name='LSTM'):\\n super(LSTMLayerGetNetInput, self).__init__()\\n with tf.variable_scope(name) as self.layer_scope:\\n self.incoming, self.incoming_shape = get_input(incoming)\\n self.n_units = n_units\\n self.lstm_inlets = ['ci', 'ig', 'og', 'fg']\\n if return_states:\\n store_states = True\\n \\n #\\n # Initialize weights and biases\\n #\\n \\n # Turn W inits into lists [forward_pass, backward_pass]\\n W_ci, W_ig, W_og, W_fg = [v[:2] if isinstance(v, list) else [v, v] for v in [W_ci, W_ig, W_og, W_fg]]\\n \\n # Make W and b tf variables\\n W_ci, W_ig, W_og, W_fg = [\\n [tofov(v[0], shape=[self.incoming_shape[-1], n_units], var_params=dict(name=n + '_fwd')),\\n tofov(v[1], shape=[n_units, n_units], var_params=dict(name=n + '_bwd'))]\\n for v, n in zip([W_ci, W_ig, W_og, W_fg], ['W_ci', 'W_ig', 'W_og', 'W_fg'])]\\n b_ci, b_ig, b_og, b_fg = [tofov(v, shape=[n_units], var_params=dict(name=n)) for v, n in\\n zip([b_ci, b_ig, b_og, b_fg], ['b_ci', 'b_ig', 'b_og', 'b_fg'])]\\n \\n # Pack weights for fwd and bwd connections\\n W_fwd_conc = tf.concat(axis=1, values=[W[0] for W in [W_ci, W_ig, W_og, W_fg]])\\n W_bwd_conc = tf.concat(axis=1, values=[W[1] for W in [W_ci, W_ig, W_og, W_fg]])\\n \\n if not forgetgate:\\n print(\\\"Warning: Setting forgetgate to 0 has not been tested yet, please set the W and b manually \\\"\\n \\\"to not-trainable tensorflow variables!\\\")\\n \\n def a_fg(x):\\n return tf.ones(x.get_shape().as_list())\\n \\n # Initialize bias for tickersteps\\n if tickerstep_biases is not None:\\n self.W_tickers = OrderedDict(zip_longest(self.lstm_inlets,\\n [tofov(tickerstep_biases, shape=[n_units],\\n var_params=dict(name='W_tickers_' + g,\\n trainable=learn_tickerstep_biases))\\n for g in self.lstm_inlets]))\\n else:\\n self.W_tickers = None\\n \\n #\\n # Create mask for output dropout\\n # apply dropout to n_units dimension of outputs, keeping dropout mask the same for all samples,\\n # sequence positions, and pixel coordinates\\n #\\n output_shape = self.get_output_shape()\\n if output_dropout:\\n out_do_mask = tf.ones(shape=[output_shape[0], output_shape[-1]],\\n dtype=tf.float32)\\n out_do_mask = tf.nn.dropout(out_do_mask, keep_prob=1. - output_dropout,\\n noise_shape=[1, output_shape[-1]])\\n \\n def out_do(x):\\n \\\"\\\"\\\"Function for applying dropout mask to outputs\\\"\\\"\\\"\\n if output_dropout:\\n return out_do_mask * x\\n else:\\n return x\\n \\n # Redefine a_out to include dropout (sneaky, sneaky)\\n a_out_nodropout = a_out\\n \\n def a_out(x):\\n return a_out_nodropout(out_do(x))\\n \\n #\\n # Handle initializations for h (hidden states) and c (cell states) as Variable\\n #\\n h_init = out_do(tofov(h_init, shape=[output_shape[0], output_shape[-1]],\\n var_params=dict(name='h_init', trainable=learn_h_init)))\\n c_init = tofov(c_init, shape=[output_shape[0], output_shape[-1]],\\n var_params=dict(name='h_init', trainable=learn_c_init))\\n \\n # Initialize lists to store LSTM activations and cell states later\\n h = [h_init]\\n c = [c_init]\\n \\n self.precomp_fwds = precomp_fwds\\n self.store_states = store_states\\n self.return_states = return_states\\n \\n self.W_fwd = OrderedDict(zip(self.lstm_inlets, [W[0] for W in [W_ci, W_ig, W_og, W_fg]]))\\n self.W_bwd = OrderedDict(zip(self.lstm_inlets, [W[1] for W in [W_ci, W_ig, W_og, W_fg]]))\\n \\n self.W_fwd_conc = W_fwd_conc\\n self.W_bwd_conc = W_bwd_conc\\n self.a = OrderedDict(zip(self.lstm_inlets, [a_ci, a_ig, a_og, a_fg]))\\n self.a['out'] = a_out\\n self.b = OrderedDict(zip(self.lstm_inlets, [b_ci, b_ig, b_og, b_fg]))\\n self.h = h\\n self.c = c\\n self.external_rec = None\\n \\n self.ig = []\\n self.og = []\\n self.ci = []\\n self.fg = []\\n \\n self.out = tf.expand_dims(h_init, 1)\\n self.name = name\\n \\n self.cur_net_fwd = dot_product(tf.zeros(self.incoming_shape[:1] + self.incoming_shape[2:]),\\n tf.zeros(self.W_fwd_conc.shape.as_list()))\",\n \"def forward(self, x, hidden):\\n emb_x = self.emb_layer(x)\\n lstm_out, hidden = self.lstm(emb_x, hidden)\\n if self.bidirectional:\\n # separate to forward and backward\\n # following code reshapes LSTM output to:\\n # (batch size, seq length, num directions, hidden dimensions)\\n # where direction '0' is forward and direction '1' is backward\\n lstm_out = lstm_out.contiguous().view(-1, self.seq_len, 2, self.hidden_dim)\\n # get backward output in first node\\n lstm_out_bw = lstm_out[:, 0, 1, :]\\n # get forward output in last node\\n lstm_out_fw = lstm_out[:, -1, 0, :]\\n # we may simple concatenate forward & backward outputs,\\n # or add them, multiply or average; in this case i used average\\n lstm_out = torch.add(input=lstm_out_bw, alpha=1, other=lstm_out_fw)\\n lstm_out = torch.div(lstm_out, 2)\\n else:\\n lstm_out = lstm_out[:, -1]\\n \\n assert lstm_out.shape[-1] == self.hidden_dim, (lstm_out.shape, self.hidden_dim)\\n lstm_out = lstm_out.contiguous().view(-1, self.hidden_dim)\\n \\n d_out = self.dropout(lstm_out)\\n fc_out = self.output_layer(d_out)\\n sig_out = torch.sigmoid(fc_out)\\n \\n # return last sigmoid output and hidden state\\n return sig_out, hidden\",\n \"def __init__(self, incoming, n_units,\\n W_ci=tf.zeros, W_ig=tf.zeros, W_og=tf.zeros, W_fg=tf.zeros,\\n b_ci=tf.zeros, b_ig=tf.zeros, b_og=tf.zeros, b_fg=tf.zeros,\\n a_ci=tf.tanh, a_ig=tf.sigmoid, a_og=tf.sigmoid, a_fg=tf.sigmoid, a_out=tf.identity,\\n c_init=tf.zeros, h_init=tf.zeros, learn_c_init=False, learn_h_init=False, forgetgate=True,\\n output_dropout=False, store_states=False, return_states=False, precomp_fwds=False,\\n tickerstep_biases=None, learn_tickerstep_biases=True, name='LSTM'):\\n super(LSTMLayerSetNetInput, self).__init__()\\n with tf.variable_scope(name) as self.layer_scope:\\n self.incoming, self.incoming_shape = get_input(incoming)\\n self.n_units = n_units\\n self.lstm_inlets = ['ci', 'ig', 'og', 'fg']\\n if return_states:\\n store_states = True\\n \\n # Make W and b tf variables\\n W_ci, W_ig, W_og, W_fg = [\\n tofov(v, shape=[n_units, n_units], var_params=dict(name=n + '_bwd'))\\n for v, n in zip([W_ci, W_ig, W_og, W_fg], ['W_ci', 'W_ig', 'W_og', 'W_fg'])]\\n b_ci, b_ig, b_og, b_fg = [tofov(v, shape=[n_units], var_params=dict(name=n)) for v, n in\\n zip([b_ci, b_ig, b_og, b_fg], ['b_ci', 'b_ig', 'b_og', 'b_fg'])]\\n \\n # Pack weights for bwd connections\\n W_bwd_conc = tf.concat(axis=1, values=[W_ci, W_ig, W_og, W_fg])\\n \\n if not forgetgate:\\n print(\\\"Warning: Setting forgetgate to 0 has not been tested yet, please set the W and b manually \\\"\\n \\\"to not-trainable tensorflow variables!\\\")\\n \\n def a_fg(x):\\n return tf.ones(x.get_shape().as_list())\\n \\n # Initialize bias for tickersteps\\n if tickerstep_biases is not None:\\n self.W_tickers = OrderedDict(zip_longest(self.lstm_inlets,\\n [tofov(tickerstep_biases, shape=[n_units],\\n var_params=dict(name='W_tickers_' + g,\\n trainable=learn_tickerstep_biases))\\n for g in self.lstm_inlets]))\\n else:\\n self.W_tickers = None\\n \\n #\\n # Create mask for output dropout\\n # apply dropout to n_units dimension of outputs, keeping dropout mask the same for all samples,\\n # sequence positions, and pixel coordinates\\n #\\n output_shape = self.get_output_shape()\\n if output_dropout:\\n out_do_mask = tf.ones(shape=[output_shape[0], output_shape[-1]],\\n dtype=tf.float32)\\n out_do_mask = tf.nn.dropout(out_do_mask, keep_prob=1. - output_dropout,\\n noise_shape=[1, output_shape[-1]])\\n \\n def out_do(x):\\n \\\"\\\"\\\"Function for applying dropout mask to outputs\\\"\\\"\\\"\\n if output_dropout:\\n return out_do_mask * x\\n else:\\n return x\\n \\n # Redefine a_out to include dropout (sneaky, sneaky)\\n a_out_nodropout = a_out\\n \\n def a_out(x):\\n return a_out_nodropout(out_do(x))\\n \\n #\\n # Handle initializations for h (hidden states) and c (cell states) as Variable\\n #\\n h_init = out_do(tofov(h_init, shape=[output_shape[0], output_shape[-1]],\\n var_params=dict(name='h_init', trainable=learn_h_init)))\\n c_init = tofov(c_init, shape=[output_shape[0], output_shape[-1]],\\n var_params=dict(name='h_init', trainable=learn_c_init))\\n \\n # Initialize lists to store LSTM activations and cell states later\\n h = [h_init]\\n c = [c_init]\\n \\n self.precomp_fwds = precomp_fwds\\n self.store_states = store_states\\n self.return_states = return_states\\n \\n self.W_fwd = OrderedDict(zip(self.lstm_inlets, [None, None, None, None]))\\n self.W_bwd = OrderedDict(zip(self.lstm_inlets, [W_ci, W_ig, W_og, W_fg]))\\n \\n self.W_fwd_conc = None\\n self.W_bwd_conc = W_bwd_conc\\n self.a = OrderedDict(zip(self.lstm_inlets, [a_ci, a_ig, a_og, a_fg]))\\n self.a['out'] = a_out\\n self.b = OrderedDict(zip(self.lstm_inlets, [b_ci, b_ig, b_og, b_fg]))\\n self.h = h\\n self.c = c\\n self.external_rec = None\\n \\n self.ig = []\\n self.og = []\\n self.ci = []\\n self.fg = []\\n \\n self.out = tf.expand_dims(h_init, 1)\\n self.name = name\",\n \"def forward(self, inputs, mode):\\n self.hidden = self.init_hidden() \\n\\n if mode == 'a':\\n\\n embedding_word = self.embedding(inputs).view(self.embedding.shape.size())\\n lstm_out, self.hidden = self.lstm_words(embedding_word.view(len(inputs), 1, -1), self.hidden)\\n softmax_out = self.softmax(self.fc(lstm_out)) \\n\\n if mode == 'b':\\n \\n embed_chars = self.embedding_chars(inputs).view(self.embedding_chars.shape.size()) \\n lstm_out_chars, self.hidden = self.lstm_chars(embed_chars.view(len(inputs), 1, -1),self.hidden) \\n softmax_out = self.softmax(self.fc(lstm_out_chars))\\n\\n if mode == 'c': \\n\\n embedding_prefix = self.embeds_prefix(inputs[0]).view(self.embeds_prefix.shape.size())\\n lstm_out_prefix, self.hidden = self.lstm_prefix(embedding_prefix.view(len(inputs[0]), 1, -1), self.hidden)\\n embedding_suffix = self.embeds_suffix(inputs[1]).view(self.embeds_suffix.shape.size())\\n lstm_out_suffix, self.hidden = self.lstm_suffix(embedding_suffix.view(len(inputs[1]), 1, -1), self.hidden)\\n lstm_out = lstm_out_prefix+lstm_out_suffix\\n softmax_out = self.softmax(self.fc(lstm_out)) \\n\\n if mode == 'd': \\n\\n embedding_c_words = self.embedding_concat_words(inputs[0]).view(self.embedding_concat_words.shape.size())\\n embedding_c_chars = self.embedding_concat_chars(inputs[1]).view(self.embedding_concat_chars.shape.size())\\n concat_input = torch.cat((embedding_c_words, embedding_c_chars),1)\\n lstm_out, self.hidden = self.lstm_concat(concat_input.view(100 , 1, -1), self.hidden)\\n softmax_out = self.softmax(self.fc(lstm_out)) \\n\\n return softmax_out, self.hidden\",\n \"def LSTM_train(X_train, Y_train, X_dev, Y_dev, R_train, R_dev, hyperparams):\",\n \"def forward(self, state):\\n x = F.relu(self.input(state))\\n for layer in self.layers:\\n x = F.relu(layer(x))\\n if self.duel:\\n # Value function estimator\\n val = F.relu(self.val_fc_input(x))\\n val = self.val_fc_output(val)\\n # Advantage function estimator\\n adv = F.relu(self.adv_fc_input(x))\\n adv = self.adv_fc_output(adv)\\n # Subtract mean so that V and A are uniquely identifiable for a given Q\\n return val + adv - adv.mean(1).unsqueeze(1).expand(state.size(0), self.action_size)\\n else:\\n return self.output(x)\",\n \"def forward(self, inputs):\\n # unpack\\n x, lengths = pad_packed_sequence(inputs, batch_first=True)\\n # x is (batch, slen)\\n x = self.embed(x) # x is (batch, seq, dim_e)\\n # but we need x to be (slen, batch, dim_e)\\n x = x.transpose(0, 1)\\n\\n # rnn\\n x = pack_padded_sequence(x, lengths, batch_first=False)\\n x, (_, _) = self.lstm(x)\\n # x is (slen, batch, num_directions * hidden_size)\\n x, lengths = pad_packed_sequence(x, batch_first=False)\\n # turn into batch first (batch, slen, num_dirs * hiddden)\\n # and then (batch, num_dirs * hidden, slen)\\n x = x.transpose(0, 1).transpose(1, 2)\\n x = F.relu(x)\\n x = F.max_pool1d(x, x.size(2)) # (batch, num_dirs * hidden, 1)\\n x = x.squeeze(2)\\n\\n # do some dropout\\n x = self.dropout(x)\\n # map to classes\\n x = self.output(x)\\n return x\",\n \"def forward(self, X, A, beta=1, print_output=False):\\n assert X.size(0) == A.size(0) + 1, print('the seq length of X and A are wrong')\\n kl_loss = 0 # KL divergence term\\n Ell_loss = 0 # expected log likelihood term\\n batch_size = X.size(1)\\n\\n if len(X.size()) != 3:\\n print('The input data matrix should be the shape of [seq_length, batch_size, input_dim]')\\n\\n X = X.to(self.device)\\n A = A.to(self.device)\\n\\n # container\\n states = torch.zeros(A.size(0), A.size(1), self.state_size).to(self.device) # [seq-1, batch, state]\\n rnn_hiddens = torch.zeros(A.size(0), A.size(1), self.hidden_size).to(self.device) # [seq-1, batch, hidden]\\n\\n # initialising state and rnn hidden state\\n # state = torch.zeros(X.size(1), self.state_size).to(self.device)\\n rnn_hidden = self.init_h(X[0]).to(self.device) # [batch, hidden]\\n if self.mode == 'LSTM':\\n rnn_hidden_c = torch.zeros_like(rnn_hidden).to(self.device) # [batch, hidden]\\n\\n # temp_prior = self.hidden_prior(rnn_hidden) #[batch, state]\\n temp_prior = rnn_hidden\\n prior_mean = self.prior_mean(temp_prior) # [batch, state]\\n prior_sigma = torch.exp(self.prior_sigma(temp_prior)) # [batch, state]\\n state = self.reparametrise(prior_mean, prior_sigma) # [batch, state]\\n\\n # rnn_hidden = torch.zeros(X.size(1), self.hidden_size).to(self.device)\\n\\n # emission_mean = X[0]\\n for t in range(1, X.size()[\\n 0]): # for each time step, compute the free energy for each batch of data (start from the second hid state)\\n if self.mode == 'LSTM':\\n next_state_prior_m, next_state_prior_sigma, rnn_hidden, rnn_hidden_c = self.prior(state,\\n A[t - 1].unsqueeze(\\n -1),\\n rnn_hidden,\\n rnn_hidden_c)\\n else:\\n next_state_prior_m, next_state_prior_sigma, rnn_hidden = self.prior(state, A[t - 1].unsqueeze(-1),\\n rnn_hidden)\\n\\n next_state_post_m, next_state_post_sigma = self.posterior(rnn_hidden, X[t])\\n state = self.reparametrise(next_state_post_m, next_state_post_sigma) # [batch, state_size]\\n states[t - 1] = state\\n rnn_hiddens[t - 1] = rnn_hidden\\n next_state_prior = Normal(next_state_prior_m, next_state_prior_sigma)\\n next_state_post = Normal(next_state_post_m, next_state_post_sigma)\\n\\n # kl = kl_divergence(next_state_prior, next_state_post).sum(dim=1) #[batch]\\n kl = kl_divergence(next_state_post, next_state_prior).sum(dim=1) # [batch]\\n\\n kl_loss += kl.mean()\\n kl_loss /= A.size(0)\\n\\n # compute nll\\n\\n # flatten state\\n flatten_states = states.view(-1, self.state_size)\\n flatten_rnn_hiddens = rnn_hiddens.view(-1, self.hidden_size)\\n flatten_x_mean, flatten_x_sigma = self.obs_model(flatten_states, flatten_rnn_hiddens)\\n\\n nll = self.batched_gaussian_ll(flatten_x_mean, flatten_x_sigma, X[1:, :, :].reshape(-1, self.output_size))\\n nll = nll.mean()\\n\\n FE = nll - kl_loss\\n\\n if print_output:\\n # print('ELL loss=', Ell_loss, 'KL loss=', kl_loss)\\n print('Free energy of this batch = {}. Nll loss = {}. KL div = {}.'.format(float(FE.data)\\n , float(nll.data),\\n float(kl_loss.data)))\\n\\n return FE, nll, kl_loss\",\n \"def lstm_forward(x, h0, Wx, Wh, b):\\n h, cache = None, None\\n #############################################################################\\n # TODO: Implement the forward pass for an LSTM over an entire timeseries. #\\n # You should use the lstm_step_forward function that you just defined. #\\n #############################################################################\\n\\n N,T,D = x.shape\\n N,H = h0.shape\\n prev_h = h0\\n prev_c = np.zeros((N, H))\\n\\n h = np.zeros((N, T, H))\\n cache = list()\\n\\n for t in range(T):\\n next_h, next_c, t_cache = lstm_step_forward(x[:,t,:],prev_h,prev_c,Wx,Wh,b)\\n prev_h = next_h\\n prev_c = next_c\\n h[:,t,:] = next_h\\n cache.append(t_cache)\\n ##############################################################################\\n # END OF YOUR CODE #\\n ##############################################################################\\n\\n return h, cache\",\n \"def the_nn_article(input_size, dropout):\\n \\n class Model(nn.Module):\\n def __init__(self):\\n super(Model, self).__init__()\\n \\n # Defining layers\\n self.hidden_size = 256\\n self.first_layer = 512\\n self.second_layer = 1024\\n self.n_layers = 2\\n self.bidirectional = True\\n self.dropout = dropout\\n \\n # RNN Layer\\n self.rnn = nn.LSTM(input_size = input_size, hidden_size = self.hidden_size, \\n num_layers = self.n_layers, batch_first = True, \\n bidirectional = self.bidirectional, dropout = self.dropout)\\n \\n self.fc1 = nn.Linear(self.first_layer, self.second_layer)\\n self.fc2 = nn.Linear(self.second_layer, 3)\\n \\n def forward(self, x):\\n batch_size = x.size(0)\\n \\n #Initializing hidden state for first input using method defined below\\n hidden = self.init_hidden(batch_size, self.hidden_size)\\n \\n # Find sequence lengths (for packing)\\n x_lengths = self.find_lengths(x)\\n \\n # Pack sequences\\n x = torch.nn.utils.rnn.pack_padded_sequence(x, x_lengths, batch_first=True, enforce_sorted=False)\\n\\n # Run the network\\n out, hidden = self.rnn(x, hidden)\\n \\n # Unpack the sequences again\\n out, _ = torch.nn.utils.rnn.pad_packed_sequence(out, batch_first=True)\\n\\n # Run through the linear layer\\n out = F.relu(self.fc1(out))\\n out = F.relu(self.fc2(out))\\n \\n # Perform log_softmax on output (WORSE PERFORMANCE!)\\n #x = F.log_softmax(x, dim = 2)\\n\\n return out, hidden\\n \\n def init_hidden(self, batch_size, hidden_size):\\n # This method generates the first hidden state of zeros which we'll use in the forward pass\\n \\n hidden = (torch.zeros(2*self.n_layers, batch_size, self.hidden_size),\\n torch.zeros(2*self.n_layers, batch_size, self.hidden_size))\\n \\n return hidden\\n \\n def find_lengths(self, input_seq):\\n # Find seq-lengths of each sequence (used to pack sequences)\\n x_lengths = []\\n for seq in input_seq:\\n for idx, vec in enumerate(seq):\\n if sum(vec).item() != 1:\\n x_lengths.append(idx)\\n break\\n if idx == 752:\\n x_lengths.append(len(seq)) \\n return x_lengths\\n \\n net = Model()\\n return net\",\n \"def forward(self, x):\\n #delete all cts\\n #self.cts = [self.cts[-1]]\\n \\n #forward\\n length, batch, dim = x.shape\\n res = []\\n res.append(self.one_step(x[0], torch.zeros((batch, self.latent_size), dtype=torch.float)))\\n\\n for i in range(1,length):\\n res.append(self.one_step(x[i], res[i-1]))\\n\\n return torch.stack(res)\",\n \"def forward(self, x):\\r\\n out = self.conv(x) # out with shape\\r\\n out, _ = self.lstm(out.permute(2, 0, 1, 3, 4).contiguous().view(self.seq_len, -1, 64 * 1 * 4))\\r\\n out = torch.mean(out.permute(1, 0, 2), 1) # [batch, num_directions * hidden_size]\\r\\n if self.embed:\\r\\n return out\\r\\n else:\\r\\n logits = self.linear(out)\\r\\n return logits, out\",\n \"def __init__(self, input_dim, hidden_dim, output_dim):\\r\\n super(LstmEstimator, self).__init__()\\r\\n \\r\\n # The LSTM takes track features as inputs, and outputs hidden states\\r\\n # with dimensionality hidden_dim\\r\\n self.lstm = nn.LSTM(input_dim, hidden_dim)\\r\\n \\r\\n self.hidden2target = nn.Linear(hidden_dim, output_dim)\",\n \"def forward_trajectory(self,x0,U,predictive_var = False):\\n ns = np.shape(x0)[0]\\n nu, T = np.shape(U) \\n \\n x_ii = x0.T\\n \\n \\n \\n \\n grad_state = np.zeros((T,ns,ns))\\n grad_control = np.zeros((T,ns,nu))\\n states = np.zeros((T,ns))\\n variances = np.zeros((T,ns))\\n\\n\\n for ii in range(T):\\n \\n #state_action = x_ii\\n state_action = np.append(x_ii,U[:,ii]).reshape((1,-1))\\n print(np.shape(state_action))\\n\\n \\n if predictive_var:\\n new_state_grads,new_state,new_state_var = self.predictive_gradients(state_action,predictive_var = True)\\n variances[ii] = new_state_var\\n else:\\n \\n new_state_grads,new_state = self.predictive_gradients(state_action,predictive_var = False)\\n print(new_state_grads)\\n print(new_state)\\n grad_state[ii,:,:] = new_state_grads[:,np.arange(ns)]\\n grad_control[ii,:,:] = new_state_grads[:,np.arange(ns+1,ns+nu)]\\n\\n states[ii,:] = new_state\\n\\n x_ii = new_state.T\\n \\n if predictive_var:\\n return grad_state,grad_control,states,variances\\n \\n return grad_state,grad_control,states\",\n \"def __call__(self, inputs, state):\\n with tf.variable_scope(\\\"BayesLSTMCell\\\"):\\n if self.w is None:\\n\\n# size = inputs.get_shape()[-1].value\\n \\n print ([\\\"------- Size input LSTM: \\\", inputs.shape])\\n print ([\\\"------- Dim input specified \\\", self.X_dim])\\n# print ([\\\"num units LSTM: \\\", self.num_units])\\n \\n self.w = VI.sample_posterior((self.X_dim + self.num_units, 4 * self.num_units),\\n name=self.n + \\\"_weights\\\",\\n prior=self.prior,\\n is_training=self.is_training)\\n \\n self.b = VI.sample_posterior((4 * self.num_units, 1),\\n name=self.n + \\\"_biases\\\",\\n prior=self.prior,\\n is_training=self.is_training)\\n\\n # Get the cell and hidden state from the previous cell [C_t-1, h_t-1]\\n C_t_prev , h_t_prev = state\\n #Vector concatenation of previous hidden state and embedded inputs\\n concat_inputs_hidden = tf.concat([inputs, h_t_prev], 1)\\n # Compute the Z = Wx + b for each of the 4 networks at once !\\n gate_inputs = tf.nn.bias_add(tf.matmul(concat_inputs_hidden, self.w), tf.squeeze(self.b))\\n \\n # Split data up for the 4 gates\\n # i = input_gate, j = new_input, f = forget_gate, o = output_gate\\n i, j, f, o = tf.split(value=gate_inputs, num_or_size_splits=4, axis=1)\\n\\n # Compute the new cell \\n C_t = (C_t_prev * tf.sigmoid(f + self._forget_bias) + tf.sigmoid(i)*self._activation(j))\\n h_t = self._activation(C_t) * tf.sigmoid(o)\\n \\n #Create tuple of the new state\\n State_t = LSTMStateTuple(C_t, h_t)\\n\\n return h_t, State_t\",\n \"def forward(self, state):\\r\\n x = F.relu(self.linear1(state))\\r\\n x = F.relu(self.linear2(x))\\r\\n #x = torch.tanh(self.linear3(x))\\r\\n #x = F.relu(self.linear3(x))\\r\\n #x = nn.LeakyReLU(self.linear3(x), negative_slope=0.1)# .negativ_slope nur für leakyReLU relevant\\r\\n x = F.leaky_relu(self.linear3(x), 0.1)\\r\\n #x = F.softmax(self.linear3(x), dim=0)\\r\\n \\r\\n return x#.negativ_slope\",\n \"def forward(self, X, X_lens):\\n\\n\\t\\t# get the batch size and sequence length (max length of the batch)\\n\\t\\t# dim of X: batch_size x batch_max_len x input feature vec dim\\n\\t\\tbatch_size, seq_len, _ = X.size()\\n\\n\\t\\t###Your code here --\\n\\t\\t# Get the output of LSTM - (output dim: batch_size x batch_max_len x lstm_hidden_dim)\\n\\t\\thid, _ = self.lstm(X)\\n\\t\\t# print('hid \\\\n{}'.format(hid))\\n\\n\\t\\t# reshape (before passing to linear layer) so that each row contains one token\\n\\t\\t# essentially, flatten the output of LSTM\\n\\t\\t# dim will become batch_size*batch_max_len x lstm_hidden_dim\\n\\t\\thid_flat = hid.contiguous().view(hid.shape[0] * hid.shape[1], hid.shape[2])\\n\\t\\t# print('hid_flat \\\\n{}'.format(hid_flat))\\n\\n\\t\\t# Get logits from the final linear layer\\n\\t\\tlogits = self.hidden_to_label(hid_flat)\\n\\t\\t# print('logits \\\\n {}'.format(logits))\\n\\t\\t# print('logits shape {}, hid shape {}, hid_flat shape {}'.format(logits.shape, hid.shape, hid_flat.shape))\\n\\t\\t# --shape of logits -> (batch_size, seq_len, self.n_output)\\n\\t\\treturn logits\",\n \"def __init__(self, incoming, n_units, W_ci, W_ig, W_og, W_fg,\\n b_ci=tf.zeros, b_ig=tf.zeros, b_og=tf.zeros, b_fg=tf.zeros,\\n a_ci=tf.tanh, a_ig=tf.sigmoid, a_og=tf.sigmoid, a_fg=tf.sigmoid, a_out=tf.nn.elu,\\n c_init=tf.zeros, h_init=tf.zeros, learn_c_init=False, learn_h_init=False, forgetgate=True, comb='add',\\n store_states=False, return_states=False, output_dropout=False, precomp_fwds=True, W_red_rec=None,\\n a_reduce_recurrents=None, tickerstep_biases=None, learn_tickerstep_biases=True,\\n dilation_rate=(1, 1), name='ConvLSTMLayer'):\\n super(ConvLSTMLayer, self).__init__()\\n with tf.variable_scope(name) as self.layer_scope:\\n self.incoming, self.incoming_shape = get_input(incoming)\\n self.n_units = n_units\\n self.lstm_inlets = ['ci', 'ig', 'og', 'fg']\\n if return_states:\\n store_states = True\\n \\n #\\n # Initialize weights and biases\\n #\\n \\n # Turn W inits into lists [forward_pass, backward_pass]\\n W_ci, W_ig, W_og, W_fg = [v[:2] if isinstance(v, list) else [v, v] for v in [W_ci, W_ig, W_og, W_fg]]\\n \\n # Check if feature dimensions to produce agree for all weight windows with n_units\\n W_dims = [[w[0].get_shape().as_list()[3], w[1].get_shape().as_list()[3]] for w in [W_ci, W_ig, W_og, W_fg]]\\n W_dims = np.array(W_dims).flatten()\\n if np.any(W_dims != n_units):\\n raise ValueError(\\\"Feature dimensions to produce must agree with n_units!\\\")\\n \\n # TODO: make all gates optional (list with keys and function for splitting)\\n if not forgetgate:\\n def a_fg(x):\\n return tf.ones(x.get_shape().as_list())\\n \\n # Make W and b tf variables\\n W_ci, W_ig, W_og, W_fg = [[tofov(w, shape=None, var_params=dict(name=n + suffix)) for w, suffix in\\n zip(v, ['_fwd', '_bwd'])] for v, n in\\n zip([W_ci, W_ig, W_og, W_fg], ['W_ci', 'W_ig', 'W_og', 'W_fg'])]\\n b_ci, b_ig, b_og, b_fg = [tofov(b, shape=[n_units], var_params=dict(name=n)) for b, n in\\n zip([b_ci, b_ig, b_og, b_fg], ['b_ci', 'b_ig', 'b_og', 'b_fg'])]\\n \\n # Pack weights for fwd and bwd connections by concatenating them at sliding mask feature dimension\\n # TODO: enable parallel calculation on multi-gpu\\n W_fwd_conc = tf.concat(axis=3, values=[W[0] for W in [W_ci, W_ig, W_og, W_fg]], name='W_fwd_conc')\\n W_bwd_conc = tf.concat(axis=3, values=[W[1] for W in [W_ci, W_ig, W_og, W_fg]], name='W_bwd_conc')\\n \\n # Initialize kernel for reducing recurrent features\\n self.reduce_recurrents = None\\n self.W_red_rec = W_red_rec\\n if a_reduce_recurrents is not None:\\n self.W_red_rec = tofov(W_red_rec, var_params=dict(name='W_red_rec'))\\n \\n def reduce_recurrents(h_prev):\\n \\\"\\\"\\\"Reduces features of internal recurrent connections h_prev\\\"\\\"\\\"\\n return a_reduce_recurrents(conv2d(h_prev, self.W_red_rec))\\n \\n self.reduce_recurrents = reduce_recurrents\\n \\n # Initialize bias for tickersteps\\n if tickerstep_biases is not None:\\n self.W_tickers = OrderedDict(zip_longest(self.lstm_inlets,\\n [tofov(tickerstep_biases, shape=[n_units],\\n var_params=dict(name='W_tickers_' + g,\\n trainable=learn_tickerstep_biases))\\n for g in self.lstm_inlets]))\\n else:\\n self.W_tickers = None\\n \\n #\\n # Create mask for output dropout\\n # apply dropout to n_units dimension of outputs, keeping dropout mask the same for all samples,\\n # sequence positions, and pixel coordinates\\n #\\n output_shape = self.get_output_shape()\\n if output_dropout:\\n out_do_mask = tf.ones(shape=[output_shape[0], output_shape[2], output_shape[3], output_shape[4]],\\n dtype=tf.float32, name='out_do_mask')\\n out_do_mask = tf.nn.dropout(out_do_mask, keep_prob=1. - output_dropout,\\n noise_shape=[1, 1, 1, output_shape[4]])\\n \\n def out_do(x):\\n \\\"\\\"\\\"Function for applying dropout mask to outputs\\\"\\\"\\\"\\n if output_dropout:\\n return out_do_mask * x\\n else:\\n return x\\n \\n # Redefine a_out to include dropout (sneaky, sneaky)\\n a_out_nodropout = a_out\\n \\n def a_out(x):\\n return a_out_nodropout(out_do(x))\\n \\n #\\n # Handle initializations for h (outputs) and c (cell states) as Variable if overwriteable or tensor if not\\n # shape=(samples, x, y, n_units)\\n #\\n h_init = out_do(tofov(h_init, shape=[output_shape[0], output_shape[2], output_shape[3], output_shape[4]],\\n var_params=dict(trainable=learn_h_init)))\\n c_init = tofov(c_init, shape=[output_shape[0], output_shape[2], output_shape[3], output_shape[4]],\\n var_params=dict(trainable=learn_c_init))\\n \\n # Initialize lists to store LSTM activations and cell states\\n h = [h_init] # [-1, x, y, n_units]\\n c = [c_init] # [-1, x, y, n_units]\\n \\n self.precomp_fwds = precomp_fwds\\n self.store_states = store_states\\n self.return_states = return_states\\n \\n self.W_fwd = OrderedDict(zip(self.lstm_inlets, [W[0] for W in [W_ci, W_ig, W_og, W_fg]]))\\n self.W_bwd = OrderedDict(zip(self.lstm_inlets, [W[1] for W in [W_ci, W_ig, W_og, W_fg]]))\\n \\n self.W_fwd_conc = W_fwd_conc\\n self.W_bwd_conc = W_bwd_conc\\n self.a = OrderedDict(ci=a_ci, ig=a_ig, og=a_og, fg=a_fg, out=a_out)\\n self.b = OrderedDict(ci=b_ci, ig=b_ig, og=b_og, fg=b_fg)\\n self.h = h\\n self.c = c\\n self.comb = comb\\n self.max_seq_len = None\\n self.external_rec = None\\n \\n self.dilation_rate = dilation_rate\\n \\n self.out = tf.expand_dims(h_init, 1)\\n self.name = name\",\n \"def forward(self, inputs):\\n batch_size = len(inputs.batch_sizes)\\n # unpack\\n x, lengths = pad_packed_sequence(inputs, batch_first=True)\\n # x is (batch, slen)\\n batch_size = x.size(0)\\n x = self.embed(x) # x is (batch, seq, dim_e)\\n # but we need x to be (slen, batch, dim_e)\\n x = x.transpose(0, 1)\\n\\n # rnn\\n x = pack_padded_sequence(x, lengths, batch_first=False)\\n _, (x, _) = self.lstm(x) # we want x=$h_(t=slen)$ (last hidden output)\\n # we have x as (num_directions=2, batch, hidden)\\n # we transpose it to (batch, num_direction, hidden)\\n # than we view it as (batch, 1, hidden * 2) and finally we\\n # squeeze it to (batch, hidden * 2) because we wanted to have\\n # the directions concatenated as a single feature vector (per input)\\n x = x.transpose(0, 1).contiguous().view(batch_size, 1, -1).squeeze(1)\\n # we need to have squeeze(dim=1) because of the batch_size=1 case\\n\\n # do some dropout\\n x = self.dropout(x)\\n # map to classes\\n x = self.output(x)\\n return x\",\n \"def forward(self, input: torch.Tensor) -> torch.Tensor:\\n x = input\\n for block in self.blocks:\\n x = block(x)\\n x = self.final_linear(x.flatten(1))\\n\\n return x\",\n \"def forward_train(self, *args, **kwargs):\\n pass\",\n \"def forward(self, state):\\n #pass\\n #forward through each layer in \\\"hidden layer\\\", with ReLU activation unit between them\\n for linear in self.hidden_layers:\\n state = F.relu(linear(state))\\n \\n state = self.output(state)\\n return state#F.log_softmax(state, dim=1)\",\n \"def forward(self, sequence):\\n\\n seq_len = len(sequence)\\n batch_size = sequence[0].size(0)\\n state_fwd = self.fwd_rnn.init_state(batch_size, [self.height, self.width])\\n state_bwd = self.bwd_rnn.init_state(batch_size, [self.height, self.width])\\n\\n outputs_fwd = []\\n outputs_bwd = []\\n for t in range(seq_len):\\n t_fwd, t_bwd = t, seq_len - t - 1\\n output_fwd, state_fwd = self.fwd_rnn(sequence[t_fwd], state_fwd)\\n output_bwd, state_bwd = self.bwd_rnn(sequence[t_bwd], state_bwd)\\n\\n outputs_fwd += [output_fwd]\\n outputs_bwd += [output_bwd]\\n\\n outputs_bwd.reverse()\\n output = [torch.cat([outputs_fwd[t], outputs_bwd[t]], dim=1) for t in range(seq_len)]\\n\\n return output\",\n \"def forward(self, inputs):\\n # unpack\\n x, lengths = pad_packed_sequence(inputs, batch_first=True)\\n # x is (batch, slen)\\n x = embedded_dropout(self.embed, x,\\n dropout=self.dropout_e if self.training else 0)\\n # x is (batch, seq, dim_e)\\n # but we need x to be (slen, batch, dim_e)\\n x = x.transpose(0, 1)\\n\\n # rnn\\n x = pack_padded_sequence(x, lengths, batch_first=False)\\n x, (_, _) = self.lstm(x)\\n # x is (slen, batch, num_directions * hidden_size)\\n x, lengths = pad_packed_sequence(x, batch_first=False)\\n rnn_out = x\\n # turn into batch first (batch, slen, num_dirs * hiddden)\\n # and then (batch, num_dirs * hidden, slen)\\n x = x.transpose(0, 1).transpose(1, 2)\\n x = F.relu(x)\\n x = F.max_pool1d(x, x.size(2)) # (batch, num_dirs * hidden, 1)\\n x = x.squeeze(2)\\n\\n # do some dropout\\n x = self.dropout(x)\\n # map to classes\\n x = self.output(x)\\n return x, rnn_out\",\n \"def forward(self, state):\\n x = state\\n for layer in self.linear_layers[:-1]:\\n x = F.relu(layer(x))\\n x = self.linear_layers[-1](x)\\n return x\",\n \"def relu_forward_hook_function(module, ten_in, ten_out):\\n self.forward_relu_outputs.append(ten_out)\",\n \"def relu_forward_hook_function(module, ten_in, ten_out):\\n self.forward_relu_outputs.append(ten_out)\",\n \"def relu_forward_hook_function(module, ten_in, ten_out):\\n self.forward_relu_outputs.append(ten_out)\",\n \"def relu_forward_hook_function(module, ten_in, ten_out):\\n self.forward_relu_outputs.append(ten_out)\",\n \"def relu_forward_hook_function(module, ten_in, ten_out):\\n self.forward_relu_outputs.append(ten_out)\",\n \"def model_RNN(x_train, y_train, x_test=None, y_test=None, kwargs={}):\\n \\\"\\\"\\\"\\n Notes on Input shape\\n 3D tensor with shape (batch_size, timesteps, input_dim).\\n https://keras.io/layers/recurrent/\\n LSTMs in Keras are typically used on 3d data (batch dimension, timesteps, features).\\n LSTM without return_sequences will output (batch dimension, output features)\\n LSTM with return_sequences will output (batch dimension, timesteps, output features)\\n Basic timeseries data has an input shape (number of sequences, steps, features). Target is (number of sequences, steps, targets). Use an LSTM with return_sequences.\\n \\\"\\\"\\\"\\n ######## RELU??? DropOut\\n # create and fit the LSTM network\\n # input_shape = Lookback x Features\\n verbose = kwargs.get('verbose',False)\\n layers = kwargs.get('layers', 1 )\\n nodes = kwargs.get('nodes', None)\\n\\n if nodes is None or nodes==0 or nodes==[0]:\\n nodes = [np.shape(x_train)[1]]\\n elif isinstance(nodes, (int, np.integer)): # turn int to list\\n nodes = [nodes]\\n\\n if layers > 1 and len(nodes) < layers:\\n nodes = list(np.pad(nodes,[0,layers-len(nodes)], mode='constant',constant_values=nodes[-1]))\\n\\n ndim = np.max([2,len(np.shape(x_train))]) # Min 2D\\n if ndim==2:\\n input_shape=(x_train.shape[1],)\\n else:\\n input_shape=(x_train.shape[1],x_train.shape[2])\\n if kwargs.get('learning_rate', False):\\n lr = kwargs.get('learning_rate')\\n else:\\n lr = False\\n\\n if np.ndim(y_train)==1:\\n n_out = 1 #e.g. forecast y as float, just 1 step ahead.\\n else:\\n n_out = np.shape(y_train)[1] #e.g. onehot encoded, or n-steps ahead.\\n\\n dropout = kwargs.get('dropout',0) # dropout rate between 0 and 1.\\n stateful = kwargs.get('stateful',True)\\n if stateful: #RNN needs fixed batch - consider using static_index\\n batch_shape = (kwargs.get('batch_size',1234),) + input_shape\\n actvn = kwargs.get('actvn','tanh')\\n actvl = kwargs.get('actvl','sigmoid')\\n if verbose and not actvn == 'tanh': print('tanh activation recommended for LSTM but you are using',actvn)\\n\\n model=[]\\n model = Sequential() # https://keras.io/models/sequential/\\n model.reset_states() # ?useful for batch training RNN... perhaps inside batched loop\\n #TODO? model.add(Embedding(max_features, output_dim=n_out))\\n\\n if layers>1:\\n for n in range(1,layers):\\n if kwargs.get('verbose'): print('+adding extra layer')\\n if stateful: #switch between batch_ and input_shape\\n model.add(LSTM(nodes[layers-1], batch_input_shape=batch_shape, return_sequences=True, activation=actvn, stateful=stateful))\\n else:\\n model.add(LSTM(nodes[layers-1], input_shape=input_shape, return_sequences=True, activation=actvn, stateful=stateful))\\n if kwargs.get('bnorm', False):\\n model.add(keras.layers.normalization.BatchNormalization())\\n # TODO find out about time lock dropout\\n if dropout:\\n model.add(Dropout(dropout)) #(c.f. Regularisation of Betas)\\n\\n # Single layer or last layer of RNN\\n if stateful:\\n model.add(LSTM(nodes[layers-1], batch_input_shape=batch_shape, return_sequences=False, activation=actvn, stateful=stateful))\\n else:\\n model.add(LSTM(nodes[layers-1], input_shape=input_shape, return_sequences=False, activation=actvn, stateful=stateful))\\n\\n #model.add(Flatten()) # Req'd if last layer return_sequences=True\\n #model.add(Dense(nodes[layers-1]**2, activation=actvl))\\n model.add(Dense(n_out, activation=actvl))\\n\\n #defaults = keras.optimizers.Nadam(lr=0.002, beta_1=0.9, beta_2=0.999, epsilon=None, schedule_decay=0.004)\\n if hasattr(kwargs,'optimizer'):\\n optimizer = kwargs['optimizer']\\n elif lr:\\n optimizer = keras.optimizers.Nadam(lr=lr, beta_1=0.9, beta_2=0.999, epsilon=1e-8, schedule_decay=0.004)\\n else:\\n optimizer = keras.optimizers.Nadam(lr=0.002, beta_1=0.9, beta_2=0.999, epsilon=1e-8,schedule_decay=0.004)\\n optimizer = 'adam'\\n\\n if is_bool_dtype(y_train):\\n model.compile(loss='binary_crossentropy', optimizer=optimizer)\\n if is_categorical_dtype(y_train) or kwargs.get('onehot',False):\\n #TODO Multiple Category\\n model.compile(loss='categorical_crossentropy', optimizer=optimizer)\\n else:\\n model.compile(loss='mean_squared_error', optimizer=optimizer)\\n\\n if verbose > 1:\\n model.summary()\\n print(\\\"Inputs: {}\\\".format(model.input_shape))\\n print(\\\"Outputs: {}\\\".format(model.output_shape))\\n print(\\\"Actual input: {}\\\".format(x_train.shape))\\n print(\\\"Actual output: {}\\\".format(y_train.shape))\\n print('Model Loss: ' + model.loss)\\n\\n # For compatability with other models;\\n model.score = model.evaluate\\n\\n return model #self.model=model\",\n \"def bi_lstm(X_inputs):\\n # X_inputs.shape = [batchsize, timestep_size] -> inputs.shape = [batchsize, timestep_size, embedding_size]\\n log(\\\"embedding\\\")\\n log(embedding)\\n log(X_inputs)\\n log(\\\"X_inputs\\\")\\n inputs = tf.nn.embedding_lookup(embedding, X_inputs) \\n \\n # ** 1.构建前向后向多层 LSTM\\n cell_fw = rnn.MultiRNNCell([lstm_cell() for _ in range(layer_num)], state_is_tuple=True)\\n cell_bw = rnn.MultiRNNCell([lstm_cell() for _ in range(layer_num)], state_is_tuple=True)\\n \\n # ** 2.初始状态\\n initial_state_fw = cell_fw.zero_state(batch_size, tf.float32)\\n initial_state_bw = cell_bw.zero_state(batch_size, tf.float32) \\n \\n # 下面两部分是等价的\\n # **************************************************************\\n # ** 把 inputs 处理成 rnn.static_bidirectional_rnn 的要求形式\\n # ** 文档说明\\n # inputs: A length T list of inputs, each a tensor of shape\\n # [batch_size, input_size], or a nested tuple of such elements.\\n # *************************************************************\\n # Unstack to get a list of 'n_steps' tensors of shape (batch_size, n_input)\\n # inputs.shape = [batchsize, timestep_size, embedding_size] -> timestep_size tensor, each_tensor.shape = [batchsize, embedding_size]\\n # inputs = tf.unstack(inputs, timestep_size, 1)\\n # ** 3.bi-lstm 计算（tf封装） 一般采用下面 static_bidirectional_rnn 函数调用。\\n # 但是为了理解计算的细节，所以把后面的这段代码进行展开自己实现了一遍。\\n# try:\\n# outputs, _, _ = rnn.static_bidirectional_rnn(cell_fw, cell_bw, inputs, \\n# initial_state_fw = initial_state_fw, initial_state_bw = initial_state_bw, dtype=tf.float32)\\n# except Exception: # Old TensorFlow version only returns outputs not states\\n# outputs = rnn.static_bidirectional_rnn(cell_fw, cell_bw, inputs, \\n# initial_state_fw = initial_state_fw, initial_state_bw = initial_state_bw, dtype=tf.float32)\\n# output = tf.reshape(tf.concat(outputs, 1), [-1, hidden_size * 2])\\n # ***********************************************************\\n \\n # ***********************************************************\\n # ** 3. bi-lstm 计算（展开）\\n with tf.variable_scope('bidirectional_rnn'):\\n # *** 下面，两个网络是分别计算 output 和 state \\n # Forward direction\\n outputs_fw = list()\\n state_fw = initial_state_fw\\n with tf.variable_scope('fw'):\\n for timestep in range(timestep_size):\\n if timestep > 0:\\n tf.get_variable_scope().reuse_variables()\\n (output_fw, state_fw) = cell_fw(inputs[:, timestep, :], state_fw)\\n outputs_fw.append(output_fw)\\n \\n # backward direction\\n outputs_bw = list()\\n state_bw = initial_state_bw\\n with tf.variable_scope('bw') as bw_scope:\\n inputs = tf.reverse(inputs, [1])\\n for timestep in range(timestep_size):\\n if timestep > 0:\\n tf.get_variable_scope().reuse_variables()\\n (output_bw, state_bw) = cell_bw(inputs[:, timestep, :], state_bw)\\n outputs_bw.append(output_bw)\\n # *** 然后把 output_bw 在 timestep 维度进行翻转\\n # outputs_bw.shape = [timestep_size, batch_size, hidden_size]\\n outputs_bw = tf.reverse(outputs_bw, [0])\\n # 把两个oupputs 拼成 [timestep_size, batch_size, hidden_size*2]\\n output = tf.concat([outputs_fw, outputs_bw], 2)\\n output = tf.transpose(output, perm=[1,0,2])\\n output = tf.reshape(output, [-1, hidden_size*2])\\n # ***********************************************************\\n return output # [-1, hidden_size*2]\",\n \"def set_model(self, n_lstm_layers=3, n_lstm_nodes=150, n_dense_1=1, n_nodes_dense_1=300, n_dense_2=4, n_nodes_dense_2=200, dropout_rate=0.1, learning_rate=0.001, batch_norm=True, batch_momentum=0.99):\\n\\n input_objects = keras.layers.Input(shape=(len(self.low_level_vars), len(self.low_level_vars[0])), name='input_objects') \\n input_global = keras.layers.Input(shape=(len(self.high_level_vars),), name='input_global')\\n lstm = input_objects\\n decay = 0.2\\n for i_layer in range(n_lstm_layers):\\n #lstm = keras.layers.LSTM(n_lstm_nodes, activation='tanh', kernel_regularizer=keras.regularizers.l2(decay), recurrent_regularizer=keras.regularizers.l2(decay), bias_regularizer=keras.regularizers.l2(decay), return_sequences=(i_layer!=(n_lstm_layers-1)), name='lstm_{}'.format(i_layer))(lstm)\\n lstm = keras.layers.LSTM(n_lstm_nodes, activation='tanh', return_sequences=(i_layer!=(n_lstm_layers-1)), name='lstm_{}'.format(i_layer))(lstm)\\n\\n #inputs to dense layers are output of lstm and global-event variables. Also batch norm the FC layers\\n dense = keras.layers.concatenate([input_global, lstm])\\n for i in range(n_dense_1):\\n dense = keras.layers.Dense(n_nodes_dense_1, activation='relu', kernel_initializer='he_uniform', name = 'dense1_%d' % i)(dense)\\n if batch_norm:\\n dense = keras.layers.BatchNormalization(name = 'dense_batch_norm1_%d' % i)(dense)\\n dense = keras.layers.Dropout(rate = dropout_rate, name = 'dense_dropout1_%d' % i)(dense)\\n\\n for i in range(n_dense_2):\\n dense = keras.layers.Dense(n_nodes_dense_2, activation='relu', kernel_initializer='he_uniform', name = 'dense2_%d' % i)(dense)\\n #add droput and norm if not on last layer\\n if batch_norm and i < (n_dense_2 - 1):\\n dense = keras.layers.BatchNormalization(name = 'dense_batch_norm2_%d' % i)(dense) \\n if i < (n_dense_2 - 1):\\n dense = keras.layers.Dropout(rate = dropout_rate, name = 'dense_dropout2_%d' % i)(dense)\\n\\n output = keras.layers.Dense(1, activation = 'sigmoid', name = 'output')(dense)\\n #optimiser = keras.optimizers.Nadam(lr = learning_rate)\\n optimiser = keras.optimizers.Adam(lr = learning_rate)\\n\\n model = keras.models.Model(inputs = [input_global, input_objects], outputs = [output])\\n model.compile(optimizer = optimiser, loss = 'binary_crossentropy')\\n self.model = model\",\n \"def forward(self, x):\\n # x = state\\n \\n x = F.relu(self.input(x))\\n x = self.output(x)\\n \\n return x\",\n \"def _lstm_unroll_base(num_lstm_layer, seq_len, num_hidden):\\n param_cells = []\\n last_states = []\\n for i in range(num_lstm_layer):\\n param_cells.append(LSTMParam(i2h_weight=mx.sym.Variable(\\\"l%d_i2h_weight\\\" % i),\\n i2h_bias=mx.sym.Variable(\\\"l%d_i2h_bias\\\" % i),\\n h2h_weight=mx.sym.Variable(\\\"l%d_h2h_weight\\\" % i),\\n h2h_bias=mx.sym.Variable(\\\"l%d_h2h_bias\\\" % i)))\\n state = LSTMState(c=mx.sym.Variable(\\\"l%d_init_c\\\" % i),\\n h=mx.sym.Variable(\\\"l%d_init_h\\\" % i))\\n last_states.append(state)\\n assert len(last_states) == num_lstm_layer\\n\\n # embedding layer\\n data = mx.sym.Variable('data')\\n wordvec = mx.sym.SliceChannel(data=data, num_outputs=seq_len, squeeze_axis=1)\\n\\n hidden_all = []\\n for seqidx in range(seq_len):\\n hidden = wordvec[seqidx]\\n for i in range(num_lstm_layer):\\n next_state = _lstm(\\n num_hidden=num_hidden,\\n indata=hidden,\\n prev_state=last_states[i],\\n param=param_cells[i],\\n seqidx=seqidx,\\n layeridx=i)\\n hidden = next_state.h\\n last_states[i] = next_state\\n hidden_all.append(hidden)\\n\\n hidden_concat = mx.sym.Concat(*hidden_all, dim=0)\\n pred_fc = mx.sym.FullyConnected(data=hidden_concat, num_hidden=11, name=\\\"pred_fc\\\")\\n return pred_fc\",\n \"def forward_tensor(self, x):\\n pass\",\n \"def forward(self, input_tensor):\\n rv = torch.randn(input_tensor.size(), device=self.device) * 0.02\\n intermediate = input_tensor + rv\\n for module in self.down:\\n intermediate = module(intermediate)\\n rv = torch.randn(intermediate.size(), device=self.device) * 0.02 + 1\\n intermediate *= rv\\n\\n intermediate = intermediate.view(-1, self.width)\\n\\n for module in self.classifier:\\n intermediate = module(intermediate)\\n\\n return intermediate\",\n \"def forward(self, x):\\n\\n def run0(x, dummy):\\n lout1 = self.lconv1(x)\\n out1 = self.conv1(lout1)\\n lout2 = self.lconv2(out1 + lout1)\\n out2 = self.conv2(lout2)\\n lout3 = self.lconv3(out2 + lout2)\\n out3 = self.conv3(lout3)\\n lout4 = self.lconv4(out3 + lout3)\\n out4 = self.conv4(lout4)\\n lout5 = self.lconv5(out4 + lout4)\\n out5 = self.conv5(lout5)\\n lout6 = self.lconv6(out5 + lout5)\\n out6 = self.conv6(lout6)\\n lout7 = self.lconv7(out6 + lout6)\\n out7 = self.conv7(lout7)\\n mat = out7[:, :, :, None] + out7[:, :, None, :]\\n cur = mat\\n if self.num_1d:\\n output1d = self.final_1d(out7)\\n return cur, output1d\\n else:\\n return cur\\n\\n dummy = torch.Tensor(1)\\n dummy.requires_grad = True\\n if self.num_1d:\\n cur, output1d = checkpoint(run0, x, dummy)\\n else:\\n cur = checkpoint(run0, x, dummy)\\n\\n def run1(cur):\\n first = True\\n for lm, m in zip(self.lconvtwos[:7], self.convtwos[:7]):\\n if first:\\n cur = lm(cur)\\n\\n first = False\\n else:\\n cur = lm(cur) + cur\\n cur = m(cur) + cur\\n return cur\\n\\n def run2(cur):\\n for lm, m in zip(self.lconvtwos[7:13], self.convtwos[7:13]):\\n cur = lm(cur) + cur\\n cur = m(cur) + cur\\n return cur\\n\\n def run3(cur):\\n for lm, m in zip(self.lconvtwos[13:], self.convtwos[13:]):\\n cur = lm(cur) + cur\\n cur = m(cur) + cur\\n\\n cur = self.final(cur)\\n cur = 0.5 * cur + 0.5 * cur.transpose(2, 3)\\n return cur\\n\\n cur = checkpoint(run1, cur)\\n cur = checkpoint(run2, cur)\\n cur = checkpoint(run3, cur)\\n\\n if self.num_1d:\\n return cur, output1d\\n else:\\n return cur\",\n \"def forward(self, state, action): \\n ##x = F.relu(self.fc1(state)) \\n x = F.relu(self.bn1(self.fc1(state))) \\n x = torch.cat([x, action], dim=1)\\n x = F.relu(self.fc2(x))\\n x = self.fc3(x)\\n return x\",\n \"def lstm_step_backward(dnext_h, dnext_c, cache):\\n dx, dh, dc, dWx, dWh, db = None, None, None, None, None, None\\n #############################################################################\\n # TODO: Implement the backward pass for a single timestep of an LSTM. #\\n # #\\n # HINT: For sigmoid and tanh you can compute local derivatives in terms of #\\n # the output value from the nonlinearity. #\\n #############################################################################\\n\\n x, i, f, o, g, prev_h, next_h, prev_c, next_c, Wx, Wh, b = cache\\n\\n #next_h = o * tanh(next_c)\\n #next_c = f *prev_c + i*g\\n # derivative of next_c with respect to h\\n tanh_nc = np.tanh(next_c)\\n dnext_c_h = (1- tanh_nc*tanh_nc) *o*dnext_h\\n dc = dnext_c_h + dnext_c\\n di = g * dc\\n df = prev_c * dc\\n do = np.tanh(next_c) * dnext_h\\n dg = i * dc\\n\\n # i = sigmoid(z) -> dz = (1-i)(i) di; di is the\\n dz_i = (1-i)*(i) * di\\n dz_f = (1-f)*(f) * df\\n dz_o = (1-o)*(o) * do\\n dz_g = (1-g*g) * dg\\n\\n dz = np.hstack((dz_i,dz_f,dz_o,dz_g)).T\\n\\n dx = np.dot(Wx, dz).T\\n dprev_h = np.dot(Wh,dz).T\\n dprev_c = f * dc\\n dWx = np.dot(dz, x).T\\n dWh = np.dot(dz, prev_h).T\\n db = np.sum(dz, axis=1)\\n\\n ##############################################################################\\n # END OF YOUR CODE #\\n ##############################################################################\\n return dx, dprev_h, dprev_c, dWx, dWh, db\",\n \"def apply_highway_lstm(x, seq_len):\\n lstm_out = apply_lstm(x, seq_len)\\n proj = ops.affine(x, FLAGS.lstm_dim * 4, \\\"w\\\", bias_name=\\\"b\\\")\\n gate, transform = tf.split(proj, 2, 2)\\n gate = tf.sigmoid(gate)\\n transform = tf.tanh(transform)\\n return lstm_out * gate + (1 - gate) * transform\",\n \"def forward(\\n self,\\n x,\\n mats_dict,\\n lidar_depth,\\n timestamps=None,\\n ):\\n if self.is_train_depth and self.training:\\n x = self.backbone(x, mats_dict, lidar_depth, timestamps)\\n preds = self.head(x)\\n return preds\\n else:\\n x = self.backbone(x, mats_dict, lidar_depth, timestamps)\\n preds = self.head(x)\\n return preds\",\n \"def forward(self, src, device):\\n\\n src = torch.as_tensor(src).float().to(device)\\n\\n\\n # Set initial hidden and cell states \\n h0 = torch.zeros(self.num_layers, src.shape[0], self.hidden_dim).to(device)\\n c0 = torch.zeros(self.num_layers, src.shape[0], self.hidden_dim).to(device)\\n\\n # shape of lstm_out: [batch_size, input_size, hidden_dim]\\n # shape of self.hidden: (a, b), where a and b both have shape (num_layers, batch_size, hidden_dim).\\n lstm_out, self.hidden = self.lstm(src, (h0, c0)) \\n \\n # Only take the output from the final timetep\\n # Can pass on the entirety of lstm_out to the next layer if it is a seq2seq prediction\\n #print(lstm_out.size())\\n y_pred = self.linear(lstm_out[:, -1, :].view(src.shape[0], -1))\\n return y_pred\",\n \"def forward(self, feature_indices, feature_values):\\n self.A_=torch.sparse.FloatTensor(self.edge_indices,self.edge_weights,torch.Size([self.args.nu,self.args.nu])).to(self.device)\\n feature=torch.sparse.FloatTensor(feature_indices,feature_values,torch.Size([self.args.nu,self.args.ne])).to(self.device).to_dense()\\n #B=feature @ feature.t()\\n #B=B-torch.diagflat(torch.diagonal(B)) \\n #B=B+torch.eye(B.shape[0]).to(self.device)\\n # B=torch.max(B-5,torch.zeros(B.shape[0],B.shape[0]).to(self.device))\\n #print(B.max())\\n # B=B/B.max()\\n # B=torch.ceil(B/20.0)\\n # B=torch.clamp(B-10,0,1)\\n # np.savetxt(\\\"adja.txt\\\",torch.sum(B[:,0:3999],1).cpu().numpy(),fmt=\\\"%1.0f\\\")\\n #degree=torch.sum(B,1)\\n # print(degree) \\n #D=torch.sqrt(torch.diagflat(1.0/degree))\\n # B=D @ B @ D\\n \\n latent_features_1 = self.layer_1(feature)\\n latent_features_1 = torch.nn.functional.relu(latent_features_1)\\n latent_features_1 = torch.nn.functional.dropout(latent_features_1, p = self.args.dropout, training = self.training)\\n latent_features_2 = self.layer_2(latent_features_1)\\n #latent_features_2=torch.spmm(self.A_,latent_features_2)\\n #for i in range(50):\\n # latent_features_2=torch.spmm(self.A_,latent_features_2)\\n localized_predictions=latent_features_2\\n \\n \\n self.predictions = torch.nn.functional.log_softmax(localized_predictions , dim=1)\\n return self.predictions\",\n \"def forward(self, x):\\n for task_module_name in self.task_module_name_path[self.task_idx]:\\n for layer in self.task_modules[task_module_name]:\\n x = layer(x)\\n #x = self.task_modules[task_module_name](x)\\n x = x.view(x.size(0), -1)\\n x = self.classification_layers[str(self.task_idx)](x)\\n return x\",\n \"def forward(self, inp, state_0):\\n next_inp = inp.view(1, -1)\\n next_state = state_0\\n outputs = []\\n for i in range(self.seq_len):\\n out, next_state = self.model(next_inp, next_state)\\n outputs.append(out)\\n next_inp = torch.argmax(out, dim=-1)\\n\\n return torch.cat(outputs, dim=0), next_state\",\n \"def forward(self, x_data, state):\\n #=====[ Step 1: Compute q(z|x) - encoding step, get z ]=====\\n # Forward encoding\\n for i in range(x_data.shape[0]):\\n x = Variable(x_data[i].reshape((1, x_data.shape[1])))\\n h_in = self.recog_x_h(x) + self.recog_h_h(state['h_rec'])\\n c_t, h_t = F.lstm(state['c_rec'], h_in)\\n state.update({'c_rec':c_t, 'h_rec':h_t})\\n # Compute q_mean and q_log_sigma\\n q_mean = self.recog_mean( state['h_rec'] )\\n q_log_sigma = 0.5 * self.recog_log_sigma( state['h_rec'] )\\n # Compute KL divergence based on q_mean and q_log_sigma\\n KLD = -0.0005 * F.sum(1 + q_log_sigma - q_mean**2 - F.exp(q_log_sigma))\\n # Compute as q_mean + noise*exp(q_log_sigma)\\n eps = Variable(np.random.normal(0, 1, q_log_sigma.data.shape ).astype(np.float32))\\n z = q_mean + F.exp(q_log_sigma) * eps\\n\\n #=====[ Step 2: Compute p(x|z) - decoding step ]=====\\n # Initial step\\n output = []\\n h_in = self.gen_z_h(z)\\n c_t, h_t = F.lstm(state['c_gen'], h_in)\\n state.update({'c_gen':c_t, 'h_gen':h_t})\\n rec_loss = Variable(np.zeros((), dtype=np.float32))\\n for i in range(x_data.shape[0]):\\n # Get output and loss\\n x_t = self.output(h_t)\\n output.append(x_t.data)\\n rec_loss += self.loss_func(x_t, Variable(x_data[i].reshape((1, x_data.shape[1]))))\\n # Get next hidden state\\n h_in = self.gen_x_h(x_t) + self.gen_h_h(state['h_gen'])\\n c_t, h_t = F.lstm(state['c_gen'], h_in)\\n state.update({'c_gen':c_t, 'h_gen':h_t})\\n\\n #=====[ Step 3: Compute KL-Divergence based on all terms ]=====\\n return output, rec_loss, KLD, state\",\n \"def forward(self, observation: Tensor) -> Tensor:\\n pass\",\n \"def relu_forward_hook_function(module, ten_in, ten_out):\\n self.forward_relu_outputs.append(ten_out)\",\n \"def forward(self, nodes_batch):\\n lower_layer_nodes = list(nodes_batch) # node idx\\n\\n nodes_batch_layers = [(lower_layer_nodes,)]\\n\\n for i in range(self.num_layers):\\n lower_layer_neighs, lower_layer_nodes = self._get_unique_neighs_list(lower_layer_nodes,\\n num_sample=self.num_neighbor_samples)\\n # lower_layer_neighs: list(list())\\n # lower_layer_nodes: list(nodes of next layer)\\n nodes_batch_layers.insert(0, (lower_layer_nodes, lower_layer_neighs))\\n\\n all_nodes = np.unique([int(n) for n in list(chain(*[layer[0] for layer in nodes_batch_layers]))])\\n all_nodes_idx = dict([(node, idx) for idx, node in enumerate(all_nodes)])\\n\\n all_neigh_nodes = pad_sequence([self.nodes_tokenized[node] for node in all_nodes], padding_value=1).transpose(0,\\n 1)[\\n :, :MAX_SEQ_LENGTH].to(self.device)\\n\\n pre_hidden_embs = self.get_roberta_embs(\\n all_neigh_nodes\\n )\\n\\n # (num_all_node, emb_size)\\n\\n for layer_idx in range(1, self.num_layers + 1):\\n this_layer_nodes = nodes_batch_layers[layer_idx][0] # all nodes in this layer\\n neigh_nodes, neighbors_list = nodes_batch_layers[layer_idx - 1] # previous layer\\n # list(), list(list())\\n\\n aggregate_feats = self.aggregate(neighbors_list, pre_hidden_embs, all_nodes_idx)\\n # (this_layer_nodes_num, emb_size)\\n\\n sage_layer = getattr(self, 'sage_layer' + str(layer_idx))\\n\\n cur_hidden_embs = sage_layer(self_feats=pre_hidden_embs[[all_nodes_idx[int(n)] for n in this_layer_nodes]],\\n # pre_hidden_embs[layer_nodes],\\n aggregate_feats=aggregate_feats)\\n\\n # cur_hidden_embs = torch.cat([pre_hidden_embs[[all_nodes_idx[int(n)] for n in this_layer_nodes]].unsqueeze(1), \\n # aggregate_feats.unsqueeze(1)], dim=1) # (b_s, 2, emb_size)\\n # cur_hidden_embs = torch.mean(cur_hidden_embs, dim=1)\\n\\n pre_hidden_embs[[all_nodes_idx[int(n)] for n in this_layer_nodes]] = cur_hidden_embs\\n\\n # (input_batch_node_size, emb_size)\\n # output the embeddings of the input nodes\\n return pre_hidden_embs[[all_nodes_idx[int(n)] for n in nodes_batch]]\",\n \"def forward(self, state):\\n \\n for linear in self.hidden_layers:\\n state = F.relu(linear(state))\\n \\n return self.output(state)\",\n \"def forward(self, input):\\n\\n # transform input into matrix of vectors [Batch, 784]\\n input = input.view(-1, 784).to(self.device)\\n\\n # full pass\\n mean, std = self.encoder(input)\\n z = self.reparameterize(mean, std)\\n output = self.decoder(z)\\n\\n # calculate each part of the loss\\n reg_loss = self.reg_loss(mean, std)\\n recon_loss = self.recon_loss(input, output)\\n\\n # avarage over batch\\n average_negative_elbo = torch.mean(reg_loss + recon_loss, dim=0)\\n return average_negative_elbo\",\n \"def forward(self, inputs):\\n\\n # Concatenate LSTM hidden state vectors into one large vector,\\n # which will be then used for prediction\\n aggregated = []\\n cnt = 0\\n for state, (lstm_cell, lstm_state) in enumerate(zip(self.lstm_cell_list, self.lstm_state_list)):\\n lstm_state = lstm_cell(inputs[:, state, :, :].view(inputs.shape[0], -1), lstm_state)\\n aggregated.append(lstm_state[1] * self.imp_weights[cnt])\\n cnt += 1\\n aggregated = torch.cat(aggregated, dim=1)\\n\\n # Calculate predictions\\n pred = F.relu(self.pred_mlp_l1(aggregated))\\n pred = self.pred_mlp_l2(pred)\\n\\n return pred\",\n \"def __init__(self, name, params, load_model):\\n\\n super(MDN_RNN, self).__init__(name, params, load_model)\\n self.name = name\\n self.type = 'MDN RNN'\\n if load_model != False:\\n self.load_model(load_model)\\n else:\\n self.params = params\\n self.z_size = self.params['z_size']\\n self.action_size = self.params['action_size']\\n self.hidden_size = self.params['hidden_size']\\n self.gaussian_size = self.params['gaussian_size']\\n self.stacked_layers = self.params['stacked_layers']\\n self.learning_rate = self.params['learning_rate']\\n self.grad_clip = self.params['grad_clip']\\n self.batch_size = self.params['batch_size']\\n self.device = self.get_device()\\n \\n self.lstm = nn.LSTM(self.z_size + self.action_size, self.hidden_size, self.stacked_layers, batch_first = True)\\n self.fc1 = nn.Linear(self.hidden_size, self.gaussian_size * self.z_size)\\n self.fc2 = nn.Linear(self.hidden_size, self.gaussian_size * self.z_size)\\n self.fc3 = nn.Linear(self.hidden_size, self.gaussian_size * self.z_size)\\n \\n if load_model != False:\\n self.load_state_dict(self.weights)\\n \\n print(self, \\\"\\\\n\\\\n\\\")\",\n \"def forward(self, graph, x):\\n graph_id = graph.graph_node_id\\n batch_size = graph_id.max() + 1\\n h = (\\n paddle.zeros((self.n_layers, batch_size, self.input_dim)),\\n paddle.zeros((self.n_layers, batch_size, self.input_dim)), )\\n q_star = paddle.zeros((batch_size, self.output_dim))\\n for _ in range(self.n_iters):\\n q, h = self.lstm(q_star.unsqueeze(0), h)\\n q = q.reshape((batch_size, self.input_dim))\\n e = (x * q.index_select(\\n graph_id, axis=0)).sum(axis=-1, keepdim=True)\\n a = segment_softmax(e, graph_id)\\n r = segment_sum(a * x, graph_id)\\n q_start = paddle.concat([q, r], axis=-1)\\n\\n return q_start\",\n \"def forward(self, sequence):\\n seq_len = len(sequence)\\n batch_size = sequence[0].size(0)\\n state_bwd = self.bwd_rnn.init_state(batch_size, [self.height, self.width])\\n\\n outputs_bwd = []\\n for t in range(seq_len):\\n t_bwd = seq_len - t - 1\\n output_bwd, state_bwd = self.bwd_rnn(sequence[t_bwd], state_bwd)\\n outputs_bwd += [output_bwd]\\n\\n outputs_bwd.reverse()\\n return outputs_bwd\",\n \"def forward(self, input_var: Tensor, hidden: Optional[HiddenDict] = None, **additional: Dict) -> RecurrentOutput:\\n ...\",\n \"def lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b):\\n next_h, next_c, cache = None, None, None\\n #############################################################################\\n # TODO: Implement the forward pass for a single timestep of an LSTM. #\\n # You may want to use the numerically stable sigmoid implementation above. #\\n #############################################################################\\n N,H = prev_h.shape\\n z_all = np.dot(x, Wx) + np.dot(prev_h, Wh) + b\\n z_i = z_all[:,:H]; z_f=z_all[:,H:2*H]; z_o = z_all[:,2*H:3*H]; z_g=z_all[:,3*H:4*H]\\n i = sigmoid(z_i)\\n f = sigmoid(z_f)\\n o = sigmoid(z_o)\\n g = np.tanh(z_g)\\n next_c = f * prev_c + i * g\\n next_h = o * np.tanh(next_c)\\n cache = (x, i, f, o, g, prev_h, next_h, prev_c, next_c, Wx, Wh, b)\\n\\n ##############################################################################\\n # END OF YOUR CODE #\\n ##############################################################################\\n\\n return next_h, next_c, cache\",\n \"def forward(self, state):\\n x = state.unsqueeze(1)\\n x = F.relu(self.cnl1(x))\\n x = F.relu(self.cnl2(x))\\n x = F.relu(self.cnl3(x))\\n x = x.view(x.shape[0], -1) # flatten\\n x = F.relu(self.dense1(x))\\n x = self.out(x)\\n return x\",\n \"def lstm_forward(self, x, parameters):\\n\\n #Accepting, x.shape = n_x, m, T_x \\n #Let's make sure we are getting input of correct dimensions\\n assert(self.nx == x.shape[0])\\n assert(self.T_x == x.shape[2])\\n \\n #writing shorter variables to handle easily\\n n_a, m = self.UNITS, x.shape[1]\\n\\n # Initialize \\\"caches\\\", which will track the list of all the caches\\n caches = []\\n\\n # Initialize a_next and c_next\\n a_next = np.zeros((n_a,m)) \\n c_next = np.zeros(a_next.shape)\\n \\n # loop over all time-steps\\n for t in range(self.T_x):\\n # Update next hidden state, next memory state, compute the prediction, get the cache \\n a_next, c_next, cache = self.lstm_cell_forward(x[:,:,t], a_next, c_next, parameters)\\n # Append the cache into caches \\n caches.append(cache)\\n \\n # store values needed for backward propagation in cache\\n caches = (caches, x)\\n\\n #since only the last activation is of our concern\\n return a_next, caches\",\n \"def forward(self, state, action):\\r\\n \\r\\n x = torch.cat([state, action], 1) ##### fixed dim ändern\\r\\n x = F.relu(self.linear1(x))\\r\\n x = F.relu(self.linear2(x))\\r\\n x = self.linear3(x)\\r\\n\\r\\n return x\",\n \"def __init__(self, embed_size, hidden_size, vocab_size, num_layers): #(512,1024,29,1)\\r\\n super(DecoderRNN, self).__init__()\\r\\n self.embed = nn.Embedding(vocab_size, embed_size)#(29,512)\\r\\n self.lstm = nn.LSTM(embed_size, hidden_size, num_layers, batch_first=True) #(512,1024,1)\\r\\n self.linear = nn.Linear(hidden_size, vocab_size)#(1024,29)\\r\\n self.init_weights()\",\n \"def __init__(self, vocab_size, output_size, embedding_dim, hidden_dim, n_layers, drop_prob=0.7):\\n super(SentimentLSTM, self).__init__()\\n\\n self.output_size = output_size\\n self.n_layers = n_layers\\n self.hidden_dim = hidden_dim\\n\\n\\n # define all layers\\n self.embed = nn.Embedding(vocab_size,embedding_dim)\\n self.lstm = nn.LSTM(embedding_dim,hidden_dim,n_layers,dropout=drop_prob,batch_first=True)\\n self.fc = nn.Linear(hidden_dim,output_size)\\n self.sigmoid = nn.Sigmoid()\\n self.drp = nn.Dropout(p=0.7)\",\n \"def local_trend_rnn(features, labels, mode, params):\\n\\n ''' set up variables & parameters'''\\n # get parameters & super parameters\\n length = params['length']\\n batch_size = params['batch_size']\\n state_size = params['state_size']\\n drop_rate = params['drop_rate']\\n attention_size = params['attention_size']\\n learning_rate = params['learning_rate']\\n\\n # get training features and label\\n local_prices = features['local_prices'] # [b, n, 1]\\n local_events = features['local_events'] # [b, n, d]\\n\\n ''' building basic model structure'''\\n # inner trend capture\\n price_trend_capture = DynamicLstm(batch_size=batch_size, state_size=state_size,\\n keep_rate=1 - drop_rate, variable_scope=\\\"price_trend_capture\\\")\\n price_trend_h_vec = price_trend_capture.run(local_prices) # [b, n, h]\\n\\n # event trend capture\\n event_trend_capture = DynamicLstm(batch_size=batch_size, state_size=state_size,\\n keep_rate=1 - drop_rate, variable_scope=\\\"event_trend_capture\\\")\\n event_trend_h_vec = event_trend_capture.run(local_events) # [b, n, h]\\n\\n ''' combine price trend and event trend '''\\n hybrid_trend = tf.concat([price_trend_h_vec, event_trend_h_vec], axis=2) # [b, n, 2h]\\n hybrid_trend_capture = DynamicLstm(batch_size=batch_size, state_size=state_size,\\n keep_rate=1 - drop_rate, variable_scope=\\\"hybrid_trend_capture\\\")\\n hybrid_trend_h_vec = hybrid_trend_capture.run(hybrid_trend) # [b, n, h]\\n\\n ''' generate final prediction '''\\n output_dense = tf.layers.Dense(units=1, name=\\\"output_dense\\\")\\n hybrid_attention = AttentionLayer(attention_size=attention_size, name=\\\"hybrid_attention\\\")\\n values = output_dense(hybrid_attention.run(hybrid_trend_h_vec)) # [b, 1]\\n\\n ''' config '''\\n # Compute predictions.\\n if mode == tf.estimator.ModeKeys.PREDICT:\\n predictions = {'values': values}\\n return tf.estimator.EstimatorSpec(mode, predictions=predictions)\\n\\n # Compute loss.\\n loss = tf.losses.mean_squared_error(labels, values)\\n\\n # Compute evaluation metrics.\\n mse = tf.metrics.mean_squared_error(labels=labels, predictions=values, name='MSE')\\n metrics = {'MSE': mse}\\n tf.summary.scalar('mean_squared_error', loss)\\n\\n if mode == tf.estimator.ModeKeys.EVAL:\\n return tf.estimator.EstimatorSpec(\\n mode, loss=loss, eval_metric_ops=metrics)\\n\\n # Create training op.\\n assert mode == tf.estimator.ModeKeys.TRAIN\\n optimizer = tf.train.AdagradOptimizer(learning_rate=learning_rate)\\n train_op = optimizer.minimize(loss, global_step=tf.train.get_global_step())\\n return tf.estimator.EstimatorSpec(mode, loss=loss, train_op=train_op)\",\n \"def forward(self,\\n *args,\\n inputs: torch.nn.Module,\\n step_fn: torch.nn.Module, ) -> torch.Tensor:\\n timestep = 0\\n hidden = inputs\\n # halting_prob_cumulation: (batch, seq_len)\\n halting_prob_cumulation = hidden.new_zeros(hidden.size()[:-1]).float()\\n\\n while timestep < self._max_computing_time and \\\"TODO: exit if all place exhausted\\\":\\n # current all alive tokens, which need further computation\\n # alive_mask: (batch, seq_len)\\n alive_mask: torch.Tensor = halting_prob_cumulation < 1.\\n alive_mask = alive_mask.float()\\n\\n # halting_prob: (batch, seq_len) <- (batch, seq_len, 1)\\n halting_prob = self._halting_fn(hidden).squeeze(-1)\\n\\n # temp_cumulation: (batch, seq_len)\\n temp_cumulation = halting_prob * alive_mask + halting_prob_cumulation\\n\\n # mask to the newly halted tokens, which is exhausted at the current timestep of computation\\n # new_halted: (batch, seq_len)\\n new_halted = (temp_cumulation > self._threshold).float()\\n remainder = 1. - halting_prob_cumulation + 1.e-10\\n\\n # all tokens that survives from the current timestep's computation\\n # alive_mask: (batch, seq_len)\\n alive_mask = (1 - new_halted) * alive_mask\\n\\n halting_prob_cumulation += halting_prob * alive_mask\\n # cumulations for newly halted positions will reach 1.0 after adding up remainder at the current timestep\\n halting_prob_cumulation += remainder * new_halted\\n\\n step_out = step_fn(hidden, *args, timestep)\\n timestep += 1\\n state_update_weight = alive_mask.unsqueeze(-1)\\n hidden = state_update_weight * step_out + (1 - state_update_weight) * hidden\\n\\n return hidden\",\n \"def lstm_backward(dh, cache):\\n dx, dh_prev, dWx, dWh, db = None, None, None, None, None\\n #############################################################################\\n # TODO: Implement the backward pass for an LSTM over an entire timeseries. #\\n # You should use the lstm_step_backward function that you just defined. #\\n #############################################################################\\n\\n N,T,H = dh.shape\\n tmp_x = cache[T-1][0]\\n D = tmp_x.shape[1]\\n # cache is a list of these values -- so cache[0] is\\n # x, i, f, o, g, prev_h, next_h, prev_c, next_c, Wx, Wh, b = cache\\n dnext_h = dh\\n\\n dx = np.zeros((N,T,D))\\n dh_prev = np.zeros((N,H))\\n dc_prev = np.zeros((N,H))\\n dWx = np.zeros((D,4*H))\\n dWh = np.zeros((H,4*H))\\n db = np.zeros((4*H))\\n\\n for t in reversed(range(0,T)):\\n # current gradient at timestep is the upstream gradient (provided as input)\\n # this may be coming from the Y as in the min_char_rnn.py (see line 59)\\n # + downstream gradient provided by rnn_step_backward.\\n dh_curr = dh[:,t,:] + dh_prev\\n dx_, dh_prev, dc_prev, dWx_, dWh_, db_ = lstm_step_backward(dh_curr, dc_prev, cache[t])\\n dWx += dWx_\\n dWh += dWh_\\n db += db_\\n dx[:,t,:]=dx_\\n\\n ##############################################################################\\n # END OF YOUR CODE #\\n ##############################################################################\\n\\n return dx, dh_prev, dWx, dWh, db\",\n \"def L_model_forward(X, parameters):\\n pass\",\n \"def __init__(self, input_size=1, hidden_layer_size=100, aux_features_size=31, output_size=1):\\n super().__init__()\\n self.hidden_layer_size = hidden_layer_size # TODO [tuning] different size (?)\\n\\n # TODO [tuning] BiLSTM (?)\\n self.lstm = nn.LSTM(input_size=input_size, hidden_size=hidden_layer_size, batch_first=True)\\n self.linear_aux = nn.Linear(aux_features_size, hidden_layer_size, bias=True) # TODO try with bias=False (?)\\n self.linear = nn.Linear(hidden_layer_size, output_size, bias=True) # TODO try with bias=False (?)\",\n \"def forward(self, input):\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n assert input.shape[1] == self.n_neurons, \\\"The shape of the input tensor is not correct.\\\"\\n\\n bn_fct = CustomBatchNormManualFunction()\\n out = bn_fct.apply(input, self.gamma, self.beta, self.eps)\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n return out\",\n \"def forwardPropagation(self, inputs, label):\\n node_hidden = np.dot(inputs, self.input_W)\\n node_hidden = np.add(node_hidden, self.input_B)\\n node_hidden = np.maximum(0, node_hidden)\\n node_output = np.dot(node_hidden, self.hidden_W)\\n node_output = np.add(node_output, self.hidden_B)\\n #print(node_output)\\n exp_node_output = np.exp(node_output)\\n node_output = exp_node_output / np.sum(exp_node_output, axis=1, keepdims=True)\\n #print(node_output)\\n #node_output = self.softmax(node_output)\\n loss = np.sum(-np.log(node_output[range(inputs.shape[0]),label]))/(inputs.shape[0])+0.5 * self.regularizer*np.sum(self.input_W *self.input_W)+0.5 * self.regularizer*np.sum(self.hidden_W *self.hidden_W)\\n \\\"\\\"\\\"Loss= Input data loss + Loss correction by penalizing the loss, here we use 0.2 as an experimental value\\\"\\\"\\\"\\n #loss = np.sum(-np.log(node_output[range(inputs.shape[0]), label])) / (inputs.shape[0]) + 0.2 * self.regularizer * np.sum(self.input_W ^ 2) + 0.2 * self.regularizer * np.sum(self.hidden_W ^ 2)\\n return loss, node_hidden, node_output\",\n \"def forward(inputs,weights,function=sigmoid,step=-1):\\n if step == 0:\\n return inputs\\n elif step == -1:\\n step = len(weights) #go to output layer \\n output = np.append(1, inputs)\\n for i in range(step):\\n output = np.append(1, function(np.dot(weights[i], output))) #calculating activation\\n return output[1:]\",\n \"def conv_step(self, parent_node_embedding, children_embedding, children_index, node_dim, w_t, w_r, w_l, b_conv):\\n with tf.compat.v1.name_scope('conv_step'):\\n # nodes is shape (batch_size x max_tree_size x node_dim)\\n # children is shape (batch_size x max_tree_size x max_children)\\n\\n with tf.compat.v1.name_scope('trees'):\\n \\n # add a 4th dimension to the parent nodes tensor\\n # nodes is shape (batch_size x max_tree_size x 1 x node_dim)\\n parent_node_embedding = tf.expand_dims(parent_node_embedding, axis=2)\\n # tree_tensor is shape\\n # (batch_size x max_tree_size x max_children + 1 x node_dim)\\n tree_tensor = tf.concat([parent_node_embedding, children_embedding], axis=2, name='trees')\\n\\n with tf.compat.v1.name_scope('coefficients'):\\n # coefficient tensors are shape (batch_size x max_tree_size x max_children + 1)\\n c_t = self.eta_t(children_index)\\n c_r = self.eta_r(children_index, c_t)\\n c_l = self.eta_l(children_index, c_t, c_r)\\n\\n # concatenate the position coefficients into a tensor\\n # (batch_size x max_tree_size x max_children + 1 x 3)\\n coef = tf.stack([c_t, c_r, c_l], axis=3, name='coef')\\n\\n with tf.compat.v1.name_scope('weights'):\\n # stack weight matrices on top to make a weight tensor\\n # (3, node_dim, conv_output_dim)\\n weights = tf.stack([w_t, w_r, w_l], axis=0)\\n\\n with tf.compat.v1.name_scope('combine'):\\n batch_size = tf.shape(input=children_index)[0]\\n max_tree_size = tf.shape(input=children_index)[1]\\n max_children = tf.shape(input=children_index)[2]\\n\\n # reshape for matrix multiplication\\n x = batch_size * max_tree_size\\n y = max_children + 1\\n result = tf.reshape(tree_tensor, (x, y, node_dim))\\n coef = tf.reshape(coef, (x, y, 3))\\n result = tf.matmul(result, coef, transpose_a=True)\\n result = tf.reshape(result, (batch_size, max_tree_size, 3, node_dim))\\n\\n # output is (batch_size, max_tree_size, conv_output_dim)\\n result = tf.tensordot(result, weights, [[2, 3], [0, 1]])\\n\\n # output is (batch_size, max_tree_size, conv_output_dim)\\n\\n # output = tf.nn.tanh(result + b_conv, name='conv')\\n output = tf.nn.leaky_relu(result + b_conv)\\n # output = tf.compat.v1.nn.swish(result + b_conv)\\n # output = tf.layers.batch_normalization(output, training=self.placeholders['is_training'])\\n output_drop_out = tf.nn.dropout(output, rate=self.placeholders[\\\"dropout_rate\\\"]) # DROP-OUT here\\n return output_drop_out\",\n \"def lstm_model(input_size, output_size, embedding, num_nodes, num_unrollings, batch_size,\\n learning_rate, exp_decay = None, gradient_max_value = 1.25, dropout_prob = 0.0):\\n\\n graph = tf.Graph()\\n with graph.as_default():\\n # [ix, fx, cx, ox]\\n x_mat = training.utils.gaussian_weights_variable([input_size, 4*num_nodes])\\n # [im, fm, cm, om]\\n o_mat = training.utils.gaussian_weights_variable([num_nodes, 4*num_nodes])\\n # [ib, fb, cb, ob]\\n b_vec = tf.Variable(tf.zeros([1, 4*num_nodes]))\\n\\n # Variables saving state across unrollings.\\n saved_output = tf.Variable(tf.zeros([batch_size, num_nodes]), trainable=False)\\n saved_state = tf.Variable(tf.zeros([batch_size, num_nodes]), trainable=False)\\n # Classifier weights and biases.\\n w = training.utils.gaussian_weights_variable([num_nodes, output_size])\\n b = tf.Variable(tf.zeros([output_size]))\\n\\n # Definition of the cell computation.\\n def lstm_cell(i, o, state):\\n \\\"\\\"\\\"Create a LSTM cell. See e.g.: http://arxiv.org/pdf/1402.1128v1.pdf\\n Note that in this formulation, we omit the various connections between the\\n previous state and the gates.\\\"\\\"\\\"\\n mult = tf.matmul(i, x_mat) + tf.matmul(o, o_mat) + b_vec\\n\\n input_gate = tf.sigmoid(mult[:, 0:num_nodes])\\n forget_gate = tf.sigmoid(mult[:, num_nodes:2*num_nodes])\\n state = forget_gate * state + input_gate * tf.tanh(mult[:, 2*num_nodes:3*num_nodes])\\n output_gate = tf.sigmoid(mult[:, 3*num_nodes:4*num_nodes])\\n return output_gate * tf.tanh(state), state\\n\\n # Input data.\\n before_embedding_size = input_size\\n if embedding is not None:\\n before_embedding_size = embedding.shape[0]\\n\\n train_data = list()\\n for _ in range(num_unrollings + 1):\\n train_data.append(\\n tf.placeholder(tf.float32, shape=[batch_size, before_embedding_size]))\\n train_inputs = train_data[:num_unrollings]\\n train_labels = train_data[1:] # Labels are inputs shifted by one time step.\\n\\n # Unrolled LSTM loop.\\n outputs = list()\\n output = saved_output\\n state = saved_state\\n for i in train_inputs:\\n if embedding is not None:\\n # Converting the input to the embedding.\\n indices = tf.argmax(i, 1)\\n i = tf.nn.embedding_lookup(embedding, indices)\\n # Dropout is only applied to inputs, not to recurrent connections.\\n i = tf.nn.dropout(i, 1 - dropout_prob)\\n output, state = lstm_cell(i, output, state)\\n outputs.append(output)\\n\\n # State saving across unrollings.\\n with tf.control_dependencies([saved_output.assign(output),\\n saved_state.assign(state)]):\\n # Classifier.\\n # Dropout is also applied to the output of the LSTM cell, only when\\n # used for the projection, as it is not recurrent.\\n outputs = tf.concat(0, outputs)\\n outputs = tf.nn.dropout(outputs, 1 - dropout_prob)\\n logits = tf.nn.xw_plus_b(outputs, w, b)\\n loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(\\n logits, tf.concat(0, train_labels)))\\n\\n # Optimizer.\\n global_step = tf.Variable(0)\\n\\n if exp_decay is not None:\\n learning_rate = tf.train.exponential_decay(\\n learning_rate, global_step,\\n exp_decay['decay_steps'], exp_decay['decay_rate'], exp_decay['staircase'])\\n\\n optimizer = tf.train.GradientDescentOptimizer(learning_rate)\\n # Clipping to avoid exploding gradient.\\n gradients, v = zip(*optimizer.compute_gradients(loss))\\n gradients, _ = tf.clip_by_global_norm(gradients, gradient_max_value)\\n optimizer = optimizer.apply_gradients(zip(gradients, v), global_step=global_step)\\n\\n # Predictions.\\n train_prediction = tf.nn.softmax(logits)\\n\\n # Sampling and validation eval: batch 1, no unrolling.\\n sample_input_ph = tf.placeholder(tf.float32, shape=[1, before_embedding_size])\\n saved_sample_output = tf.Variable(tf.zeros([1, num_nodes]))\\n saved_sample_state = tf.Variable(tf.zeros([1, num_nodes]))\\n reset_sample_state = tf.group(\\n saved_sample_output.assign(tf.zeros([1, num_nodes])),\\n saved_sample_state.assign(tf.zeros([1, num_nodes])))\\n\\n sample_input = sample_input_ph\\n if embedding is not None:\\n indices = tf.argmax(sample_input_ph, 1)\\n sample_input = tf.nn.embedding_lookup(embedding, indices)\\n\\n sample_output, sample_state = lstm_cell(\\n sample_input, saved_sample_output, saved_sample_state)\\n with tf.control_dependencies([saved_sample_output.assign(sample_output),\\n saved_sample_state.assign(sample_state)]):\\n sample_prediction = tf.nn.softmax(tf.nn.xw_plus_b(sample_output, w, b))\\n\\n tf_graph = {\\n 'graph': graph,\\n 'data_ph': train_data,\\n 'sample_ph': sample_input_ph }\\n tf_predictions = [train_prediction, sample_prediction]\\n\\n return tf_graph, optimizer, loss, tf_predictions, reset_sample_state\",\n \"def forward(self, model, sample, reduce=True):\\n # print('sample',sample)\\n vad, asr = False, False\\n assert len(set(sample['task'])) == 1\\n task = sample['task'][0]\\n assert task == 'vad'\\n vad = True\\n net_output = model(**sample['net_input'])\\n\\n logits_vad = net_output['encoder_seq_out']\\n features = net_output['features']\\n ts_embedding = net_output['ts_embedding']\\n\\n ori_targets = model.get_targets(sample, net_output)\\n ts_targets = sample[\\\"target_ts\\\"]\\n non_padding_mask = ~net_output[\\\"padding_mask\\\"]\\n input_lengths = non_padding_mask.long().sum(-1)\\n #targets = ts_targets.expand(logits_vad.size(0), logits_vad.size(1))\\n targets = ts_targets\\n\\n targets = targets.contiguous().view(-1).long()\\n # targets = model.get_targets(sample, net_output).view(-1).long()\\n lprobs = F.softmax(logits_vad, dim=-1, dtype=torch.float32)\\n\\n\\n if vad:\\n loss_ts_vad = self.criterion_ts_vad(logits_vad.view(-1, logits_vad.size(-1)), targets)\\n contrasitive_loss = self.contrastive_loss(features.contiguous().view(-1, features.size(-1)), ts_embedding.contiguous().view(-1, ts_embedding.size(-1)), targets)\\n\\n loss = loss_ts_vad + contrasitive_loss\\n else:\\n print('batch error', targets)\\n sys.exit()\\n\\n target_lengths = sample[\\\"target_lengths\\\"]\\n\\n ntokens = len(targets)\\n sample_size = 1 # sample['target'].size(0) if self.sentence_avg else ntokens #sample['ntokens']\\n\\n logging_output = {\\n 'loss': loss.data,\\n }\\n\\n if vad:\\n logging_output['loss_vad'] = loss.data\\n preds = logits_vad.view(-1, logits_vad.size(-1)).argmax(dim=-1)\\n #sil_cnt = (targets == 2).sum()\\n ts_cnt = (targets == 0).sum()\\n pred_ts_cnt = (preds == 0).sum()\\n #assert sil_cnt + sp_cnt == len(targets)\\n #assert sil_cnt + sp_cnt == len(preds)\\n\\n try:\\n logging_output['n_pred_ts'] = pred_ts_cnt\\n logging_output['n_ts'] = ts_cnt\\n\\n logging_output['ncorrect_vad'] = (preds == targets).sum()\\n logging_output['ncorrect_ts'] = ((preds == 0) & (targets == 0)).sum()\\n # print(111111,logging_output['ncorrect_sil']/sil_cnt,logging_output['ncorrect_sp']/sp_cnt)\\n # print(1111,sil_cnt,sp_cnt,((preds == 1) & (targets == 1)).sum(),((preds == 0) & (targets == 0)).sum())\\n except:\\n print('vad sample_size error')\\n logging_output['ncorrect_vad'] = 0\\n logging_output['nsentences_vad'] = sample['target'].size(0)\\n logging_output['sample_size_vad'] = sample_size\\n logging_output['ntokens_vad'] = ntokens\\n logging_output[\\\"c_errors\\\"] = 0\\n logging_output[\\\"c_total\\\"] = 0\\n\\n return loss, sample_size, logging_output\",\n \"def forward(self, inputs, hidden):\\n batch_size = inputs[0].size(1)\\n\\n embed_sum = None\\n for feat, layer in zip(inputs, self.fcs):\\n if embed_sum is None:\\n embed_sum = layer(feat.view(-1, feat.size(2)))\\n else:\\n embed_sum = embed_sum + layer(feat.view(-1, feat.size(2)))\\n # import pdb; pdb.set_trace()\\n embeds = self.relu1(embed_sum)\\n embeds = self.bn1(embeds)\\n\\n # re-expand the network outputs 6\\n embeds = embeds.view(-1, batch_size, self.hidden_dim)\\n lstm_out, hidden = self.lstm(embeds, hidden)\\n out = self.fc2(lstm_out.view(-1, lstm_out.size(2)))\\n out = out.view(-1, batch_size, self.output_dim)\\n out = self.sigmoid(out)\\n return out, hidden\",\n \"def forward(self, inputs, hidden):\\n batch_size = inputs[0].size(1)\\n\\n embed_sum = None\\n for feat, layer in zip(inputs, self.fcs):\\n if embed_sum is None:\\n embed_sum = layer(feat.view(-1, feat.size(2)))\\n else:\\n embed_sum = embed_sum + layer(feat.view(-1, feat.size(2)))\\n # import pdb; pdb.set_trace()\\n embeds = self.relu1(embed_sum)\\n embeds = self.bn1(embeds)\\n\\n # re-expand the network outputs 6\\n embeds = embeds.view(-1, batch_size, self.hidden_dim)\\n lstm_out, hidden = self.lstm(embeds, hidden)\\n out = self.fc2(lstm_out.view(-1, lstm_out.size(2)))\\n out = out.view(-1, batch_size, self.output_dim)\\n out = self.sigmoid(out)\\n return out, hidden\",\n \"def forward(self, features, features_lengths, spkids):\\n pass\",\n \"def forward(self, x):\\n #print('output of fetures.children() : %s'%str([i for i in self.features.children()]))\\n #print(\\\"shape of input is %s\\\" % str(x.size()))\\n for layer_no, layer in enumerate(self.features.children()):\\n\\n if layer_no is 23:\\n y = layer(x)\\n if layer_no is 33:\\n z = layer(x)\\n x = layer(x)\\n\\n #print('debug')\\n #print('layer info: %s'%str(layer))\\n #print(\\\"shape of x is %s\\\" % str(x.size()))\\n\\n x = self.conv1D_downstream1(x)\\n x = self.conv1D_downstream2(x)\\n x = self.upsample_1(x)\\n\\n z = self.conv1D_pool4(z)\\n y = self.conv1D_pool3(y)\\n #print('debug')\\n #print(\\\"shape of x is %s\\\"%str(x.size()))\\n #print(\\\"shape of z is %s\\\" % str(z.size()))\\n\\n if x.size() is not z.size():\\n x = nn.functional.interpolate(x,size = (z.size()[2],z.size()[3]), mode = 'nearest')\\n x = x+ z\\n x = self.upsample_2(x)\\n x = x+y\\n x = self.upsample_3(x)\\n\\n return x\",\n \"def forward(self, input, hidden):\\r\\n output, hidden = self.rnn(input, hidden)\\r\\n output = f.log_softmax(self.out(output.squeeze(1)), 1)\\r\\n return output, hidden\",\n \"def MultiLSTM(inputs,weights):\\n w_kernel = weights['w_kernel']\\n w_recurrent = weights['w_recurrent']\\n w_bias = weights['w_bias']\\n T = inputs.shape[-2]\\n H = []\\n for t in range(T):\\n if t > 0:\\n z = tf.einsum('knx,xj->knj',inputs[:,:,t,:],w_kernel) + tf.einsum('knl,lj->knj',h,w_recurrent) + tf.expand_dims(w_bias,0)\\n else:\\n z = tf.einsum('knx,xj->knj',inputs[:,:,t,:],w_kernel) + tf.expand_dims(w_bias,0)\\n i,f,o,u = tf.split(z,4,axis=-1)\\n i = tf.sigmoid(i) #input gate\\n f = tf.sigmoid(f + 1.0) #forget gate\\n o = tf.sigmoid(o) #output gate\\n u = tf.tanh(u) #information let in by input gate\\n if t > 0:\\n c = f * c + i * u\\n else:\\n c = i * u\\n h = o * tf.tanh(c)\\n H.append(h)\\n H = tf.stack(H,-2)\\n return(H)\",\n \"def forward(self, state):\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n x = F.relu(self.fc3(x))\\n return self.fc4(x)\",\n \"def forward(self, feature_indices, feature_values):\\n \\n \\n #feature_values = torch.nn.functional.dropout(feature_values, p = self.args.dropout, training = self.training)\\n feature=torch.sparse.FloatTensor(feature_indices,feature_values,torch.Size([self.args.nu,self.args.ne])).to(self.device).float()\\n latent_features_1 = torch.nn.functional.relu(self.layer_1(feature))\\n latent_features_1 = torch.nn.functional.dropout(latent_features_1, p = self.args.dropout, training = self.training)\\n latent_features_2 = self.layer_2(latent_features_1)\\n\\n if self.args.model==\\\"exact\\\": \\n self.predictions = torch.mm(torch.nn.functional.dropout(self.propagator, p = self.args.dropout, training = self.training), latent_features_2)\\n else:\\n localized_predictions = latent_features_2\\n edge_weights = torch.nn.functional.dropout(self.edge_weights, p = self.args.dropout, training = self.training)\\n self.A_=torch.sparse.FloatTensor(self.edge_indices,self.edge_weights,torch.Size([self.args.nu,self.args.nu])).to(self.device).float()\\n for iteration in range(self.args.iter_time): \\n localized_predictions = (1-self.args.alpha)*torch.spmm(self.A_, localized_predictions)+self.args.alpha*latent_features_2\\n self.predictions = localized_predictions \\n \\n self.predictions = torch.nn.functional.log_softmax(self.predictions , dim=1)\\n return self.predictions\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6560829","0.6491293","0.64687145","0.6263219","0.6240839","0.6211139","0.61944425","0.61904705","0.6172884","0.6169751","0.616302","0.6126835","0.60965496","0.60779876","0.6044476","0.6039012","0.60056037","0.6002348","0.5969338","0.596877","0.5955149","0.59262687","0.5920903","0.58881646","0.58796","0.58500004","0.5843868","0.58298874","0.58219355","0.5818881","0.58136666","0.5808412","0.57921225","0.5791758","0.5788975","0.57856625","0.57482135","0.57364553","0.57323563","0.57322043","0.5705553","0.5680556","0.5680222","0.5674047","0.5674047","0.5674047","0.5674047","0.5674047","0.5660097","0.56371444","0.5631475","0.5623185","0.56210494","0.5619964","0.56175625","0.5612475","0.5611775","0.56087774","0.5608493","0.5606401","0.5597659","0.55958164","0.558915","0.5589008","0.5588763","0.55881596","0.5580825","0.5578178","0.55774397","0.55705667","0.55675274","0.5556771","0.5554681","0.5554588","0.5553198","0.554787","0.55446845","0.55422264","0.55177146","0.5516272","0.550769","0.55064094","0.55062777","0.5500743","0.5500293","0.54935694","0.5487883","0.5486982","0.548642","0.54858196","0.5484586","0.5482742","0.5480526","0.5480526","0.5479319","0.5476963","0.54752344","0.54751354","0.5474322","0.5472571"],"string":"[\n \"0.6560829\",\n \"0.6491293\",\n \"0.64687145\",\n \"0.6263219\",\n \"0.6240839\",\n \"0.6211139\",\n \"0.61944425\",\n \"0.61904705\",\n \"0.6172884\",\n \"0.6169751\",\n \"0.616302\",\n \"0.6126835\",\n \"0.60965496\",\n \"0.60779876\",\n \"0.6044476\",\n \"0.6039012\",\n \"0.60056037\",\n \"0.6002348\",\n \"0.5969338\",\n \"0.596877\",\n \"0.5955149\",\n \"0.59262687\",\n \"0.5920903\",\n \"0.58881646\",\n \"0.58796\",\n \"0.58500004\",\n \"0.5843868\",\n \"0.58298874\",\n \"0.58219355\",\n \"0.5818881\",\n \"0.58136666\",\n \"0.5808412\",\n \"0.57921225\",\n \"0.5791758\",\n \"0.5788975\",\n \"0.57856625\",\n \"0.57482135\",\n \"0.57364553\",\n \"0.57323563\",\n \"0.57322043\",\n \"0.5705553\",\n \"0.5680556\",\n \"0.5680222\",\n \"0.5674047\",\n \"0.5674047\",\n \"0.5674047\",\n \"0.5674047\",\n \"0.5674047\",\n \"0.5660097\",\n \"0.56371444\",\n \"0.5631475\",\n \"0.5623185\",\n \"0.56210494\",\n \"0.5619964\",\n \"0.56175625\",\n \"0.5612475\",\n \"0.5611775\",\n \"0.56087774\",\n \"0.5608493\",\n \"0.5606401\",\n \"0.5597659\",\n \"0.55958164\",\n \"0.558915\",\n \"0.5589008\",\n \"0.5588763\",\n \"0.55881596\",\n \"0.5580825\",\n \"0.5578178\",\n \"0.55774397\",\n \"0.55705667\",\n \"0.55675274\",\n \"0.5556771\",\n \"0.5554681\",\n \"0.5554588\",\n \"0.5553198\",\n \"0.554787\",\n \"0.55446845\",\n \"0.55422264\",\n \"0.55177146\",\n \"0.5516272\",\n \"0.550769\",\n \"0.55064094\",\n \"0.55062777\",\n \"0.5500743\",\n \"0.5500293\",\n \"0.54935694\",\n \"0.5487883\",\n \"0.5486982\",\n \"0.548642\",\n \"0.54858196\",\n \"0.5484586\",\n \"0.5482742\",\n \"0.5480526\",\n \"0.5480526\",\n \"0.5479319\",\n \"0.5476963\",\n \"0.54752344\",\n \"0.54751354\",\n \"0.5474322\",\n \"0.5472571\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6306742"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":79099,"cells":{"query":{"kind":"string","value":"Get c and h of all children"},"document":{"kind":"string","value":"def get_child_states(self, tree):\n # add extra singleton dimension in middle...\n # because pytorch needs mini batches... :sad:\n if tree.num_children==0:\n child_c = Var(torch.zeros(1,1,self.mem_dim))\n child_h = Var(torch.zeros(1,1,self.mem_dim))\n if self.cudaFlag:\n child_c, child_h = child_c.cuda(), child_h.cuda()\n else:\n child_c = Var(torch.Tensor(tree.num_children,1,self.mem_dim))\n child_h = Var(torch.Tensor(tree.num_children,1,self.mem_dim))\n if self.cudaFlag:\n child_c, child_h = child_c.cuda(), child_h.cuda()\n for idx in range(tree.num_children):\n child_c[idx] = tree.children[idx].state[0]\n child_h[idx] = tree.children[idx].state[1]\n # child_c[idx], child_h[idx] = tree.children[idx].state\n return child_c, child_h"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def Children(self) -> _n_1_t_2:","def get_children(self, i, elems):\n # if len(elems) == 1:\n # return []\n # elif self.explored[i]:\n # return self.children[i]\n # else:\n self.children[i], self.children_elems[i] = self._get_children(list(elems)) # all_two_partitions(list(elems))\n\n # self.update_from_children(i, (ch_l, ch_r))\n return self.children[i], self.children_elems[i]","def getChildren():","def get_childs(self):\n\t\treturn self.__childs","def get_hnodes(self,h):\n t_nodes = self.get_h(h)\n for t_node in t_nodes:\n t_node = self.tree.get_node(t_node)\n self.check_childs(t_node.identifier)","def get_all_children(self):\n return tuple(self.children)","def get_children(self):\n return self.children","def get_children(self):\r\n return self.children","def children(self) -> Iterable[Heirarchical]:\n return []","def get_children(self):\n\n pass","def children(self):\n return [self.cut]","def get_children(self):\n return []","def get_children(self):\n return self.children","def get_children(self):\n return self.children","def get_children(self):\n return self.children","def get_children_elements(self):\n\n pass","def get_children(self):\r\n return self._children","def children(node):\n\n return snd(node)","def getChildren(self):\n return self.child_edges","def _all_children(self) -> list[Container]:\n\n def get() -> list[Container]:\n result: list[Container] = []\n\n # Padding Top.\n if self.align in (VerticalAlign.CENTER, VerticalAlign.BOTTOM):\n result.append(Window(width=Dimension(preferred=0)))\n\n # The children with padding.\n for child in self.children:\n result.append(child)\n result.append(\n Window(\n height=self.padding,\n char=self.padding_char,\n style=self.padding_style,\n )\n )\n if result:\n result.pop()\n\n # Padding right.\n if self.align in (VerticalAlign.CENTER, VerticalAlign.TOP):\n result.append(Window(width=Dimension(preferred=0)))\n\n return result\n\n return self._children_cache.get(tuple(self.children), get)","def get_array_of_children(self):\n children = [self.posXposYposZ,self.posXposYnegZ,self.posXnegYposZ,self.posXposYnegZ,self.negXposYposZ,self.negXposYnegZ,self.negXnegYposZ,self.negXnegYnegZ ] \n return children","def _all_children(self) -> list[Container]:\n\n def get() -> list[Container]:\n result: list[Container] = []\n\n # Padding left.\n if self.align in (HorizontalAlign.CENTER, HorizontalAlign.RIGHT):\n result.append(Window(width=Dimension(preferred=0)))\n\n # The children with padding.\n for child in self.children:\n result.append(child)\n result.append(\n Window(\n width=self.padding,\n char=self.padding_char,\n style=self.padding_style,\n )\n )\n if result:\n result.pop()\n\n # Padding right.\n if self.align in (HorizontalAlign.CENTER, HorizontalAlign.LEFT):\n result.append(Window(width=Dimension(preferred=0)))\n\n return result\n\n return self._children_cache.get(tuple(self.children), get)","def GetChildren(self, p_int, p_int_1, p_int_2):\n ...","def getChildren(self):\n return []","def children(self):\n return tuple(getattr(self, i) for i in self._traversable)","def get_children(self):\n return self.items","def getchildren(self):\n return self.root.getchildren()","def elements(self):\n for c in self.children:\n yield c\n for c2 in c.elements:\n yield c2","def GetChildren( self ):\n children = [\n cWrpr \n for cWrpr in GameNodePath.GetChildren( self ) \n if not cWrpr.data.getPythonTag( TAG_IGNORE )\n ]\n return children","def children(self):\n return self.contents","def children(self):\n return self.contents","def children(self):\n return self._children","def children(self):\n return self._children","def get_children(self):\n raise NotImplementedError()","def get_child_nodes(self):\n parts = []\n for child in sorted(self.children, key=lambda c: c.start):\n child_part = (child.start, child.end, child)\n parts.append(child_part)\n return parts","def get_children(self):\n return self._children","def children(self): # noqa: ANN201","def children(self):\n return self.hashring_watch.get_children()","def children(self):\n return self.leaves","def get_children(self):\n return [node for node in self._children.values()]","def childWells(self):\n if self.childWellIndices() is None:\n return []\n tcs=[]\n for idx in self.childWellIndices():\n tcs.append(self.clsParent.clsWells[idx])\n\n return tcs","def children(self):\n \n return self._children","def get_children(self):\n offset = self.offset_pad(self._determine_key(True))\n if self.ValueLength > 0:\n # Nasty hardcoding unicode (length*2) length in here, \n # but what else can we do?\n return self.obj_vm.read(offset, self.ValueLength * 2)\n else:\n return self._recurse_children(offset)","def get_children(self):\n children = []\n for node in self.node.get_children():\n children.append(Geom(node))\n return children","def children_list(self):\n return [\n # self.notify,\n # self.snap_multiplier,\n # self.range_low, self.range_high,\n # self.activity_threshold\n ]","def children(self):\n return {x[1] for x in self.outgoing}","def get_children(self):\n std = self._std\n bld = self._bld\n cls = self.__class__\n\n root = self.get_sobj()\n cit = std.NewChildIterator(root)\n cit.InitEx(0)\n\n children = []\n while cit.More():\n node = cls(std, bld, cit.Value().GetID(), self)\n if node.is_alive():\n children.append(node)\n cit.Next()\n return children","def children(phi):\n ret = []\n if hasattr(phi, 'x'):\n ret.append(phi.x)\n if hasattr(phi, 'y'):\n assert isinstance(phi, amnet.Mu) or \\\n isinstance(phi, amnet.Stack)\n ret.append(phi.y)\n if hasattr(phi, 'z'):\n assert isinstance(phi, amnet.Mu)\n ret.append(phi.z)\n\n assert len(ret) <= 3\n return ret","def positions(self):\n def expand(p):\n yield p\n for ch in self.children(p):\n for _c in expand(ch):\n yield _c\n return expand(self.root())","def GetChildren(self):\r\n\r\n return self._children","def children(self):\n return list(self._children)","def children(self, i):\n if i < 0:\n raise IndexError()\n return self._children[i]","def get_children(self):\r\n\r\n # FIXME: Expose iteration from CIndex, PR6125.\r\n def visitor(child, parent, children):\r\n # FIXME: Document this assertion in API.\r\n # FIXME: There should just be an isNull method.\r\n assert child != conf.lib.clang_getNullCursor()\r\n\r\n # Create reference to TU so it isn't GC'd before Cursor.\r\n child._tu = self._tu\r\n children.append(child)\r\n return 1 # continue\r\n children = []\r\n conf.lib.clang_visitChildren(self, callbacks['cursor_visit'](visitor),\r\n children)\r\n return iter(children)","def getChildren(self):\n \n return self._children","def children(v=()):\n assert all([isinstance(w, Widget) for w in v])\n return tuple(v)","def _get_children(self) -> Sequence[\"HallwayState\"]:\n if self.cur_pos < self.end_pos:\n if self.cur_pos > 0: # Stop the hallway from going negative\n yield self.new(self.cur_pos - 1)\n yield self.new(self.cur_pos + 1)","def _get_children(self):\n return set()","def get_cells(self):\n return [\n cell for column in self.children for cell in column.get_cells()]","def get_child_descriptors(self):\r\n return self.descriptor.get_children()","def getBufferChildren(self, buffertop):\n children = [v for k, v in self.GS_arcs if k == buffertop]\n return children","def fm_all_children(self):\n return self._relation_lst[self.CHILD].copy()","def get_children(self, child_range=None):\n child_c, child_r = self.collection.get_child()\n child_c = [\"{}\".format(c) for c in child_c]\n res = child_c + child_r\n if child_range:\n start, stop = (int(el) for el in child_range.split(\"-\", 1))\n # map CDMI range value to python index\n stop += 1\n else:\n start = 0\n stop = len(res)\n return res[start:stop]","def get_children(self):\n return NodeList(self._my_map['childNodes'])","def children(self, pos):\n return range(self.dary * pos + 1, min(self.dary * (pos + 1) + 1, len(self.heap)))","def _naive_layout(self) -> List[Tuple[int, int]]:\n positions = []\n width = self.parent_component.width\n height = self.parent_component.height\n padding = self.parent_component.padding\n for child in self.parent_component.children:\n cwidth, cheight = child.width, child.height\n props = child.props\n top = 0\n left = 0\n # handle horizontal and vertical alignments\n if props.h_alignment is HAlignment.LEFT:\n left = child.margin[0] + padding[0]\n elif props.h_alignment is HAlignment.CENTER:\n left = width / 2 - cwidth / 2\n elif props.h_alignment is HAlignment.RIGHT:\n left = width - (child.margin[1] + cwidth + padding[1])\n \n if props.v_alignment is VAlignment.TOP:\n top = child.margin[2] + padding[2]\n elif props.v_alignment is VAlignment.CENTER:\n top = height / 2 - cheight / 2\n elif props.v_alignment is VAlignment.BOTTOM:\n top = height - (child.margin[3] + cheight + padding[3])\n \n offset = child.offset\n positions.append((left + offset[0], top + offset[1]))\n return positions","def getChilds(self, index):\n return index, (2 * index) + 1, (2 * index) + 2","def get_children(self):\n children = []\n for i in self.children_ids:\n child = Comment(self.articleID, self.children_ids[i])\n children.append(child)\n children.extend(child.get_children())\n return children","def _all_subnodes(self):\n return self.__dict__.values()","def firsts(self):\r\n return self._children_of[None]","def children(self) -> Tuple[CombinatorialClassType, ...]:\n if self._children is None:\n self._children = self._strategy.decomposition_function(self.comb_class)\n if self._children is None:\n raise StrategyDoesNotApply(\"{} does not apply\".format(self._strategy))\n return self._children","def get_child_descriptors(self):\r\n if self.child_descriptor is None:\r\n return []\r\n\r\n return [self.child_descriptor]","def _get_children_ixs(self, parent_ix):\n ix_left = (parent_ix * 2) + 1\n ix_right = ix_left + 1\n if ix_left >= len(self):\n ix_left = None\n if ix_right >= len(self):\n ix_right = None\n return ix_left, ix_right","def children(self):\n try:\n attr_name = 'Parrot_%s_attributes' % self.pmc_name\n attr_type = gdb.lookup_type(attr_name).pointer()\n\n attrs = self.val['data'].cast(attr_type).dereference()\n\n '''\n Something ridiculous happens here. I take a list of tuples:\n [ (\"key1\", \"val1\"), (\"key2\", \"val2\") ]\n\n and turn it, in one iteration, into:\n [\n [(\"name\", \"key1\"), (\"value\", \"val1\")],\n [(\"name\", \"key2\"), (\"value\", \"val2\")]\n ]\n\n That, in turn, is mutated into one list.\n [\n (\"name\", \"key1\"), (\"value\", \"val1\"),\n (\"name\", \"key2\"), (\"value\", \"val2\")\n ]\n\n What we go through for 100% lazy iteration.\n '''\n name_value_tuples = PMCIterator(attrs)\n nv_iter = itertools.imap(lambda val: [ (\"name\", val[0]), (\"value\", val[1]) ],\n name_value_tuples)\n nv_chain = itertools.chain.from_iterable(nv_iter)\n\n return nv_chain\n except RuntimeError as e:\n return [ ( \"__ERROR__\", \"\" ) ].__iter__()","def get_child_nodes(node):\r\n return list(iter_child_nodes(node))","def getChildren(self):\n if not self.Children:\n\n #print 'reached leave node {0}'.format(self.CommID)\n #raw_input()\n return [[], []]\n\n children = deque()\n parent = deque()\n for c in range(len(self.Children)):\n children.append(self.Children[c])\n parent.append(self.CommID)\n retval = (children, parent)\n\n #print 'retval of ID {0} is {1}'.format(self.CommID, retval)\n #raw_input('wait')\n\n return retval","def getChildren(self):\n if not self.Children:\n\n #print 'reached leave node {0}'.format(self.CommID)\n #raw_input()\n return [[], []]\n\n children = deque()\n parent = deque()\n for c in range(len(self.Children)):\n children.append(self.Children[c])\n parent.append(self.CommID)\n retval = (children, parent)\n\n #print 'retval of ID {0} is {1}'.format(self.CommID, retval)\n #raw_input('wait')\n\n return retval","def get_children(self, parent):\n all_nodes = self.get_nodes()\n parent_index = all_nodes.index(parent)\n parent_family = self.__nodes[parent_index]\n children = parent_family[1:len(parent_family)]\n \n return [self.__nodes[child_index][0] for child_index in children]","def children(self):\n if self._children is None:\n return set()\n else:\n return self._children","def Children( cls, pid ):\n\t\tres = []\n\t\tpid = int(pid)\n\t\tfor cpid, cmd in cls.List().items():\n\t\t\tppid = int(cls.Status(cpid)[\"ppid\"])\n\t\t\tif ppid == pid:\n\t\t\t\tres.append( (cpid, None, cmd))\n\t\treturn res","def getSiblings():","def _get_children(self, x):\n try:\n return x._pfp__children\n\n except AttributeError:\n return []","def children(self, n):\n if self.left(n):\n yield self.left(n)\n if self.right(n):\n yield self.right(n)","def get_children(self):\n\n return self._children.copy()","def info(self):\n return nx.info(self.tree)\n\n\n # def children(self):\n \"\"\" Return the children of the current node.\n\n \"\"\"\n # return self.left, self.right","def generate_child_positions(self) -> List[Tuple[int, int]]:\n layout = self.parent_component.props.layout\n if layout == UILayoutType.LIST:\n return self._list_layout()\n elif layout == UILayoutType.GRID:\n pass\n elif layout == UILayoutType.MANUAL_GRID:\n pass\n else: # assume UILayoutType.NONE\n return self._naive_layout()","def descendants(self):\n for a in self._related(set(), 'children'):\n yield a","def get_children(self, parent):\n\n child_names = []\n for child in parent.children:\n child_names.append(child.label)\n return child_names","def get_children(self):\n children = []\n side_size = int(math.sqrt(len(self._state)))\n pos = self._state.index(0)\n row = pos // side_size\n col = pos % side_size\n moves = get_moves(side_size, col, row)\n for direction in moves:\n if moves[direction]['is_movable']:\n new_state = move(self._state, pos, moves[direction]['rel_pos'])\n children.append(Node(new_state, heuristic=self._heuristic,\n g_score=self._g_score+self._cost(self._state, new_state)))\n\n return children","def get_children(self):\n if not self.FileInfo:\n raise StopIteration(\"No children\")\n offset = self.offset_pad(self.FileInfo.obj_offset + self.ValueLength)\n return self._recurse_children(offset)","def units(self):\n return self.children()","def child_views(self):\n return self.children","def GetChildren(self, *args, **kwargs):\n pass","def children(self, p):\n if self.left(p) is not None:\n yield self.left(p)\n if self.right(p) is not None:\n yield self.right(p)","def children(self, p):\n if self.left(p) is not None:\n yield self.left(p)\n if self.right(p) is not None:\n yield self.right(p)","def children(self, p):\n if self.left(p) is not None:\n yield self.left(p)\n if self.right(p) is not None:\n yield self.right(p)","def children(self, p):\n if self.left(p) is not None:\n yield self.left(p)\n\n if self.right(p) is not None:\n yield self.right(p)","def children(self) -> List[Region]:\n return []","def pieces(self):\n return (self.leaf_nodes.order_by('piece')\n .values_list('piece', flat=True))","def children(self):\n l = []\n n = self.node.firstChild\n while n:\n l.append(XmlWrapper(n))\n n = n.nextSibling\n return l","def children(self):\n l = []\n n = self.node.firstChild\n while n:\n l.append(XmlWrapper(n))\n n = n.nextSibling\n return l"],"string":"[\n \"def Children(self) -> _n_1_t_2:\",\n \"def get_children(self, i, elems):\\n # if len(elems) == 1:\\n # return []\\n # elif self.explored[i]:\\n # return self.children[i]\\n # else:\\n self.children[i], self.children_elems[i] = self._get_children(list(elems)) # all_two_partitions(list(elems))\\n\\n # self.update_from_children(i, (ch_l, ch_r))\\n return self.children[i], self.children_elems[i]\",\n \"def getChildren():\",\n \"def get_childs(self):\\n\\t\\treturn self.__childs\",\n \"def get_hnodes(self,h):\\n t_nodes = self.get_h(h)\\n for t_node in t_nodes:\\n t_node = self.tree.get_node(t_node)\\n self.check_childs(t_node.identifier)\",\n \"def get_all_children(self):\\n return tuple(self.children)\",\n \"def get_children(self):\\n return self.children\",\n \"def get_children(self):\\r\\n return self.children\",\n \"def children(self) -> Iterable[Heirarchical]:\\n return []\",\n \"def get_children(self):\\n\\n pass\",\n \"def children(self):\\n return [self.cut]\",\n \"def get_children(self):\\n return []\",\n \"def get_children(self):\\n return self.children\",\n \"def get_children(self):\\n return self.children\",\n \"def get_children(self):\\n return self.children\",\n \"def get_children_elements(self):\\n\\n pass\",\n \"def get_children(self):\\r\\n return self._children\",\n \"def children(node):\\n\\n return snd(node)\",\n \"def getChildren(self):\\n return self.child_edges\",\n \"def _all_children(self) -> list[Container]:\\n\\n def get() -> list[Container]:\\n result: list[Container] = []\\n\\n # Padding Top.\\n if self.align in (VerticalAlign.CENTER, VerticalAlign.BOTTOM):\\n result.append(Window(width=Dimension(preferred=0)))\\n\\n # The children with padding.\\n for child in self.children:\\n result.append(child)\\n result.append(\\n Window(\\n height=self.padding,\\n char=self.padding_char,\\n style=self.padding_style,\\n )\\n )\\n if result:\\n result.pop()\\n\\n # Padding right.\\n if self.align in (VerticalAlign.CENTER, VerticalAlign.TOP):\\n result.append(Window(width=Dimension(preferred=0)))\\n\\n return result\\n\\n return self._children_cache.get(tuple(self.children), get)\",\n \"def get_array_of_children(self):\\n children = [self.posXposYposZ,self.posXposYnegZ,self.posXnegYposZ,self.posXposYnegZ,self.negXposYposZ,self.negXposYnegZ,self.negXnegYposZ,self.negXnegYnegZ ] \\n return children\",\n \"def _all_children(self) -> list[Container]:\\n\\n def get() -> list[Container]:\\n result: list[Container] = []\\n\\n # Padding left.\\n if self.align in (HorizontalAlign.CENTER, HorizontalAlign.RIGHT):\\n result.append(Window(width=Dimension(preferred=0)))\\n\\n # The children with padding.\\n for child in self.children:\\n result.append(child)\\n result.append(\\n Window(\\n width=self.padding,\\n char=self.padding_char,\\n style=self.padding_style,\\n )\\n )\\n if result:\\n result.pop()\\n\\n # Padding right.\\n if self.align in (HorizontalAlign.CENTER, HorizontalAlign.LEFT):\\n result.append(Window(width=Dimension(preferred=0)))\\n\\n return result\\n\\n return self._children_cache.get(tuple(self.children), get)\",\n \"def GetChildren(self, p_int, p_int_1, p_int_2):\\n ...\",\n \"def getChildren(self):\\n return []\",\n \"def children(self):\\n return tuple(getattr(self, i) for i in self._traversable)\",\n \"def get_children(self):\\n return self.items\",\n \"def getchildren(self):\\n return self.root.getchildren()\",\n \"def elements(self):\\n for c in self.children:\\n yield c\\n for c2 in c.elements:\\n yield c2\",\n \"def GetChildren( self ):\\n children = [\\n cWrpr \\n for cWrpr in GameNodePath.GetChildren( self ) \\n if not cWrpr.data.getPythonTag( TAG_IGNORE )\\n ]\\n return children\",\n \"def children(self):\\n return self.contents\",\n \"def children(self):\\n return self.contents\",\n \"def children(self):\\n return self._children\",\n \"def children(self):\\n return self._children\",\n \"def get_children(self):\\n raise NotImplementedError()\",\n \"def get_child_nodes(self):\\n parts = []\\n for child in sorted(self.children, key=lambda c: c.start):\\n child_part = (child.start, child.end, child)\\n parts.append(child_part)\\n return parts\",\n \"def get_children(self):\\n return self._children\",\n \"def children(self): # noqa: ANN201\",\n \"def children(self):\\n return self.hashring_watch.get_children()\",\n \"def children(self):\\n return self.leaves\",\n \"def get_children(self):\\n return [node for node in self._children.values()]\",\n \"def childWells(self):\\n if self.childWellIndices() is None:\\n return []\\n tcs=[]\\n for idx in self.childWellIndices():\\n tcs.append(self.clsParent.clsWells[idx])\\n\\n return tcs\",\n \"def children(self):\\n \\n return self._children\",\n \"def get_children(self):\\n offset = self.offset_pad(self._determine_key(True))\\n if self.ValueLength > 0:\\n # Nasty hardcoding unicode (length*2) length in here, \\n # but what else can we do?\\n return self.obj_vm.read(offset, self.ValueLength * 2)\\n else:\\n return self._recurse_children(offset)\",\n \"def get_children(self):\\n children = []\\n for node in self.node.get_children():\\n children.append(Geom(node))\\n return children\",\n \"def children_list(self):\\n return [\\n # self.notify,\\n # self.snap_multiplier,\\n # self.range_low, self.range_high,\\n # self.activity_threshold\\n ]\",\n \"def children(self):\\n return {x[1] for x in self.outgoing}\",\n \"def get_children(self):\\n std = self._std\\n bld = self._bld\\n cls = self.__class__\\n\\n root = self.get_sobj()\\n cit = std.NewChildIterator(root)\\n cit.InitEx(0)\\n\\n children = []\\n while cit.More():\\n node = cls(std, bld, cit.Value().GetID(), self)\\n if node.is_alive():\\n children.append(node)\\n cit.Next()\\n return children\",\n \"def children(phi):\\n ret = []\\n if hasattr(phi, 'x'):\\n ret.append(phi.x)\\n if hasattr(phi, 'y'):\\n assert isinstance(phi, amnet.Mu) or \\\\\\n isinstance(phi, amnet.Stack)\\n ret.append(phi.y)\\n if hasattr(phi, 'z'):\\n assert isinstance(phi, amnet.Mu)\\n ret.append(phi.z)\\n\\n assert len(ret) <= 3\\n return ret\",\n \"def positions(self):\\n def expand(p):\\n yield p\\n for ch in self.children(p):\\n for _c in expand(ch):\\n yield _c\\n return expand(self.root())\",\n \"def GetChildren(self):\\r\\n\\r\\n return self._children\",\n \"def children(self):\\n return list(self._children)\",\n \"def children(self, i):\\n if i < 0:\\n raise IndexError()\\n return self._children[i]\",\n \"def get_children(self):\\r\\n\\r\\n # FIXME: Expose iteration from CIndex, PR6125.\\r\\n def visitor(child, parent, children):\\r\\n # FIXME: Document this assertion in API.\\r\\n # FIXME: There should just be an isNull method.\\r\\n assert child != conf.lib.clang_getNullCursor()\\r\\n\\r\\n # Create reference to TU so it isn't GC'd before Cursor.\\r\\n child._tu = self._tu\\r\\n children.append(child)\\r\\n return 1 # continue\\r\\n children = []\\r\\n conf.lib.clang_visitChildren(self, callbacks['cursor_visit'](visitor),\\r\\n children)\\r\\n return iter(children)\",\n \"def getChildren(self):\\n \\n return self._children\",\n \"def children(v=()):\\n assert all([isinstance(w, Widget) for w in v])\\n return tuple(v)\",\n \"def _get_children(self) -> Sequence[\\\"HallwayState\\\"]:\\n if self.cur_pos < self.end_pos:\\n if self.cur_pos > 0: # Stop the hallway from going negative\\n yield self.new(self.cur_pos - 1)\\n yield self.new(self.cur_pos + 1)\",\n \"def _get_children(self):\\n return set()\",\n \"def get_cells(self):\\n return [\\n cell for column in self.children for cell in column.get_cells()]\",\n \"def get_child_descriptors(self):\\r\\n return self.descriptor.get_children()\",\n \"def getBufferChildren(self, buffertop):\\n children = [v for k, v in self.GS_arcs if k == buffertop]\\n return children\",\n \"def fm_all_children(self):\\n return self._relation_lst[self.CHILD].copy()\",\n \"def get_children(self, child_range=None):\\n child_c, child_r = self.collection.get_child()\\n child_c = [\\\"{}\\\".format(c) for c in child_c]\\n res = child_c + child_r\\n if child_range:\\n start, stop = (int(el) for el in child_range.split(\\\"-\\\", 1))\\n # map CDMI range value to python index\\n stop += 1\\n else:\\n start = 0\\n stop = len(res)\\n return res[start:stop]\",\n \"def get_children(self):\\n return NodeList(self._my_map['childNodes'])\",\n \"def children(self, pos):\\n return range(self.dary * pos + 1, min(self.dary * (pos + 1) + 1, len(self.heap)))\",\n \"def _naive_layout(self) -> List[Tuple[int, int]]:\\n positions = []\\n width = self.parent_component.width\\n height = self.parent_component.height\\n padding = self.parent_component.padding\\n for child in self.parent_component.children:\\n cwidth, cheight = child.width, child.height\\n props = child.props\\n top = 0\\n left = 0\\n # handle horizontal and vertical alignments\\n if props.h_alignment is HAlignment.LEFT:\\n left = child.margin[0] + padding[0]\\n elif props.h_alignment is HAlignment.CENTER:\\n left = width / 2 - cwidth / 2\\n elif props.h_alignment is HAlignment.RIGHT:\\n left = width - (child.margin[1] + cwidth + padding[1])\\n \\n if props.v_alignment is VAlignment.TOP:\\n top = child.margin[2] + padding[2]\\n elif props.v_alignment is VAlignment.CENTER:\\n top = height / 2 - cheight / 2\\n elif props.v_alignment is VAlignment.BOTTOM:\\n top = height - (child.margin[3] + cheight + padding[3])\\n \\n offset = child.offset\\n positions.append((left + offset[0], top + offset[1]))\\n return positions\",\n \"def getChilds(self, index):\\n return index, (2 * index) + 1, (2 * index) + 2\",\n \"def get_children(self):\\n children = []\\n for i in self.children_ids:\\n child = Comment(self.articleID, self.children_ids[i])\\n children.append(child)\\n children.extend(child.get_children())\\n return children\",\n \"def _all_subnodes(self):\\n return self.__dict__.values()\",\n \"def firsts(self):\\r\\n return self._children_of[None]\",\n \"def children(self) -> Tuple[CombinatorialClassType, ...]:\\n if self._children is None:\\n self._children = self._strategy.decomposition_function(self.comb_class)\\n if self._children is None:\\n raise StrategyDoesNotApply(\\\"{} does not apply\\\".format(self._strategy))\\n return self._children\",\n \"def get_child_descriptors(self):\\r\\n if self.child_descriptor is None:\\r\\n return []\\r\\n\\r\\n return [self.child_descriptor]\",\n \"def _get_children_ixs(self, parent_ix):\\n ix_left = (parent_ix * 2) + 1\\n ix_right = ix_left + 1\\n if ix_left >= len(self):\\n ix_left = None\\n if ix_right >= len(self):\\n ix_right = None\\n return ix_left, ix_right\",\n \"def children(self):\\n try:\\n attr_name = 'Parrot_%s_attributes' % self.pmc_name\\n attr_type = gdb.lookup_type(attr_name).pointer()\\n\\n attrs = self.val['data'].cast(attr_type).dereference()\\n\\n '''\\n Something ridiculous happens here. I take a list of tuples:\\n [ (\\\"key1\\\", \\\"val1\\\"), (\\\"key2\\\", \\\"val2\\\") ]\\n\\n and turn it, in one iteration, into:\\n [\\n [(\\\"name\\\", \\\"key1\\\"), (\\\"value\\\", \\\"val1\\\")],\\n [(\\\"name\\\", \\\"key2\\\"), (\\\"value\\\", \\\"val2\\\")]\\n ]\\n\\n That, in turn, is mutated into one list.\\n [\\n (\\\"name\\\", \\\"key1\\\"), (\\\"value\\\", \\\"val1\\\"),\\n (\\\"name\\\", \\\"key2\\\"), (\\\"value\\\", \\\"val2\\\")\\n ]\\n\\n What we go through for 100% lazy iteration.\\n '''\\n name_value_tuples = PMCIterator(attrs)\\n nv_iter = itertools.imap(lambda val: [ (\\\"name\\\", val[0]), (\\\"value\\\", val[1]) ],\\n name_value_tuples)\\n nv_chain = itertools.chain.from_iterable(nv_iter)\\n\\n return nv_chain\\n except RuntimeError as e:\\n return [ ( \\\"__ERROR__\\\", \\\"\\\" ) ].__iter__()\",\n \"def get_child_nodes(node):\\r\\n return list(iter_child_nodes(node))\",\n \"def getChildren(self):\\n if not self.Children:\\n\\n #print 'reached leave node {0}'.format(self.CommID)\\n #raw_input()\\n return [[], []]\\n\\n children = deque()\\n parent = deque()\\n for c in range(len(self.Children)):\\n children.append(self.Children[c])\\n parent.append(self.CommID)\\n retval = (children, parent)\\n\\n #print 'retval of ID {0} is {1}'.format(self.CommID, retval)\\n #raw_input('wait')\\n\\n return retval\",\n \"def getChildren(self):\\n if not self.Children:\\n\\n #print 'reached leave node {0}'.format(self.CommID)\\n #raw_input()\\n return [[], []]\\n\\n children = deque()\\n parent = deque()\\n for c in range(len(self.Children)):\\n children.append(self.Children[c])\\n parent.append(self.CommID)\\n retval = (children, parent)\\n\\n #print 'retval of ID {0} is {1}'.format(self.CommID, retval)\\n #raw_input('wait')\\n\\n return retval\",\n \"def get_children(self, parent):\\n all_nodes = self.get_nodes()\\n parent_index = all_nodes.index(parent)\\n parent_family = self.__nodes[parent_index]\\n children = parent_family[1:len(parent_family)]\\n \\n return [self.__nodes[child_index][0] for child_index in children]\",\n \"def children(self):\\n if self._children is None:\\n return set()\\n else:\\n return self._children\",\n \"def Children( cls, pid ):\\n\\t\\tres = []\\n\\t\\tpid = int(pid)\\n\\t\\tfor cpid, cmd in cls.List().items():\\n\\t\\t\\tppid = int(cls.Status(cpid)[\\\"ppid\\\"])\\n\\t\\t\\tif ppid == pid:\\n\\t\\t\\t\\tres.append( (cpid, None, cmd))\\n\\t\\treturn res\",\n \"def getSiblings():\",\n \"def _get_children(self, x):\\n try:\\n return x._pfp__children\\n\\n except AttributeError:\\n return []\",\n \"def children(self, n):\\n if self.left(n):\\n yield self.left(n)\\n if self.right(n):\\n yield self.right(n)\",\n \"def get_children(self):\\n\\n return self._children.copy()\",\n \"def info(self):\\n return nx.info(self.tree)\\n\\n\\n # def children(self):\\n \\\"\\\"\\\" Return the children of the current node.\\n\\n \\\"\\\"\\\"\\n # return self.left, self.right\",\n \"def generate_child_positions(self) -> List[Tuple[int, int]]:\\n layout = self.parent_component.props.layout\\n if layout == UILayoutType.LIST:\\n return self._list_layout()\\n elif layout == UILayoutType.GRID:\\n pass\\n elif layout == UILayoutType.MANUAL_GRID:\\n pass\\n else: # assume UILayoutType.NONE\\n return self._naive_layout()\",\n \"def descendants(self):\\n for a in self._related(set(), 'children'):\\n yield a\",\n \"def get_children(self, parent):\\n\\n child_names = []\\n for child in parent.children:\\n child_names.append(child.label)\\n return child_names\",\n \"def get_children(self):\\n children = []\\n side_size = int(math.sqrt(len(self._state)))\\n pos = self._state.index(0)\\n row = pos // side_size\\n col = pos % side_size\\n moves = get_moves(side_size, col, row)\\n for direction in moves:\\n if moves[direction]['is_movable']:\\n new_state = move(self._state, pos, moves[direction]['rel_pos'])\\n children.append(Node(new_state, heuristic=self._heuristic,\\n g_score=self._g_score+self._cost(self._state, new_state)))\\n\\n return children\",\n \"def get_children(self):\\n if not self.FileInfo:\\n raise StopIteration(\\\"No children\\\")\\n offset = self.offset_pad(self.FileInfo.obj_offset + self.ValueLength)\\n return self._recurse_children(offset)\",\n \"def units(self):\\n return self.children()\",\n \"def child_views(self):\\n return self.children\",\n \"def GetChildren(self, *args, **kwargs):\\n pass\",\n \"def children(self, p):\\n if self.left(p) is not None:\\n yield self.left(p)\\n if self.right(p) is not None:\\n yield self.right(p)\",\n \"def children(self, p):\\n if self.left(p) is not None:\\n yield self.left(p)\\n if self.right(p) is not None:\\n yield self.right(p)\",\n \"def children(self, p):\\n if self.left(p) is not None:\\n yield self.left(p)\\n if self.right(p) is not None:\\n yield self.right(p)\",\n \"def children(self, p):\\n if self.left(p) is not None:\\n yield self.left(p)\\n\\n if self.right(p) is not None:\\n yield self.right(p)\",\n \"def children(self) -> List[Region]:\\n return []\",\n \"def pieces(self):\\n return (self.leaf_nodes.order_by('piece')\\n .values_list('piece', flat=True))\",\n \"def children(self):\\n l = []\\n n = self.node.firstChild\\n while n:\\n l.append(XmlWrapper(n))\\n n = n.nextSibling\\n return l\",\n \"def children(self):\\n l = []\\n n = self.node.firstChild\\n while n:\\n l.append(XmlWrapper(n))\\n n = n.nextSibling\\n return l\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6792127","0.673864","0.6668528","0.66547626","0.66468894","0.6605106","0.6564175","0.6527869","0.6469268","0.6447035","0.6377662","0.6343646","0.6330529","0.6330529","0.6330529","0.62940097","0.62744546","0.6263438","0.6258187","0.62352306","0.62139827","0.62090605","0.61994195","0.61869246","0.6180354","0.61672926","0.6160346","0.61562407","0.61496854","0.6148137","0.6148137","0.61392087","0.61392087","0.6138377","0.6134368","0.61279714","0.61225253","0.61100644","0.61083394","0.6100154","0.60808337","0.60619277","0.60406566","0.6035799","0.5999933","0.59640944","0.5944412","0.5914219","0.5902336","0.5901584","0.5885088","0.58741945","0.5873998","0.584944","0.58382547","0.57936716","0.579312","0.5788191","0.57725245","0.57675374","0.57572526","0.57391846","0.57380694","0.57278174","0.57215285","0.57186776","0.5717563","0.57141536","0.57085764","0.5692156","0.56872237","0.56843644","0.5683599","0.5676423","0.5675225","0.5675225","0.56565505","0.56442523","0.562791","0.56166536","0.5607002","0.560477","0.56027466","0.5600961","0.56003135","0.5590777","0.5584313","0.5582913","0.5576555","0.55762035","0.5571398","0.5571119","0.5570621","0.5570621","0.5570621","0.5564679","0.55615747","0.55436677","0.55433196","0.55433196"],"string":"[\n \"0.6792127\",\n \"0.673864\",\n \"0.6668528\",\n \"0.66547626\",\n \"0.66468894\",\n \"0.6605106\",\n \"0.6564175\",\n \"0.6527869\",\n \"0.6469268\",\n \"0.6447035\",\n \"0.6377662\",\n \"0.6343646\",\n \"0.6330529\",\n \"0.6330529\",\n \"0.6330529\",\n \"0.62940097\",\n \"0.62744546\",\n \"0.6263438\",\n \"0.6258187\",\n \"0.62352306\",\n \"0.62139827\",\n \"0.62090605\",\n \"0.61994195\",\n \"0.61869246\",\n \"0.6180354\",\n \"0.61672926\",\n \"0.6160346\",\n \"0.61562407\",\n \"0.61496854\",\n \"0.6148137\",\n \"0.6148137\",\n \"0.61392087\",\n \"0.61392087\",\n \"0.6138377\",\n \"0.6134368\",\n \"0.61279714\",\n \"0.61225253\",\n \"0.61100644\",\n \"0.61083394\",\n \"0.6100154\",\n \"0.60808337\",\n \"0.60619277\",\n \"0.60406566\",\n \"0.6035799\",\n \"0.5999933\",\n \"0.59640944\",\n \"0.5944412\",\n \"0.5914219\",\n \"0.5902336\",\n \"0.5901584\",\n \"0.5885088\",\n \"0.58741945\",\n \"0.5873998\",\n \"0.584944\",\n \"0.58382547\",\n \"0.57936716\",\n \"0.579312\",\n \"0.5788191\",\n \"0.57725245\",\n \"0.57675374\",\n \"0.57572526\",\n \"0.57391846\",\n \"0.57380694\",\n \"0.57278174\",\n \"0.57215285\",\n \"0.57186776\",\n \"0.5717563\",\n \"0.57141536\",\n \"0.57085764\",\n \"0.5692156\",\n \"0.56872237\",\n \"0.56843644\",\n \"0.5683599\",\n \"0.5676423\",\n \"0.5675225\",\n \"0.5675225\",\n \"0.56565505\",\n \"0.56442523\",\n \"0.562791\",\n \"0.56166536\",\n \"0.5607002\",\n \"0.560477\",\n \"0.56027466\",\n \"0.5600961\",\n \"0.56003135\",\n \"0.5590777\",\n \"0.5584313\",\n \"0.5582913\",\n \"0.5576555\",\n \"0.55762035\",\n \"0.5571398\",\n \"0.5571119\",\n \"0.5570621\",\n \"0.5570621\",\n \"0.5570621\",\n \"0.5564679\",\n \"0.55615747\",\n \"0.55436677\",\n \"0.55433196\",\n \"0.55433196\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6630454"},"document_rank":{"kind":"string","value":"5"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":790,"numItemsPerPage":100,"numTotalItems":95772,"offset":79000,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjQ5NjEzMiwianRpIjoiOWJiYTZmNDEtZGU1MS00OWI5LThkYzctMWVkMDk5OTFiZjQzIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODY0OTk3MzIsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.85Xa1Lho0TO_mhCQNUtRSHaNqe1r7K-VafJptvJNP5uSC1EhIN0iRn0z5CxBtuEswikKSNTbq-MpfhTTgfpvAQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Renders the about page. | def data():
return render_template(
'data.html',
title='Data',
year=datetime.now().year,
img_tichonet = '/static/pics/tichonet.png',
message='Your application description page.'
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def about():\n return render_template('about.html', title='About')",
"def about():\n\n return render_template('about_page.html', title='About')",
"def about():\n\n\treturn render_template(\"about.html\")",
"def on_about(self):\n render_about_window()",
"def about():\n return render_temp... | [
"0.85650355",
"0.85034525",
"0.84489655",
"0.84044397",
"0.8394454",
"0.82935613",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82680845",... | 0.0 | -1 |
Renders the about page. | def nba():
form1 = ExpandForm()
form2 = CollapseForm()
df = pd.read_csv(path.join(path.dirname(__file__), 'static/Data/injuries_2010-2020.csv'))
raw_data_table = ''
if request.method == 'POST':
if request.form['action'] == 'Expand' and form1.validate_on_submit():
raw_data_table ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def about():\n return render_template('about.html', title='About')",
"def about():\n\n return render_template('about_page.html', title='About')",
"def about():\n\n\treturn render_template(\"about.html\")",
"def on_about(self):\n render_about_window()",
"def about():\n return render_temp... | [
"0.85650355",
"0.85034525",
"0.84489655",
"0.84044397",
"0.8394454",
"0.82935613",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82680845",... | 0.0 | -1 |
Renders the about page. | def Gallery():
return render_template(
'Gallery.html',
title='The to 8 NBA players right now',
year=datetime.now().year,
message=''
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def about():\n return render_template('about.html', title='About')",
"def about():\n\n return render_template('about_page.html', title='About')",
"def about():\n\n\treturn render_template(\"about.html\")",
"def on_about(self):\n render_about_window()",
"def about():\n return render_temp... | [
"0.85650355",
"0.85034525",
"0.84489655",
"0.84044397",
"0.8394454",
"0.82935613",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82709616",
"0.82680845",... | 0.0 | -1 |
Prints the confusion matrix and precision, accuracy, recall and ROC AUC. | def print_logistic_results(
X_test,
y_test,
logistic_model,
predictions_logistic_model,
solver,
confusion_matrix=False,
):
print(solver)
print("-----------------")
if confusion_matrix:
disp = plot_confusion_matrix(
logistic_model,
X_test,
y... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_score(classifier,X_test,y_test):\n print(\"Test results:\\n\")\n print('Accuracy Score: {0:.4f}\\n'.format(accuracy_score(y_test,classifier.predict(X_test))))\n print('Classification Report:\\n{}\\n'.format(classification_report(y_test,classifier.predict(X_test))))\n print('Confusion Matrix:\... | [
"0.7529526",
"0.750704",
"0.7487848",
"0.7295018",
"0.72805387",
"0.71712613",
"0.7148443",
"0.70700246",
"0.70566607",
"0.69996154",
"0.697553",
"0.6913525",
"0.6849898",
"0.66885924",
"0.666082",
"0.66598463",
"0.6652944",
"0.66395116",
"0.6633511",
"0.662369",
"0.66195637"... | 0.5877733 | 81 |
Compose a label for i'th word of a tree, according to 'fields'. Return a string (possibly multiline). | def _label(tree, node, fields):
# Form (always).
label = tree.forms(node)
# Lemma.
if 'lemma' in fields:
label += u'\n' + tree.lemmas(node)
# Postags.
postags = []
if 'cpostag' in fields:
postags.append(tree.cpostags(node))
if 'postag' in fields:
postags.append(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_label_text(field_name: str, field: dict):\n\n label = \"\"\n if \"required\" in field:\n label = \" * \" if field.get(\"required\") else \"\"\n\n # If we don't have a label defined, used the field name\n if \"label\" not in field:\n field.update({\"label\... | [
"0.65825105",
"0.6076069",
"0.59696615",
"0.5935693",
"0.5935261",
"0.58478886",
"0.58437353",
"0.5761943",
"0.564017",
"0.5549377",
"0.5525734",
"0.5482963",
"0.54392093",
"0.5434365",
"0.5414149",
"0.5410233",
"0.53963095",
"0.5393825",
"0.53839684",
"0.53701466",
"0.534880... | 0.72464603 | 0 |
Return label text height. First line is in big font, other lines are in small font. | def _label_height(text):
return _BIG_FONT + _SMALL_LINE * text.count(u'\n') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetLabelSize(dc, label, vertical):\r\n\r\n text_width = text_height = 0\r\n\r\n # get the text height\r\n dummy, text_height = dc.GetTextExtent(\"ABCDHgj\")\r\n # get the text width\r\n if label.strip():\r\n text_width, dummy = dc.GetTextExtent(label)\r\n\r\n if vertical:\r\n tm... | [
"0.7271216",
"0.71656597",
"0.6950726",
"0.69150996",
"0.68502",
"0.68196136",
"0.67779195",
"0.6538287",
"0.64716256",
"0.6353686",
"0.62325746",
"0.6218229",
"0.6213206",
"0.60821",
"0.59820193",
"0.59775317",
"0.5935517",
"0.5899317",
"0.58370006",
"0.5835381",
"0.58216095... | 0.8867154 | 0 |
Return label text width. Width of a single glyph is considered to be equal to font size. First line is in big font, other lines are in small font. | def _label_width(text):
width = 0
for lineno, line in enumerate(text.split(u'\n')):
size = [_BIG_FONT, _SMALL_FONT][lineno > 0] # Cool idiom, huh?
width = max(width, size * len(line))
return width | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def label_width(self):\n return self._label_width",
"def label_width(self, start, end, numlabels=None, char_width=None):\n return self.formatter.estimate_width(start, end, numlabels, char_width,\n ticker=self)",
"def width(self, text):\n return l... | [
"0.77487105",
"0.75036937",
"0.70768744",
"0.7019592",
"0.7008805",
"0.69664294",
"0.68807596",
"0.679242",
"0.6748034",
"0.67123944",
"0.66297275",
"0.65036947",
"0.6460371",
"0.640202",
"0.6389833",
"0.6327039",
"0.6237472",
"0.6214645",
"0.6123736",
"0.61015725",
"0.604933... | 0.82819164 | 0 |
Return radius of a circular segment of an arc of a given height level. | def _arc_radius(height_in_units):
return height_in_units * _ARC_HEIGHT_UNIT / (1 - math.cos(_ANGLE)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def circleCirc(radius):\n radius = float(radius)\n return 2*math.pi*radius",
"def get_radius(self):\n if self.no_dist is False:\n dist = self.distance\n radius = (dist * self.ang_size / 60. *\n np.pi/180. * ct._kpc_over_pc_)/2.\n self.radius = ra... | [
"0.7022965",
"0.694876",
"0.6926556",
"0.69203454",
"0.68934387",
"0.68595546",
"0.6837693",
"0.68078643",
"0.6790736",
"0.6790736",
"0.67545676",
"0.67370695",
"0.6680574",
"0.6631358",
"0.6623361",
"0.6594229",
"0.65553945",
"0.65350884",
"0.64718235",
"0.64544165",
"0.6400... | 0.81892455 | 0 |
Return minimal horizontal size for an arc of a given "flight level". | def _arc_min_length(height_in_units):
return 2 * _arc_radius(height_in_units) * math.sin(_ANGLE) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def minimum_size(self):\n # Size in arcsec\n size = self.seeing.minimum_size()\n try:\n # Try using `intrinsic` as an object\n size = max(self.intrinsic.minimum_size(), size)\n except AttributeError:\n pass\n return size",
"def calculate_previou... | [
"0.5729011",
"0.5543878",
"0.55003494",
"0.54918885",
"0.5427095",
"0.54054224",
"0.53995574",
"0.5392929",
"0.53288615",
"0.5295742",
"0.528502",
"0.52563035",
"0.52264947",
"0.5151043",
"0.51448995",
"0.5134441",
"0.5106881",
"0.50455415",
"0.49992964",
"0.49982598",
"0.498... | 0.66271394 | 0 |
Draw a multiline label at given position. Enclose elements in a . | def _draw_label(file, text, x, y, css_class):
width = _label_width(text)
height = _label_height(text)
# Start a group.
file.write(u' <g class="%s">\n' % css_class)
# Invisible hover-rectangle.
# Makes it easier to hover over the label.
file.write(u' <rect x="%i" y="%i" width="%... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def put_label(i):\n i = min(i, len(x)-2)\n dx = sx[i+1] - sx[i]\n dy = sy[i+1] - sy[i]\n rotation = np.rad2deg(math.atan2(dy, dx)) + rotation_offset\n pos = [(x[i] + x[i+1])/2. + offset[0], (y[i] + y[i+1])/2 + offset[1]]\n plt.text(pos[0], pos[1], label_text, size=9, rotat... | [
"0.7264121",
"0.72207683",
"0.71647966",
"0.70395815",
"0.7019444",
"0.6994132",
"0.6829644",
"0.66767454",
"0.6491546",
"0.6471871",
"0.646692",
"0.6456439",
"0.6452432",
"0.6445409",
"0.64314634",
"0.639197",
"0.63918877",
"0.638899",
"0.6381818",
"0.6336534",
"0.6320836",
... | 0.65577906 | 8 |
Draw a vertical "arc from the root" to the node at (x, y). Enclose elements in a . | def _draw_root_arc(file, x, y, height_in_units, deprel, css_class):
height = height_in_units * _ARC_HEIGHT_UNIT
# Start.
file.write(u' <g class="%s">\n' % css_class)
# Path.
path = 'M %i %i L %i %i' % (x, y, x, y - height)
file.write(u' <path d="%s" class="arc" />\n' % path)
fi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _draw_arc(file, start_x, end_x, y, height_in_units, deprel, css_class):\n height = height_in_units * _ARC_HEIGHT_UNIT\n radius = _arc_radius(height_in_units)\n length = _arc_min_length(height_in_units)\n\n # Start.\n file.write(u' <g class=\"%s\">\\n' % css_class)\n\n # Path.\n path =... | [
"0.64772046",
"0.64068234",
"0.62226677",
"0.61593276",
"0.6059894",
"0.58969045",
"0.58713514",
"0.586212",
"0.5840232",
"0.5805969",
"0.57956517",
"0.56697184",
"0.5667503",
"0.5664292",
"0.56430775",
"0.5603307",
"0.5598331",
"0.55746675",
"0.55711836",
"0.55608064",
"0.55... | 0.7157346 | 0 |
Draw an arc from the node at (start_x, y) to the node at (end_x, y). Enclose elements in a . | def _draw_arc(file, start_x, end_x, y, height_in_units, deprel, css_class):
height = height_in_units * _ARC_HEIGHT_UNIT
radius = _arc_radius(height_in_units)
length = _arc_min_length(height_in_units)
# Start.
file.write(u' <g class="%s">\n' % css_class)
# Path.
path = (
'M %.2... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def arc_n(self, xn ,yn, rn, start, stop):\n x = round(xn * self.width)\n y = round(yn * self.height)\n r = round(rn * min(self.width, self.height))\n self.arc(x, y, r, start, stop)",
"def draw_arc(ax, center, height, width, theta1=0, theta2=numpy.pi, color='k', direction='down',\n ... | [
"0.70424855",
"0.69551045",
"0.6952669",
"0.688913",
"0.6807394",
"0.66460675",
"0.6618592",
"0.6547217",
"0.65388316",
"0.6534261",
"0.6514192",
"0.6471966",
"0.64710987",
"0.6460161",
"0.6459329",
"0.6446214",
"0.64154017",
"0.6335754",
"0.63317806",
"0.625453",
"0.6236552"... | 0.7387968 | 0 |
Draw an arrow with a tip at (tip_x, tip_y), "attacking" the surface at a given angle. | def _draw_arrow(file, tip_x, tip_y, angle):
# Offset the tip.
tip_x -= _ARROW_SIZE * 0.2 * math.cos(angle)
tip_y += _ARROW_SIZE * 0.2 * math.sin(angle)
# Draw the arrow.
path = (
'M %.2f %.2f'
'L %.2f %.2f'
'L %.2f %.2f'
'L %.2f %.2f'
'Z'
) % (
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_arrow(dc, fr, to, tail_angle, tail_length):\r\n end_x, end_y = to[0], to[1]\r\n vec = -(to - fr)\r\n vec = vec.normalized()\r\n tail_1 = vec.rotated(tail_angle) * tail_length\r\n tail_2 = vec.rotated(-tail_angle) * tail_length\r\n dc.DrawLine(end_x, end_y, end_x+tail_1[0], end_y+tail_1[1... | [
"0.6208793",
"0.60975254",
"0.60448563",
"0.60122025",
"0.5948734",
"0.5920215",
"0.5909208",
"0.5828393",
"0.57645756",
"0.5744468",
"0.5715196",
"0.5706364",
"0.56345356",
"0.56342465",
"0.5627154",
"0.5548939",
"0.54402685",
"0.5438652",
"0.53856605",
"0.5363015",
"0.53515... | 0.7083311 | 0 |
Object representation into json Returns; | def __repr__(self):
return json.dumps(self.__dict__) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def as_json(self):",
"def json_friendly(self):",
"def to_json(self):\n pass",
"def serialize(self, obj):\n return json.dumps(obj)",
"def json(self):\n class ExtendedJSONEncoder(json.JSONEncoder):\n def default(self, obj):\n if isinstance(obj, datetime.date) or... | [
"0.799896",
"0.7658569",
"0.7402277",
"0.73150796",
"0.7264073",
"0.7256318",
"0.7240075",
"0.71770257",
"0.7169451",
"0.7150388",
"0.71494526",
"0.7145647",
"0.7123351",
"0.7119767",
"0.70871913",
"0.7080076",
"0.70696765",
"0.70595527",
"0.705732",
"0.7001852",
"0.6998944",... | 0.0 | -1 |
Run task on specified `builder`. | def run(self, builder, retry):
time_start = time.time()
self.date_start = utils.strdate()
if self.require:
raise TaskDependenciesError("Task {} can't run. Requires {}"\
.format(self.tid, ', '.join(self.require)))
try:
self.results = getattr(builde... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self, builder):\n\n # Change to the test directory\n os.chdir(builder.stage_dir)\n self.logger.debug(f\"Changing to directory {builder.stage_dir}\")\n\n run_cmd = self.cmd + [os.path.basename(builder.build_script)]\n run_cmd = \" \".join(run_cmd)\n\n # ---------- S... | [
"0.59340215",
"0.59032077",
"0.5841938",
"0.58288544",
"0.57701546",
"0.56623113",
"0.54032415",
"0.5359394",
"0.5356444",
"0.53439844",
"0.5296021",
"0.528549",
"0.52820635",
"0.5263518",
"0.52304286",
"0.5229381",
"0.5182776",
"0.5178227",
"0.5171122",
"0.5161379",
"0.51545... | 0.6643704 | 0 |
Is the task runnable | def is_runnable(self):
return self.state == self.STATE_INIT and not self.require | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_runnable(self):\n \n if len(target_tasks) < 1: \n return False\n # check task names?\n \n if self.run_folder is None or \\\n not os.path.exists(self.run_folder) or \\\n not os.path.exists(os.path.join(self.run_folder, self.run_id, 'SampleSh... | [
"0.73557484",
"0.71910566",
"0.71346843",
"0.6990803",
"0.6896121",
"0.6896121",
"0.6868695",
"0.67810875",
"0.6776982",
"0.66866755",
"0.6680824",
"0.665087",
"0.66431415",
"0.66022867",
"0.6563005",
"0.6540378",
"0.65363276",
"0.6515555",
"0.6485275",
"0.6474582",
"0.645360... | 0.7445494 | 0 |
Check if a task is finnished | def is_finished(self):
return self.state != self.STATE_INIT and self.state != self.STATE_READY | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_task_stagnant(task):",
"def task_succeed(json_raw):\n rally_report = json.loads(json_raw)\n tasks = rally_report.get('tasks')\n if tasks:\n for task in tasks:\n if task.get('status') != 'finished' or \\\n task.get('pass_sla') is not True:\n ... | [
"0.72337425",
"0.6817414",
"0.66699123",
"0.66345733",
"0.6586728",
"0.65562165",
"0.6518176",
"0.6507567",
"0.6454811",
"0.6445249",
"0.6433979",
"0.64289474",
"0.6370663",
"0.6345039",
"0.6315901",
"0.6314589",
"0.63130414",
"0.62983197",
"0.628415",
"0.6283269",
"0.6277551... | 0.0 | -1 |
Update task childs When a task state changes, update childs. If the task success, remove dependencies on childs otherwise mark childs states with STATE_DEPENDENCY | def update_childs(self, _tasks):
tasks = copy.deepcopy(_tasks)
for child in tasks.keys():
# only process init state tasks
if tasks[child].state != self.STATE_INIT:
continue
# if erased and none
if not tasks[child].require:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, request, pk=None):\n child_task = self.get_object()\n serializer = ChildTaskSerializer(data=request.data)\n parent_task_id = serializer.data['parent_task_id']\n if serializer.is_valid():\n # Request passed validation.\n response = super(ChildTaskVi... | [
"0.66115755",
"0.61238635",
"0.59749055",
"0.587335",
"0.57489765",
"0.5735887",
"0.57200396",
"0.5662248",
"0.56386054",
"0.56310064",
"0.56048024",
"0.5558004",
"0.5553909",
"0.5491969",
"0.54777765",
"0.5447478",
"0.5438334",
"0.5404273",
"0.5398509",
"0.5397731",
"0.53831... | 0.75299466 | 0 |
Helper function for querying newest predictors | def get_predictors(newest=True, **kwargs):
if newest:
predictor_ids = db.session.query(
func.max(Predictor.id)).group_by(Predictor.name)
else:
predictor_ids = db.session.query(Predictor.id)
if 'run_id' in kwargs:
# This following JOIN can be slow
predictor_ids = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def status_quo_model(X):\n\n def mostrecent(x):\n x = x[x.notnull()]\n if len(x) > 0:\n return x.iloc[-1]\n else:\n return 0\n preds = X.apply(mostrecent, axis=1)\n\n return preds",
"def get_latest_model():\n return get_models()[-1]",
"def fetch_latest_rou... | [
"0.6160301",
"0.57882196",
"0.5635682",
"0.54638565",
"0.54508704",
"0.5402498",
"0.53701395",
"0.5270943",
"0.5247883",
"0.5204437",
"0.51682633",
"0.5162629",
"0.5126087",
"0.50463015",
"0.5031413",
"0.5011624",
"0.5008288",
"0.50078815",
"0.49992976",
"0.4983294",
"0.49757... | 0.6798848 | 0 |
Check some conventions for class declaration and add it to MATRIX_TYPES. | def register_mat_type(cls):
base = "Prox"
assert issubclass(cls, ProxBase), "Must be a subclass of ProxBase."
assert cls.__name__.startswith(base), "Make sure to start your class name with %s." % (base, )
MATRIX_TYPES[cls.__name__[len(base):]] = cls
return cls | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_check_types():",
"def create_data_types(self):\n for col in self.all_columns:\n try:\n if float(self.train[col].iloc[-3]):\n self.train[col] = self.train[col].astype(np.float32)\n except:\n pass\n self.d_types = self.tra... | [
"0.55636877",
"0.55425423",
"0.54069316",
"0.53332627",
"0.5255422",
"0.5248838",
"0.52114916",
"0.5197763",
"0.51575273",
"0.51413214",
"0.51304966",
"0.5114597",
"0.5092314",
"0.5090019",
"0.507949",
"0.5064494",
"0.5049244",
"0.5039898",
"0.5020227",
"0.50085855",
"0.50085... | 0.55065656 | 2 |
Convert adjacency matrix to format suitable for Cooccurrences model. | def _adj_to_feat(self, role2ind: Dict[int, int], token2ind: Dict[int, int], mat) -> Tuple:
roles = sorted(role2ind, key=role2ind.get)
roles = ["RoleId_%d" % role for role in roles]
tokens = sorted(token2ind, key=token2ind.get)
return roles + tokens, mat | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def formAdjacencyMatrix(self):\n self.adjacencyMatrix = dict()\n for i in self.node:\n self.adjacencyMatrix[i] = dict()\n for j in self.node:\n self.adjacencyMatrix[i][j] = 0\n \n for ij in self.link:\n self.adjacencyMatrix[self.link[ij].tail][self.link[ij]... | [
"0.6812465",
"0.67126846",
"0.65021217",
"0.6407358",
"0.63938165",
"0.6392823",
"0.6228346",
"0.613841",
"0.61353105",
"0.61353105",
"0.61353105",
"0.61353105",
"0.61353105",
"0.6115678",
"0.6061505",
"0.60569936",
"0.6053248",
"0.6036972",
"0.6013883",
"0.6004805",
"0.60019... | 0.0 | -1 |
Decorator for multiple trial of the test case. The decorated test case is launched multiple times. The case is judged as passed at least specified number of trials. If the number of successful trials exceeds `min_success`, the remaining trials are skipped. | def repeat_with_success_at_least(times, min_success):
assert times >= min_success
def _repeat_with_success_at_least(f):
@functools.wraps(f)
def wrapper(*args, **kwargs):
assert len(args) > 0
instance = args[0]
assert isinstance(instance, unittest.TestCase)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test(numTrials):\n # Your Code Here\n hits = 0.0\n for i in range(numTrials):\n result = trial()\n #print result\n hits += result\n return hits / numTrials",
"def main(num_trials, num_actions):\n\tfor i in xrange(int(num_trials)):\n\t\ttrial(i+1, int(num_actions))",
"def th... | [
"0.61784405",
"0.61314857",
"0.596407",
"0.59254247",
"0.5910247",
"0.58234215",
"0.58015466",
"0.5779273",
"0.5725785",
"0.57112896",
"0.565361",
"0.55590385",
"0.5535777",
"0.5398447",
"0.53845537",
"0.5376214",
"0.5375111",
"0.5372522",
"0.5372075",
"0.53648865",
"0.536413... | 0.7441564 | 0 |
Decorator that imposes the test to be successful in a row. Decorated test case is launched multiple times. The case is regarded as passed only if it is successful specified times in a row. | def repeat(times, intensive_times=None):
if intensive_times is None:
return repeat_with_success_at_least(times, times)
casual_test = bool(int(os.environ.get('CUPY_TEST_CASUAL', '0')))
times_ = times if casual_test else intensive_times
return repeat_with_success_at_least(times_, times_) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def repeat_with_success_at_least(times, min_success):\n\n assert times >= min_success\n\n def _repeat_with_success_at_least(f):\n @functools.wraps(f)\n def wrapper(*args, **kwargs):\n assert len(args) > 0\n instance = args[0]\n assert isinstance(instance, unitte... | [
"0.72282165",
"0.5893259",
"0.5893259",
"0.58438414",
"0.5840127",
"0.5832044",
"0.5789604",
"0.570743",
"0.56748116",
"0.5672933",
"0.56607103",
"0.564322",
"0.56301177",
"0.5628773",
"0.5611231",
"0.56013286",
"0.5548431",
"0.5542579",
"0.5527588",
"0.5468622",
"0.54141116"... | 0.0 | -1 |
Decorator that imposes the test to be successful at least once. Decorated test case is launched multiple times. The case is regarded as passed if it is successful at least once. | def retry(times):
return repeat_with_success_at_least(times, 1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def repeat_with_success_at_least(times, min_success):\n\n assert times >= min_success\n\n def _repeat_with_success_at_least(f):\n @functools.wraps(f)\n def wrapper(*args, **kwargs):\n assert len(args) > 0\n instance = args[0]\n assert isinstance(instance, unitte... | [
"0.6898724",
"0.6600555",
"0.6360581",
"0.6360581",
"0.6300756",
"0.6187742",
"0.6149502",
"0.60974175",
"0.60415596",
"0.6039456",
"0.6007458",
"0.59917194",
"0.59881485",
"0.59328115",
"0.5917926",
"0.5913737",
"0.5906948",
"0.5901848",
"0.58891857",
"0.5841937",
"0.5839205... | 0.0 | -1 |
Check field to win | def check_win(game_field):
if (game_field[0] != ' ') and (game_field[0] == game_field[1] == game_field[2]):
return game_field[0]
elif (game_field[3] != ' ') and (game_field[3] == game_field[4] == game_field[5]):
return game_field[3]
elif (game_field[6] != ' ') and (game_field[6] == game_fiel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def WinCheck(field):\n for i in range(len(field)):\n if field[i] == 2048:\n return True\n return False",
"def hasWin(self) :\n comparison = self.compareNumberUser()\n if (comparison == 'equal') :\n return True\n else :\n return False",
"def _ch... | [
"0.6859255",
"0.64502525",
"0.64117455",
"0.6401923",
"0.6345855",
"0.62657017",
"0.62467015",
"0.62204844",
"0.62164706",
"0.6021899",
"0.5994172",
"0.59842855",
"0.59764385",
"0.5944389",
"0.593727",
"0.5928098",
"0.5926611",
"0.59181637",
"0.59166956",
"0.58986425",
"0.589... | 0.6655412 | 1 |
receive user input and return move key or confirm choice | def user_input():
key = input('Move position or press y to do turn: ')
if key == 'w' or 's' or 'd' or 'a' or 'y':
return key
elif key == 'h':
print('There is no help yet')
else:
print('Need help? Press "h"')
return user_input() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user_choice():\n move = input('Where would you like to move? (Use N, S, E, W to move North, South, East or West.) \\n')\n return move.capitalize()",
"def askMove(self,posibleMoves):\n print(\"Where will you move?\")\n while True:\n pos = raw_input(\"Type Colum and Row 'CR' Ex:a... | [
"0.70844096",
"0.68121403",
"0.6759099",
"0.6759018",
"0.6693364",
"0.6693364",
"0.6693364",
"0.6686266",
"0.66857535",
"0.6581062",
"0.652651",
"0.65197897",
"0.6514418",
"0.64933616",
"0.64899606",
"0.6466338",
"0.64507335",
"0.64295095",
"0.6406177",
"0.6397167",
"0.638439... | 0.70637566 | 1 |
scale the input image to the specific size by using bilinear interpolation | def scale(input_img, size):
width, height = size
old_height, old_width = input_img.shape
x_scale = float(height) / old_height
y_scale = float(width) / old_width
output_img = np.zeros((height, width), dtype=np.uint8)
for xidx in xrange(height):
old_x = float(xidx) / x_scale
for y... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scale_image(self, pixels, size):\n x_min, x_max = np.amin(pixels[:,0]), np.amax(pixels[:,0])\n y_min, y_max = np.amin(pixels[:,1]), np.amax(pixels[:,1])\n z_min, z_max = np.amin(pixels[:,2]), np.amax(pixels[:,2])\n \n pixels[:,0] -= x_min \n pixels[:,1] -= y_min\n ... | [
"0.7530757",
"0.7487166",
"0.7231397",
"0.710274",
"0.6902195",
"0.68922347",
"0.67708784",
"0.67459106",
"0.6726698",
"0.67057925",
"0.6663453",
"0.6641842",
"0.65853053",
"0.65753484",
"0.65709734",
"0.6562367",
"0.65519804",
"0.655139",
"0.65492624",
"0.64551073",
"0.64065... | 0.804545 | 0 |
Make a signature that will be used for the constructor of the Structure | def make_signature(names, required, additional_properties, bases_params_by_name):
non_default_args_for_class = OrderedDict(
[
(name, Parameter(name, Parameter.POSITIONAL_OR_KEYWORD))
for name in names
if name in required
]
)
non_default_args_for_bases = O... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_signature(func_name, restype, argtypes):\n global cfi\n f = getattr(cfi, func_name)\n f.restype = restype\n f.argtypes = argtypes",
"def make_signature(self, data, classes=None): \n raise NotImplementedError",
"def handle_signature(self, sig, signode):\n\n sig_match = rust_a... | [
"0.67649955",
"0.6748138",
"0.62753767",
"0.62733954",
"0.62205595",
"0.6208152",
"0.61552846",
"0.6111243",
"0.60572535",
"0.60572535",
"0.60572535",
"0.60314375",
"0.5854847",
"0.5817568",
"0.57975745",
"0.57575345",
"0.572025",
"0.56700957",
"0.5659344",
"0.56551206",
"0.5... | 0.5923225 | 12 |
Extract the parameters from all the base classes to support inheritance of Structures. | def get_base_info(bases):
bases_params = OrderedDict()
bases_required = []
base_structures = [
base for base in bases if issubclass(base, Structure) and base is not Structure
]
for base in base_structures:
for k, param in getattr(base, "__signature__").parameters.items():
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_params(cls):\n the_classes = cls.mro()\n params = odict()\n for the_class in the_classes:\n for key, val in the_class.__dict__.items():\n if isinstance(val, Parameter):\n params[key] = val\n return params",
"def _get_derived_parame... | [
"0.6480872",
"0.6387825",
"0.6387825",
"0.6316849",
"0.5984677",
"0.5930033",
"0.5876679",
"0.58338517",
"0.58183604",
"0.5752015",
"0.5737816",
"0.5660116",
"0.5644318",
"0.56097096",
"0.55356723",
"0.5527715",
"0.5501345",
"0.54906714",
"0.54674923",
"0.54569507",
"0.544304... | 0.70361996 | 0 |
convert to string or a list of strings | def as_str(the_val):
if hasattr(the_val, "__iter__"):
return "[{}]".format(", ".join([str(v) for v in the_val]))
return str(the_val) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def str_or_list(value):\n if isinstance(value, list):\n return value\n return [value]",
"def _strings_to_list(one_or_more_strings):\n if isinstance(one_or_more_strings, str):\n return [one_or_more_strings]\n else:\n return list(one_or_more_strings)",
"def _arg_to_str_list(arg: ... | [
"0.74122554",
"0.7048533",
"0.6944346",
"0.67461395",
"0.65838027",
"0.6525629",
"0.6525177",
"0.65212876",
"0.649296",
"0.6492582",
"0.6481708",
"0.6453794",
"0.6448759",
"0.64282435",
"0.63953394",
"0.6367725",
"0.636742",
"0.6350239",
"0.63342106",
"0.63309085",
"0.6321552... | 0.62606215 | 22 |
Parses a list of path names for path keys. | def _parse_path(p_names):
gnmi_elems = []
for word in p_names:
word_search = _RE_PATH_COMPONENT.search(word)
if not word_search: # Invalid path specified.
raise XpathError('xpath component parse error: %s' % word)
if word_search.group('key') is not None: # A path key was provided.
tmp_key ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ParsePath(p_names: Iterable[Text]) -> gnmi_pb2.Path:\n gnmi_elems = []\n for word in p_names:\n word_search = _RE_PATH_COMPONENT.search(word)\n if not word_search: # Invalid path specified.\n raise XpathError('xpath component parse error: %s' % word)\n if word_search.group('key') is not None: ... | [
"0.6744838",
"0.643762",
"0.6129683",
"0.6027652",
"0.5850749",
"0.5803134",
"0.5716737",
"0.56847453",
"0.56610566",
"0.56403434",
"0.56000715",
"0.55541354",
"0.5528111",
"0.552703",
"0.5489616",
"0.5481644",
"0.5437132",
"0.5436902",
"0.54319805",
"0.542672",
"0.54056877",... | 0.7012274 | 0 |
All this really does is add the devices into a python list! Parses the xpath names. This takes an input string and converts it to a list of gNMI Path names. Those are later turned into a gNMI Path Class object for use in the Get/SetRequests. | def _path_names(xpath):
if not xpath or xpath == '/': # A blank xpath was provided at CLI.
return []
return xpath.strip().strip('/').split('/') # Remove leading and trailing '/'. For example it turns it into ['interfaces', 'interface[name=Ethernet1]', 'state', 'counters'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse_path(p_names):\n gnmi_elems = []\n for word in p_names:\n word_search = _RE_PATH_COMPONENT.search(word)\n if not word_search: # Invalid path specified.\n raise XpathError('xpath component parse error: %s' % word)\n if word_search.group('key') is not None: # A path key was provided.\n ... | [
"0.60383373",
"0.58014375",
"0.5726008",
"0.56360483",
"0.55687326",
"0.55472445",
"0.5278853",
"0.5220772",
"0.5136307",
"0.51119274",
"0.5111663",
"0.5092509",
"0.5083667",
"0.50776213",
"0.5030007",
"0.5019841",
"0.4971111",
"0.49702564",
"0.49412",
"0.49258375",
"0.490256... | 0.64530164 | 0 |
Get the gNMI val for path definition. | def _get_val(json_value):
val = gnmi_pb2.TypedValue()
if '@' in json_value:
try:
set_json = json.loads(six.moves.builtins.open(
json_value.strip('@'), 'rb').read())
except (IOError, ValueError) as e:
raise JsonReadError('Error while loading JSON: %s' % str(e))
val.json_ietf_val = j... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _mn_get_errdef_ ( self ) :\n return _mn_stat_ ( self ) ['ERRDEF']",
"def _sysfs_gpio_value_path(self) -> str:\n return SYSFS_GPIO_VALUE_PATH % self.number",
"def getvalue(self,num,name):\n return self.M.conf(num)[name]",
"def xpath_get(self, path, dtype=str, default=None):\n items... | [
"0.54860014",
"0.5419368",
"0.5391605",
"0.53698635",
"0.5327229",
"0.52489007",
"0.5220476",
"0.514872",
"0.5135619",
"0.51132995",
"0.5089152",
"0.5076575",
"0.504162",
"0.50249386",
"0.5013237",
"0.50073",
"0.4996823",
"0.49759886",
"0.4968135",
"0.4957804",
"0.49576333",
... | 0.0 | -1 |
Creates a gNMI Stub. | def _create_stub(target, port):
channel = gnmi_pb2_grpc.grpc.insecure_channel(target + ':' + port)
return gnmi_pb2_grpc.gNMIStub(channel) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createRotoNodeMI():\n return gs()",
"def CreateStub(creds: grpc.ssl_channel_credentials,\n target: Text,\n port: Text,\n host_override: Optional[Text] = None) -> gnmi_pb2_grpc.gNMIStub:\n if host_override:\n channel = grpc.secure_channel(target + ':' + port, c... | [
"0.61915773",
"0.6070097",
"0.6048654",
"0.5815189",
"0.5606532",
"0.54397595",
"0.54164815",
"0.536739",
"0.5323115",
"0.5196695",
"0.51673496",
"0.51654017",
"0.51477623",
"0.5134972",
"0.5129161",
"0.50861603",
"0.5079436",
"0.50461864",
"0.50413865",
"0.5032544",
"0.50237... | 0.73616546 | 0 |
Create a gNMI GetRequest. | def _get(stub, paths, username, password):
if username: # User/pass supplied for Authentication.
return stub.Get(
gnmi_pb2.GetRequest(path=[paths], encoding='JSON_IETF'),
metadata=[('username', username), ('password', password)])
return stub.Get(gnmi_pb2.GetRequest(path=[paths], encoding='JSON_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createRequest(self):\n self.get_bmc_website()\n self.__createChangeRequest = Create(self.browser)\n self.__createChangeRequest.createNCR()",
"def req():\n return Request()",
"def newRequest(self):\n return Request( )",
"def _get_request(url, params):\n request = requests... | [
"0.6275348",
"0.6039188",
"0.5644295",
"0.5601162",
"0.55611426",
"0.5554668",
"0.55537415",
"0.55537415",
"0.55537415",
"0.55537415",
"0.55537415",
"0.55537415",
"0.55537415",
"0.55537415",
"0.55537415",
"0.55537415",
"0.55537415",
"0.55537415",
"0.55537415",
"0.55537415",
"... | 0.0 | -1 |
Normalized DTW distance of match. Normalization is the DTW distance divided by the query length. | def value(self):
return self.alignment.matching[self.idx] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_norm_distance(length: int, distance: float) -> float:\n return distance/(length*2)",
"def norm_distance(self):\n graph_size = self.N + self.M\n return self.distance() / (1. * graph_size)",
"def distance(self):\n return self.value * len(self.alignment.query)",
"def _get_distanc... | [
"0.6603236",
"0.65938926",
"0.6180144",
"0.6038773",
"0.5947053",
"0.59462976",
"0.5937442",
"0.59329134",
"0.5930879",
"0.59043634",
"0.58797866",
"0.58697975",
"0.58553916",
"0.58475196",
"0.58244836",
"0.58004606",
"0.57862604",
"0.5781636",
"0.57628703",
"0.57606786",
"0.... | 0.0 | -1 |
DTW distance of match. This value is dependent on the length of the query. Use the value property when comparing queries of different lengths. | def distance(self):
return self.value * len(self.alignment.query) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def distance(self) -> float:\n return self._dist_two_wire() # at this time we only support 2-wire meausre",
"async def distance(self):\n return round(await self._rpc.distance(), 2)",
"def get_distance(self) -> int:\n return self.get_measurement_data().distance",
"def distance(self):\n ... | [
"0.6928184",
"0.68774277",
"0.6728091",
"0.66035616",
"0.65458184",
"0.65157306",
"0.64634323",
"0.6341544",
"0.6227368",
"0.6217934",
"0.6202405",
"0.6184627",
"0.61629593",
"0.6140443",
"0.6025408",
"0.5916094",
"0.59097636",
"0.59070665",
"0.59023696",
"0.58621186",
"0.585... | 0.72271866 | 0 |
Matched segment in series. | def segment(self):
start = self.alignment.matching_function_startpoint(self.idx)
end = self.alignment.matching_function_endpoint(self.idx)
return [start, end] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def segment(data):",
"def inters_segment(self, s):\r\n if (self.m == s.m) and (self.n == s.n):\r\n # The segment s is over this segment. Return the middle point\r\n x = (self.start[0] + self.end[0]) / 2\r\n y = (self.start[1] + self.end[1]) / 2\r\n elif self.m == s.... | [
"0.63851285",
"0.636012",
"0.5928439",
"0.57494164",
"0.57120156",
"0.5710203",
"0.5703304",
"0.56625986",
"0.5658319",
"0.56185806",
"0.5548253",
"0.55100864",
"0.5505265",
"0.55011165",
"0.549471",
"0.5462471",
"0.5416681",
"0.5410249",
"0.54036164",
"0.5403587",
"0.5396656... | 0.56756234 | 7 |
Matched path in series | def path(self):
return self.alignment.matching_function_bestpath(self.idx) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_paths(self, start_key, target_key):\n\n stack = [(start_key, [start_key])]\n while stack:\n node_key, path = stack.pop()\n node = self.nodes[node_key]\n for nxt in node.neighbors - set(path):\n if nxt == target_key:\n yield p... | [
"0.59405094",
"0.591103",
"0.57794636",
"0.5735956",
"0.57198715",
"0.5684821",
"0.56824625",
"0.56819975",
"0.56717503",
"0.566512",
"0.5641157",
"0.56369686",
"0.56321734",
"0.5628646",
"0.56255174",
"0.5623009",
"0.5602458",
"0.56013024",
"0.5598196",
"0.55957115",
"0.5581... | 0.5848285 | 2 |
Get matrix with all warping paths. If the aligmnent was computed using a compact, the paths are first copied into a full warping paths matrix. | def warping_paths(self):
return self.paths | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def OptimalWarpingPath( self, colStart=None ):\n rows = len(self.D)\n cols = len(self.D[0])\n n = rows-1\n m = cols-1\n if colStart:\n m=colStart\n path = [(n,m)]\n while n > 0 or m > 0:\n if n == 0 :\n path.insert(0,(0,m-1))\n ... | [
"0.57083774",
"0.55504566",
"0.5493086",
"0.5358879",
"0.534058",
"0.5296055",
"0.5175524",
"0.51565313",
"0.5116445",
"0.5079303",
"0.50442624",
"0.5040348",
"0.50351185",
"0.5022339",
"0.50113636",
"0.49944746",
"0.49744827",
"0.49310946",
"0.4899484",
"0.48985958",
"0.4893... | 0.61657995 | 0 |
The matching score for each endpoint of a possible match. | def matching_function(self):
return self.matching | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def match_score(self):\n return self._match_score",
"def process_matches(matches: List[EndpointMatch]) -> List[Result] :\n out=[]\n #sort data\n sort_f = lambda match: match.endpoint_1.name\n sorted_matches = sorted(matches, key = sort_f)\n #group by endpoint 1\n for key, group in iterto... | [
"0.7035574",
"0.6779627",
"0.65998214",
"0.64877146",
"0.6409186",
"0.6369248",
"0.63564235",
"0.6307807",
"0.6299877",
"0.6294158",
"0.6294158",
"0.6275924",
"0.61757773",
"0.6149975",
"0.6143561",
"0.6095175",
"0.60838723",
"0.60640055",
"0.605235",
"0.60385066",
"0.6019981... | 0.5605125 | 71 |
Yields the next best match. Stops at k matches (use None for all matches). | def kbest_matches(self, k=1, overlap=0):
self.align()
matching = np.array(self.matching)
maxv = np.ceil(np.max(matching) + 1)
matching[:min(len(self.query) - 1, overlap)] = maxv
ki = 0
while k is None or ki < k:
best_idx = np.argmin(matching)
if be... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def kbest_matches(self, k=1):\n self.align(k=k)\n # if k is None:\n # return [SSMatch(best_idx, self) for best_idx in range(len(self.distances))]\n # if self.keep_all_distances:\n # best_idxs = np.argpartition(self.distances, k)\n # return [SSMatch(best_idx, se... | [
"0.70543814",
"0.6908173",
"0.63451654",
"0.6075485",
"0.58968025",
"0.58009946",
"0.57997376",
"0.5776829",
"0.57495296",
"0.5703111",
"0.556711",
"0.556711",
"0.55580676",
"0.55529094",
"0.55048394",
"0.54525316",
"0.54502773",
"0.5401287",
"0.53894967",
"0.5379987",
"0.535... | 0.764717 | 0 |
Matched segment in series. | def matching_function_segment(self, idx):
start = self.matching_function_startpoint(idx)
end = self.matching_function_endpoint(idx)
return [start, end] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def segment(data):",
"def inters_segment(self, s):\r\n if (self.m == s.m) and (self.n == s.n):\r\n # The segment s is over this segment. Return the middle point\r\n x = (self.start[0] + self.end[0]) / 2\r\n y = (self.start[1] + self.end[1]) / 2\r\n elif self.m == s.... | [
"0.63851285",
"0.636012",
"0.5928439",
"0.57494164",
"0.5710203",
"0.5703304",
"0.56756234",
"0.56625986",
"0.5658319",
"0.56185806",
"0.5548253",
"0.55100864",
"0.5505265",
"0.55011165",
"0.549471",
"0.5462471",
"0.5416681",
"0.5410249",
"0.54036164",
"0.5403587",
"0.5396656... | 0.57120156 | 4 |
Index in series for end of match in matching function at idx. | def matching_function_endpoint(self, idx):
if len(self.matching) == len(self.series):
return idx
diff = len(self.series) - len(self.matching)
return idx + diff | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def matching_function_startpoint(self, idx):\n real_idx = idx + 1\n path = dtw.best_path(self.paths, col=real_idx)\n start_idx = path[0][1]\n return start_idx",
"def return_index(self, idx):\n return (\n self.timeseries[:, idx],\n self.ch_amount,\n ... | [
"0.6543316",
"0.6367245",
"0.6301939",
"0.6193361",
"0.6084704",
"0.604178",
"0.6038365",
"0.59744316",
"0.5873895",
"0.5802779",
"0.5789299",
"0.57315546",
"0.5716819",
"0.5716819",
"0.5716819",
"0.5696154",
"0.56579256",
"0.5647888",
"0.5644456",
"0.5643995",
"0.5639753",
... | 0.76498044 | 0 |
Index in series for start of match in matching function at idx. | def matching_function_startpoint(self, idx):
real_idx = idx + 1
path = dtw.best_path(self.paths, col=real_idx)
start_idx = path[0][1]
return start_idx | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def matching_function_endpoint(self, idx):\n if len(self.matching) == len(self.series):\n return idx\n diff = len(self.series) - len(self.matching)\n return idx + diff",
"def return_index(self, idx):\n return (\n self.timeseries[:, idx],\n self.ch_amou... | [
"0.73175603",
"0.6497857",
"0.6373355",
"0.63612413",
"0.6209229",
"0.6074658",
"0.59414655",
"0.5822107",
"0.58188355",
"0.5815306",
"0.57833564",
"0.5764828",
"0.5758278",
"0.5715285",
"0.5713959",
"0.56651026",
"0.5658479",
"0.565782",
"0.5641599",
"0.56098294",
"0.5585502... | 0.76478 | 0 |
Indices in series for best path for match in matching function at idx. | def matching_function_bestpath(self, idx):
real_idx = idx + 1
path = dtw.best_path(self.paths, col=real_idx)
return path | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def matching_function_startpoint(self, idx):\n real_idx = idx + 1\n path = dtw.best_path(self.paths, col=real_idx)\n start_idx = path[0][1]\n return start_idx",
"def matching_function_endpoint(self, idx):\n if len(self.matching) == len(self.series):\n return idx\n ... | [
"0.6690884",
"0.6565373",
"0.6028413",
"0.5854189",
"0.56420803",
"0.5517227",
"0.5480761",
"0.5445093",
"0.543877",
"0.5414658",
"0.540015",
"0.53611726",
"0.53540796",
"0.5341432",
"0.53364134",
"0.53286445",
"0.52923155",
"0.52770895",
"0.5264886",
"0.5238736",
"0.52386314... | 0.68909335 | 0 |
Local concurrences, see LocalConcurrences. | def local_concurrences(series1, series2=None, gamma=1, tau=0, delta=0, delta_factor=1, estimate_settings=None,
only_triu=False, penalty=None, window=None):
lc = LocalConcurrences(series1, series2, gamma, tau, delta, delta_factor,
only_triu=only_triu, penalty=penalty... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_local_school_composition(self):\n # get the composition of the students in the neighbourhood\n\n local_composition = get_counts_util(students=self.students, model=self.model)\n\n self.local_composition = local_composition\n\n self.current_capacity = np.sum(self.local_composition... | [
"0.60490185",
"0.60490185",
"0.60156554",
"0.565439",
"0.5614832",
"0.5524443",
"0.53362507",
"0.5183139",
"0.5157542",
"0.51443374",
"0.51101583",
"0.51035136",
"0.50987923",
"0.5077436",
"0.5068534",
"0.505619",
"0.5055168",
"0.5046074",
"0.5033463",
"0.50281024",
"0.501018... | 0.60815006 | 0 |
Yields the next best match. Stops at k matches (use None for all matches). | def kbest_matches(self, k=1, minlen=2, buffer=0):
ki = 0
while k is None or ki < k:
idx = None
lcm = None
while idx is None:
idx = np.unravel_index(np.argmax(self._wp, axis=None), self._wp.shape)
if idx[0] == 0 or idx[1] == 0:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def kbest_matches(self, k=1, overlap=0):\n self.align()\n matching = np.array(self.matching)\n maxv = np.ceil(np.max(matching) + 1)\n matching[:min(len(self.query) - 1, overlap)] = maxv\n ki = 0\n while k is None or ki < k:\n best_idx = np.argmin(matching)\n ... | [
"0.7646963",
"0.70550805",
"0.63452125",
"0.6075674",
"0.58965683",
"0.58014125",
"0.5800323",
"0.5776327",
"0.57494646",
"0.57036394",
"0.556718",
"0.556718",
"0.5560365",
"0.5552767",
"0.5505271",
"0.54529965",
"0.54505706",
"0.54012245",
"0.53904915",
"0.538011",
"0.535193... | 0.69067085 | 2 |
Search the best matching (subsequence) time series compared to a given time series. | def __init__(self, query, s, dists_options=None, use_lb=True, keep_all_distances=False,
max_dist=None, max_value=None, use_c=None, use_ndim=None):
self.query = query
if use_ndim is None:
self.use_ndim = (util.detect_ndim(query) > 1)
else:
self.use_ndim = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simsearch_non_exist(self, input_ts, n):\n\n\t\tinput_ts = standardize(input_ts)\n\t\t# calc dist from input_ts to vantage points\n\t\tdist = []\n\t\tfor (vt, id) in self.vantage_pts:\n\t\t\tdist.append((calcDist(vt, input_ts), str(id)))\n\t\t# sort vantage points by distance\n\t\tdist.sort(key=lambda kv: kv[0]... | [
"0.56875837",
"0.5610644",
"0.55802405",
"0.5507607",
"0.54011166",
"0.5385939",
"0.53479487",
"0.5211469",
"0.52071184",
"0.51898646",
"0.5148763",
"0.51333714",
"0.5120546",
"0.5094568",
"0.508902",
"0.5076198",
"0.5071674",
"0.50551015",
"0.5047635",
"0.5043175",
"0.498195... | 0.0 | -1 |
Return the ith value from the kbest values. | def get_ith_value(self, i):
if self.distances is None or self.k is None:
raise ValueError('Align should be called before asking for the i-th value.')
if i > self.k:
raise ValueError('The i-th value is not available, i={}>k={}'.format(i, self.k))
return self.kbest_distance... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Kbest(kbest_init, kbest, i, iter_number, all_iter_number=None):\n iter_number = iter_number if all_iter_number is None else all_iter_number\n d = iter_number / kbest_init\n nkbest = math.ceil(abs(kbest_init - i/d))\n return nkbest",
"def get_n_best(self):\n pass",
"def best_value(self):\... | [
"0.683538",
"0.66753155",
"0.6674319",
"0.64500123",
"0.63540584",
"0.63536274",
"0.63132733",
"0.62678784",
"0.6219374",
"0.6204914",
"0.6191994",
"0.6184342",
"0.6169411",
"0.6162491",
"0.6113362",
"0.60936606",
"0.6074645",
"0.60177016",
"0.6013775",
"0.6009977",
"0.600826... | 0.7239786 | 0 |
Return the k best matches. It is recommended to set k to a value, and not None. If k is set to None, all comparisons are kept and returned. Also no early stopping is applied in case k is None. | def kbest_matches(self, k=1):
self.align(k=k)
# if k is None:
# return [SSMatch(best_idx, self) for best_idx in range(len(self.distances))]
# if self.keep_all_distances:
# best_idxs = np.argpartition(self.distances, k)
# return [SSMatch(best_idx, self) for bes... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def kbest_matches(self, k=1, overlap=0):\n self.align()\n matching = np.array(self.matching)\n maxv = np.ceil(np.max(matching) + 1)\n matching[:min(len(self.query) - 1, overlap)] = maxv\n ki = 0\n while k is None or ki < k:\n best_idx = np.argmin(matching)\n ... | [
"0.75734186",
"0.69651777",
"0.64580584",
"0.62036735",
"0.6153091",
"0.61466444",
"0.5955852",
"0.5941158",
"0.5936029",
"0.5909154",
"0.5865215",
"0.58565974",
"0.58123106",
"0.58104837",
"0.58069605",
"0.5760755",
"0.5758019",
"0.5743457",
"0.57420886",
"0.57395303",
"0.57... | 0.74664825 | 1 |
Initialize the default serializer instance. | def __init__(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize_serializer(self):\n serializer = self.pyleus_config.get('serializer')\n if serializer in SERIALIZERS:\n self._serializer = SERIALIZERS[serializer](\n self._input_stream, self._output_stream)\n else:\n raise ValueError(\"Unknown serializer: {0... | [
"0.78563565",
"0.74911463",
"0.7031151",
"0.6834225",
"0.68167543",
"0.65071994",
"0.64760256",
"0.6447599",
"0.64018154",
"0.63145745",
"0.6253491",
"0.62514484",
"0.622034",
"0.6200799",
"0.6196979",
"0.6187993",
"0.61851466",
"0.6144137",
"0.61341083",
"0.611839",
"0.61169... | 0.0 | -1 |
r"""AlexNet model architecture from the | def localizer_alexnet(pretrained=False, **kwargs):
model = LocalizerAlexNet(**kwargs)
if pretrained is True:
# load parts of pre-train
state_dict_pretrain = model_zoo.load_url(model_urls['alexnet'])
state_dict_new = {}
for item_name, item_value in state_dict_pretrain.iteritems()... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def alexnet(**kwargs):\n model = AlexNet(**kwargs)\n # if pretrained:\n # model.load_state_dict(model_zoo.load_url(model_urls['alexnet']))\n return model",
"def imagenet_alexnet(**kwargs):\r\n model = ImageNetAlexNet(**kwargs)\r\n return model",
"def load(self, name=\"\"):\n\n self... | [
"0.6519144",
"0.6468875",
"0.64450973",
"0.64397836",
"0.631246",
"0.6307277",
"0.6291954",
"0.6257867",
"0.62547463",
"0.6231065",
"0.61943966",
"0.614853",
"0.6140133",
"0.6133221",
"0.6133221",
"0.61192954",
"0.61159253",
"0.610197",
"0.60987943",
"0.6097791",
"0.6090801",... | 0.0 | -1 |
VGG 19layer model (configuration "E") | def localizer_vggnet(pretrained=False, **kwargs):
model = LocalizerVGG(make_layers(cfg['E']), **kwargs)
if pretrained:
model.load_state_dict(model_zoo.load_url(model_urls['vgg19']))
return model | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_vgg():\n input_shape = (256, 256, 3)\n\n vgg = keras.applications.VGG19(include_top = False , input_shape = input_shape , weights=\"imagenet\")\n features = vgg.get_layer(index = 9).output\n\n model = keras.Model(inputs=[vgg.inputs], outputs=[features])\n return model",
"def vgg19(pretr... | [
"0.7938028",
"0.7352684",
"0.7322909",
"0.731347",
"0.72912514",
"0.72898996",
"0.7235066",
"0.72287446",
"0.7197585",
"0.71894604",
"0.7084843",
"0.707336",
"0.7058049",
"0.7026087",
"0.7002693",
"0.69967985",
"0.69944525",
"0.69195586",
"0.6903537",
"0.68565315",
"0.6850008... | 0.0 | -1 |
Constructs a ResNet101 model. | def localizer_resnet(pretrained=False, **kwargs):
model = LocalizerResNet(Bottleneck, [3, 4, 23, 3], **kwargs)
if pretrained:
model.load_state_dict(model_zoo.load_url(model_urls['resnet101']))
return model | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resnet101(pretrained=False, **kwargs):\n model = ResNet(Bottleneck, [3, 4, 23, 3], **kwargs)\n if pretrained:\n model.load_state_dict(model_zoo.load_url(model_urls['resnet101']))\n fc = transfer_fc(model.fc)\n model.fc = fc\n return model",
"def resnet101(pretrained=False):\n model =... | [
"0.74078393",
"0.7382251",
"0.7362759",
"0.7362759",
"0.7362759",
"0.7362759",
"0.73424184",
"0.7229764",
"0.71670717",
"0.7158963",
"0.71486",
"0.71486",
"0.71299857",
"0.70261806",
"0.7023042",
"0.7003144",
"0.67619354",
"0.6710136",
"0.6650574",
"0.6602656",
"0.6595372",
... | 0.0 | -1 |
Drop `None` valued keys from an object. | def _drop_nulls(o):
if isinstance(o, (dict, Mapping)):
return {k: _drop_nulls(v) for k, v in o.items() if v is not None}
elif isinstance(o, list):
return [_drop_nulls(v) for v in o if v is not None]
elif isinstance(o, set):
return {_drop_nulls(v) for v in o if v is not None}
else... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_none(obj: dict):\n return remap(\n obj, visit=lambda path, key, value: key is not None and value is not None\n )",
"def remove_empty_fields(obj: dict) -> dict:\n return {k: v for k, v in obj.items() if v is not None}",
"def strip_empty_optional_fields(object_dict):\n return {k: v ... | [
"0.82257617",
"0.7622132",
"0.7455038",
"0.7318793",
"0.7178498",
"0.71008503",
"0.6978789",
"0.69149274",
"0.68529075",
"0.68520445",
"0.6845486",
"0.68321306",
"0.6754147",
"0.674078",
"0.6731009",
"0.671434",
"0.6638371",
"0.66069853",
"0.6593238",
"0.6582964",
"0.653182",... | 0.7540454 | 2 |
Gets the marshmallow serializer for the implementing class. | def schema(cls):
schema = getattr(cls, "__schema__")
if schema is None:
raise Exception(f"{cls.__name__}: not serializable; missing schema")
return schema | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getSerializer():",
"def serializer(self) -> ArchiveSerializer:\n return serializer_from_dict(self.doc.get('serializer'))",
"def get_serializer_class(self):\n return self.serializer_class",
"def serializer_class(self):",
"def serializer_for(self, obj):\n # 1-NULL serializer\n ... | [
"0.6885214",
"0.68805057",
"0.68130696",
"0.6553876",
"0.6539851",
"0.65222543",
"0.6462709",
"0.63988924",
"0.63497216",
"0.6265041",
"0.62470025",
"0.6222195",
"0.6174481",
"0.6151403",
"0.6135117",
"0.61226743",
"0.61192995",
"0.61141056",
"0.6104061",
"0.60989475",
"0.608... | 0.54014117 | 84 |
Convert an implementing instance to JSON. | def to_json(
self,
camel_case: bool = True,
pretty_print: bool = True,
drop_nulls: bool = False,
) -> str:
d = (
self.schema().dump(self)
if camel_case
else {humps.decamelize(k): v for k, v in self.schema().dump(self).items()}
)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def toJSON(self):\n raise NotImplementedError()",
"def _trait_to_json(x, self):\n return x",
"def cls2json(self):\n return json.dumps(self.__dict__)",
"def cls2json(self):\n return json.dumps(self.__dict__)",
"def to_json(self):\n return json.dumps(self._asdict())",
"def to... | [
"0.76304615",
"0.72295505",
"0.71398264",
"0.71398264",
"0.70748025",
"0.6982968",
"0.6981433",
"0.6967107",
"0.694104",
"0.69204724",
"0.6879784",
"0.6869435",
"0.68520975",
"0.68448627",
"0.6821424",
"0.679783",
"0.6795996",
"0.6789671",
"0.6786653",
"0.6750585",
"0.6750306... | 0.0 | -1 |
Convert an implementing instance to a Python dictionary. | def to_dict(self, camel_case: bool = True):
if camel_case: # camel case is used by default
return self.schema().dump(self)
return {humps.decamelize(k): v for k, v in self.schema().dump(self).items()} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_dict(cls) -> dict:\n raise NotImplementedError()",
"def to_dict(self):\n raise NotImplementedError('To be implemented in subclass.')",
"def to_dict(self) -> dict:\n if self.actual_instance is None:\n return None\n\n to_dict = getattr(self.actual_instance, \"to_dict... | [
"0.7722431",
"0.72972405",
"0.72160584",
"0.7203824",
"0.7089014",
"0.70702934",
"0.6892197",
"0.6865275",
"0.6825165",
"0.6812693",
"0.67964077",
"0.67964077",
"0.6761097",
"0.6760542",
"0.6744427",
"0.6713587",
"0.67031294",
"0.66965395",
"0.6682606",
"0.66673934",
"0.66619... | 0.0 | -1 |
Define the main Situation Map This can then be called from both the Index page (embedded) & the Map_Viewing_Client (fullscreen) | def define_map(window=False, toolbar=False, config=None):
if not config:
config = gis.get_config()
if not deployment_settings.get_security_map() or s3_has_role("MapAdmin"):
catalogue_toolbar = True
else:
catalogue_toolbar = False
# @ToDo: Make these configurable
search = T... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def home():\n m = Map() # Create map html\n return render_template('index.html') # pulls map html using jinja2",
"def map_page():\n m = Map() # Create map html\n return render_template('index.html') # pulls map html using jinja2",
"def map_viewing_client():\n\n # Read configuration settings\n ... | [
"0.68494546",
"0.6841336",
"0.66321546",
"0.6554362",
"0.650557",
"0.6486836",
"0.64321727",
"0.63996077",
"0.6397022",
"0.63146144",
"0.62892425",
"0.6276585",
"0.62084687",
"0.6158665",
"0.6139917",
"0.6106178",
"0.61012053",
"0.60764265",
"0.60558933",
"0.6029097",
"0.6025... | 0.58404505 | 36 |
RESTful CRUD controller for Locations | def location():
tablename = "%s_%s" % (module, resourcename)
table = db[tablename]
# Allow prep to pass vars back to the controller
vars = {}
# @ToDo: Clean up what needs to be done only for interactive views,
# vs. what needs to be done generally. E.g. some tooltips are defined
# for non... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self):\n response = view_locations()\n return marshal(response, view_locations_model), SUCCESS",
"def locations(request):\n locations = Location.objects.all()\n context = {'locations': locations}\n return render(request, 'std/Locations.html', context)",
"def add_location_to_datab... | [
"0.62846005",
"0.5941099",
"0.58022356",
"0.5732818",
"0.56623435",
"0.5616209",
"0.56091696",
"0.5553856",
"0.55110383",
"0.5508723",
"0.5465169",
"0.54390836",
"0.5432776",
"0.5418669",
"0.5358974",
"0.5351006",
"0.5321775",
"0.5263251",
"0.5243733",
"0.5202777",
"0.5198896... | 0.5839535 | 2 |
Handle Deduplication of Locations by comparing the ones which are closest together | def location_duplicates():
if not auth.s3_has_role(1):
redirect(URL(r=request, c="default", f="index"))
# @ToDo: Set this via the UI & pass in as a var
dupe_distance = 50 # km
# Shortcut
locations = db.gis_location
table_header = THEAD(TR(TH(T("Location 1")),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_nearest_location():\n locations = [(10, 20), (30, 40), (50, 60)]\n\n assert nearest_location(locations, 8) == 0\n assert nearest_location(locations, 15) == 0\n assert nearest_location(locations, 22) == 0\n\n assert nearest_location(locations, 28) == 1\n assert nearest_location(locations,... | [
"0.6515084",
"0.6443725",
"0.6310686",
"0.62804294",
"0.62343484",
"0.6222334",
"0.6214705",
"0.61703825",
"0.6148088",
"0.61349726",
"0.60373837",
"0.6024918",
"0.59760636",
"0.5908262",
"0.5871901",
"0.58064955",
"0.580585",
"0.58049893",
"0.57756054",
"0.57671916",
"0.5748... | 0.0 | -1 |
Delete references to a old record and replacing it with the new one. | def delete_location():
old = request.vars.old
new = request.vars.new
# Find all tables which link to the Locations table
# @ToDo Replace with db.gis_location._referenced_by
tables = shn_table_links("gis_location")
for table in tables:
for count in range(len(tables[table])):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete(self, old):\n return self.replace(old, None)",
"def clean_collection(previous_records, collection):\n for previous_record in previous_records:\n collection.delete_one({\"_ref\": previous_record})",
"def unlink(self):\n self._linked = False\n self.is_dirty = Fal... | [
"0.6722188",
"0.63206416",
"0.6193478",
"0.6067735",
"0.6048706",
"0.6044757",
"0.59926844",
"0.5902274",
"0.58998084",
"0.5897296",
"0.5842966",
"0.5819181",
"0.5801957",
"0.5744306",
"0.571759",
"0.56649935",
"0.56476563",
"0.5647505",
"0.5632458",
"0.5605677",
"0.55868614"... | 0.58176273 | 12 |
Opens a popup screen where the deduplication process takes place. | def location_resolve():
# @ToDo: Error gracefully if conditions not satisfied
locID1 = request.vars.locID1
locID2 = request.vars.locID2
# Shortcut
locations = db.gis_location
# Remove the comment and replace it with buttons for each of the fields
count = 0
for field in locations:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ShowPopUp(self):\n self.popup = True\n t = Timer(1.0, self.RemovePopUp)\n t.start() # after 1 second, the pop up will be removed",
"def close_1(self):\n self.pop_up_del.destroy()",
"def player_killed_popup(self):\n\n # creates/formats popup content\n content = Box... | [
"0.6079889",
"0.59903973",
"0.577682",
"0.5569663",
"0.5477131",
"0.5393549",
"0.53250754",
"0.5319395",
"0.5258942",
"0.5247842",
"0.52020067",
"0.5171097",
"0.51346767",
"0.50580317",
"0.50342005",
"0.50131637",
"0.50029737",
"0.49837068",
"0.4970867",
"0.49681687",
"0.4945... | 0.0 | -1 |
id the location record id Returns a JSON array of records which link to the specified location | def location_links():
try:
record_id = request.args[0]
except:
item = s3xrc.xml.json_message(False, 400, "Need to specify a record ID!")
raise HTTP(400, body=item)
try:
# Shortcut
locations = db.gis_location
deleted = (locations.deleted == False)
qu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_location_by_id(self, location_id):",
"def get_locations_by_ids(self, id_list):",
"def get_locations(self, id_):\n with self._db_connection() as connection:\n return connection.get_locations(id_)",
"def get_record(self, id: uplink.Path):\n pass",
"def get(self, lid=None):\n ... | [
"0.67174894",
"0.6008066",
"0.58011514",
"0.57892656",
"0.5722104",
"0.57062936",
"0.5673444",
"0.56674194",
"0.5475068",
"0.53737307",
"0.5360654",
"0.53458697",
"0.5334068",
"0.5311456",
"0.5299961",
"0.5287552",
"0.5255019",
"0.525247",
"0.52420944",
"0.5201093",
"0.520053... | 0.69435656 | 0 |
Map Service Catalogue. Allows selection of which Layers are active. | def map_service_catalogue():
if deployment_settings.get_security_map() and not s3_has_role("MapAdmin"):
unauthorised()
subtitle = T("List Layers")
# Start building the Return with the common items
output = dict(subtitle=subtitle)
# Hack: We control all perms from this 1 table
table = d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addServices(self):\r\n self.addHendrix()\r\n\r\n if not self.options.get('global_cache') and not self.options.get('nocache'):\r\n self.addLocalCacheService()\r\n\r\n if self.is_secure:\r\n self.addSSLService()\r\n\r\n self.catalogServers(self.hendrix)",
"def ... | [
"0.56927997",
"0.5558211",
"0.5455615",
"0.5436424",
"0.5423937",
"0.5407362",
"0.5387539",
"0.53662133",
"0.531283",
"0.52958256",
"0.5293356",
"0.5290555",
"0.5283825",
"0.5283825",
"0.5278759",
"0.52735716",
"0.5246372",
"0.52412826",
"0.5204378",
"0.5197035",
"0.51858264"... | 0.7492633 | 0 |
RESTful CRUD controller Deprecated? (How to link Symbology with Feature Queries?) | def feature_class():
if deployment_settings.get_security_map() and not s3_has_role("MapAdmin"):
unauthorised()
tablename = "%s_%s" % (module, resourcename)
table = db[tablename]
# Model options
table.gps_marker.comment = DIV( _class="tooltip",
_title="%s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def api():\n from gluon.contrib.hypermedia import Collection\n rules = {\n '<tablename>': {'GET':{},'POST':{},'PUT':{},'DELETE':{}},\n }\n return Collection(db).process(request,response,rules)",
"def api():\n from gluon.contrib.hypermedia import Collection\n rules = {\n '<tabl... | [
"0.63021535",
"0.63021535",
"0.63021535",
"0.54665816",
"0.5306297",
"0.51899964",
"0.51852626",
"0.5146428",
"0.5133736",
"0.5106283",
"0.5064291",
"0.5060795",
"0.50409156",
"0.50372016",
"0.50157815",
"0.50113213",
"0.50113213",
"0.5009449",
"0.49796224",
"0.49735948",
"0.... | 0.48194984 | 51 |
OnValidation callback to strip the module from the resource in future may build the simple Query from helpers | def feature_layer_query(form):
resource = None
if "resource" in form.vars:
resource = form.vars.resource
# Remove the module from name
form.vars.resource = resource[len(form.vars.module) + 1:]
#if "advanced" in form.vars:
# # We should use the query field as-is
# pass... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def definition_validator(request):\n return validator(request, DefinitionValidator())",
"def clean_scope_path(field_name):\n\n @check_field_is_empty(field_name)\n def wrapper(self):\n \"\"\"Decorator wrapper method.\n \"\"\"\n # convert to lowercase for user comfort\n scope_path = self.cleaned_d... | [
"0.54791737",
"0.51245075",
"0.5107239",
"0.5107239",
"0.5095273",
"0.50353414",
"0.5028772",
"0.5028772",
"0.49702075",
"0.49682945",
"0.49621952",
"0.491872",
"0.48250982",
"0.48220852",
"0.48180136",
"0.48148456",
"0.48021254",
"0.477355",
"0.4771214",
"0.47633955",
"0.476... | 0.0 | -1 |
RESTful CRUD controller for GPS Waypoints | def waypoint():
tablename = "%s_%s" % (module, resourcename)
return s3_rest_controller(module, resourcename) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def truck_new_destination(request):\n\n # Check if the request type if POST\n if request.method == \"POST\":\n # Deserialize the JSON because it will be in bytes\n body = json.loads(request.body)\n # Make success true\n body[\"success\"] = True\n result = Coordinates.object... | [
"0.6011582",
"0.56452894",
"0.5466609",
"0.53996044",
"0.53592944",
"0.52812284",
"0.5271507",
"0.5268566",
"0.5232904",
"0.52319175",
"0.5200802",
"0.51974565",
"0.5183591",
"0.5177245",
"0.5163129",
"0.51435393",
"0.51186156",
"0.51055056",
"0.50948495",
"0.50870943",
"0.50... | 0.55535144 | 2 |
RESTful CRUD controller for GPS Track points | def trackpoint():
tablename = "%s_%s" % (module, resourcename)
return s3_rest_controller(module, resourcename) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def postPoint(request, Form):\n\tform = Form(request.POST)\n\tform.data = form.data.copy()\n\n\t# Convert coords to valid geometry\n\ttry:\n\t\tform.data['geom'] = normalizeGeometry(form.data['geom'])\n\texcept(ValueError):\n\t\t# TODO provide error message to user here\n\t\tJsonResponse({'success': False})\n\t\t#... | [
"0.5809034",
"0.5650834",
"0.5485648",
"0.54556686",
"0.54116833",
"0.5347068",
"0.5315559",
"0.53064376",
"0.52042806",
"0.5170043",
"0.515309",
"0.51526916",
"0.5140874",
"0.5118063",
"0.5113319",
"0.51017606",
"0.50763506",
"0.50656134",
"0.50540537",
"0.50357795",
"0.5021... | 0.49471533 | 24 |
RESTful CRUD controller for GPS Tracks (uploaded as files) | def track():
if deployment_settings.get_security_map() and not s3_has_role("MapAdmin"):
unauthorised()
tablename = "%s_%s" % (module, resourcename)
# Model options
# used in multiple controllers, so defined in model
# CRUD Strings
# used in multiple controllers, so defined in model
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fileupload():\r\n response.view = 'generic.json'\r\n\r\n if not session.add_files:\r\n session.add_files = []\r\n\r\n def GET(tulip_url, file=None, deletefile=None, uploads=None, commit=None):\r\n try:\r\n tulip_url = request.args[0]\r\n tulip = Tulip(url=tulip_url)... | [
"0.5775585",
"0.55965734",
"0.5479527",
"0.5399208",
"0.53839546",
"0.53149116",
"0.5286183",
"0.5246993",
"0.5221587",
"0.52108526",
"0.5184614",
"0.51574683",
"0.5151327",
"0.5146005",
"0.51184344",
"0.5110236",
"0.50837094",
"0.5052814",
"0.50399965",
"0.5034756",
"0.50265... | 0.5204354 | 10 |
Map Viewing Client. UI for a user to view the overall Maps with associated Features | def map_viewing_client():
# Read configuration settings
config = gis.get_config()
if config.opt_gis_layout == 1:
window = True
else:
window = False
# @ToDo Make Configurable
toolbar = True
map = define_map(window=window, toolbar=toolbar, config=config)
response.title ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_map(self):\n self.m1.display()",
"def view_map():\n print(\"\"\"\n ____________________________________Client Rooms______________________\n| |1 Locker Rooms 2| 1 | 2 | |\n| |_________ ________| | | Dance |\n| ... | [
"0.7127541",
"0.67286265",
"0.6691963",
"0.6657234",
"0.6594132",
"0.6563301",
"0.6557549",
"0.65367615",
"0.6368804",
"0.6324405",
"0.63240755",
"0.6310753",
"0.6295974",
"0.6293221",
"0.6289974",
"0.6289065",
"0.6267285",
"0.62239516",
"0.6221713",
"0.62063324",
"0.6203795"... | 0.7959577 | 0 |
Cutdown version of the Map Viewing Client. Used by shn_gis_location_represent() to show just this feature on the map. Called by the s3_viewMap() JavaScript | def display_feature():
# The Feature
feature_id = request.args(0)
# Check user is authorised to access record
if not s3_has_permission("read", db.gis_location, feature_id):
session.error = T("No access to this record!")
raise HTTP(401, body=s3xrc.xml.json_message(False, 401, session.er... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def map_viewing_client():\n\n # Read configuration settings\n config = gis.get_config()\n if config.opt_gis_layout == 1:\n window = True\n else:\n window = False\n\n # @ToDo Make Configurable\n toolbar = True\n\n map = define_map(window=window, toolbar=toolbar, config=config)\n\n... | [
"0.70388645",
"0.6206016",
"0.59935665",
"0.5980806",
"0.5953084",
"0.588402",
"0.58347285",
"0.57914495",
"0.5777059",
"0.5756342",
"0.5682982",
"0.56562376",
"0.5653656",
"0.56441224",
"0.5619128",
"0.5595263",
"0.5566024",
"0.5558867",
"0.5549201",
"0.55468726",
"0.5527164... | 0.5667057 | 11 |
Cutdown version of the Map Viewing Client. Used as a link from the RHeader. URL generated serverside Shows all locations matching a query. | def display_features():
# Parse the URL, check for implicit resources, extract the primary record
# http://127.0.0.1:8000/eden/gis/display_features&module=pr&resource=person&instance=1&jresource=presence
ok = 0
if "module" in request.vars:
res_module = request.vars.module
ok +=1
if ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def map_viewing_client():\n\n # Read configuration settings\n config = gis.get_config()\n if config.opt_gis_layout == 1:\n window = True\n else:\n window = False\n\n # @ToDo Make Configurable\n toolbar = True\n\n map = define_map(window=window, toolbar=toolbar, config=config)\n\n... | [
"0.67756677",
"0.62331223",
"0.5998669",
"0.59628314",
"0.5796065",
"0.57899296",
"0.5650925",
"0.56401074",
"0.5581914",
"0.5578536",
"0.5540391",
"0.55384326",
"0.5536463",
"0.55362093",
"0.5535088",
"0.5525045",
"0.54985315",
"0.5463616",
"0.5459861",
"0.54495734",
"0.5404... | 0.0 | -1 |
Call a Geocoder service | def geocode():
if "location" in request.vars:
location = request.vars.location
else:
session.error = T("Need to specify a location to search for.")
redirect(URL(r=request, f="index"))
if "service" in request.vars:
service = request.vars.service
else:
# @ToDo: se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def geocoding(address, API_KEY=API_KEY, GEOCODE_API_URL=GEOCODE_API_URL):\n # define the parameters of the search\n params = {\n 'address': '{}'.format(address),\n 'key': API_KEY\n }\n\n # Do the request and get the response data\n response = requests.get(GEOCODE_API_URL, params=params)\n r... | [
"0.67605937",
"0.66416836",
"0.6609462",
"0.64985216",
"0.63995135",
"0.6378873",
"0.6299485",
"0.62925833",
"0.6129592",
"0.60888636",
"0.60519594",
"0.6046673",
"0.602397",
"0.5928912",
"0.59067833",
"0.59050494",
"0.58398014",
"0.5806385",
"0.5775408",
"0.577366",
"0.57714... | 0.70826596 | 0 |
Custom View for GeoExplorer | def about():
return dict() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def skinProxyGeo(self):\n\n pass",
"def view(self):\n raise NotImplementedError",
"def layers(self): # -> LayerView:\n ...",
"def view(self):",
"def home(request):\n # view_options = MVView(\n # projection='EPSG:4326',\n # center=[-70.6,18.75],\n # zoom=8,\n ... | [
"0.6319753",
"0.62977684",
"0.6024548",
"0.59940994",
"0.5963482",
"0.5947566",
"0.58839697",
"0.5866329",
"0.5845885",
"0.57547957",
"0.5734449",
"0.57217485",
"0.57103384",
"0.55894476",
"0.5579907",
"0.55639654",
"0.55572385",
"0.5553838",
"0.55305344",
"0.5512673",
"0.549... | 0.0 | -1 |
Map Save/Publish Handler for GeoExplorer | def maps():
if request.env.request_method == "GET":
# This is a request to read the config of a saved map
# Which map are we updating?
id = request.args(0)
if not id:
raise HTTP(501)
# Read the WMC record
record = db(db.gis_wmc.id == id).select(limitby=... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_map(self, save_location):\n self.map.save(save_location)",
"def save_map(self, path: str):\n self.folium_map.save(path)",
"def save_to_geojson(self, topology_map, filename):",
"def save(self):\n if self._filename:\n with open(self._filename, 'w') as f:\n ... | [
"0.65955484",
"0.65663844",
"0.61429054",
"0.5894037",
"0.58076996",
"0.5799099",
"0.57216716",
"0.5705162",
"0.57048523",
"0.57038677",
"0.56936365",
"0.56528556",
"0.5625634",
"0.5615208",
"0.55805653",
"0.55427307",
"0.5536261",
"0.5494068",
"0.54426414",
"0.5428568",
"0.5... | 0.5233776 | 30 |
Custom View for the Potlatch2 OpenStreetMap editor | def potlatch2():
if request.args(0) == "potlatch2.html":
osm_oauth_consumer_key = deployment_settings.get_osm_oauth_consumer_key()
osm_oauth_consumer_secret = deployment_settings.get_osm_oauth_consumer_secret()
if osm_oauth_consumer_key and osm_oauth_consumer_secret:
gpx_url = N... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def view_map():\n print(\"\"\"\n ____________________________________Client Rooms______________________\n| |1 Locker Rooms 2| 1 | 2 | |\n| |_________ ________| | | Dance |\n| | | |__| |__| Fl... | [
"0.5956941",
"0.5876095",
"0.5870691",
"0.5804954",
"0.57842386",
"0.57654804",
"0.5738355",
"0.5679043",
"0.5668454",
"0.5618465",
"0.55423635",
"0.55370593",
"0.547862",
"0.54725426",
"0.54639965",
"0.54085356",
"0.54077595",
"0.5403992",
"0.5376458",
"0.5351264",
"0.534027... | 0.6068055 | 0 |
Test new OpenLayers functionality in a RAD environment currently being used to trial using GeoJSON for internal feature layers | def test2():
# Internal Feature Layers
feature_queries = []
feature_layers = db(db.gis_layer_feature.resource == "office").select()
for layer in feature_layers:
if layer.role_required and not auth.s3_has_role(layer.role_required):
continue
_layer = gis.get_feature_layer(laye... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_product():\n\n fiveconfigure.debug_mode = True\n import collective.geo.openlayers\n zcml.load_config('configuretest.zcml', collective.geo.openlayers)\n\n fiveconfigure.debug_mode = False",
"def test_layer_API(self):\n\n # Exceptions\n exclude = ['get_topN', 'get_bins',\n ... | [
"0.654739",
"0.6299019",
"0.6127946",
"0.58873796",
"0.57860696",
"0.5783082",
"0.5711746",
"0.56842566",
"0.5647381",
"0.56204945",
"0.559212",
"0.55821013",
"0.5580289",
"0.55746514",
"0.557363",
"0.5571923",
"0.553894",
"0.55071616",
"0.5482145",
"0.5464055",
"0.54393184",... | 0.7514468 | 0 |
Asigna el valor v al elemento kveces anterior. | def __setitem__(self, k, v):
self.valores[( zero - k )%self.longitud] = v | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def actualizar_velocidad(self):\r\n pass",
"def find_prev(self, v):\n if v - 1 < self.values[0] or v - 1 > self.values[-1]:\n raise IndexError('element not found')\n\n index = self._bin_search_recursive(v, 0, len(self.values) - 1)\n\n if index > 0:\n return self.... | [
"0.5935664",
"0.58318734",
"0.57799566",
"0.573883",
"0.56817716",
"0.56737953",
"0.56477207",
"0.5641579",
"0.5633477",
"0.56009114",
"0.55635613",
"0.5553526",
"0.5553526",
"0.55367154",
"0.5518482",
"0.54913104",
"0.54913104",
"0.54346764",
"0.5428058",
"0.5373884",
"0.537... | 0.5369091 | 22 |
Obtiene el valor del kesimo elemento. | def __getitem__(self, k):
it = Historial.__getitem__(self, k)
if it != None:
return it[1]
else:
return it | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def valor(self):\n try:\n objeto = self.objeto\n except AttributeError:\n objeto = None\n return objeto",
"def valor(self):\n if self._inteiro != None:\n return str(self._inteiro)\n else:\n return \"Sem Valor\"",
"de... | [
"0.7187529",
"0.71030325",
"0.65446925",
"0.6502201",
"0.6502201",
"0.6502201",
"0.6472011",
"0.6464514",
"0.6441088",
"0.6440774",
"0.64297825",
"0.64091015",
"0.6393591",
"0.6393024",
"0.6393024",
"0.6393024",
"0.6356786",
"0.6339224",
"0.6331197",
"0.6331197",
"0.6327495",... | 0.0 | -1 |
Obtiene el tiempo del kesimo elemento (por el final). | def time(self, k):
it = Historial.__getitem__(self, k)
if it != None:
return it[0]
else:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def letra_tiempo(self):\n return self.letra, self.tiempo",
"def get_t(self):\n return self.t",
"def get_tin(self):\n return self.tin[:]",
"def Temp(t):\n return 20 # Need to link to data",
"def _get_max_t(self):\n \"\"\"\n if hasattr(self,'k_of_t'):\n re... | [
"0.619667",
"0.59608144",
"0.59497315",
"0.5923782",
"0.5808081",
"0.5783681",
"0.5765352",
"0.5689239",
"0.56744725",
"0.56744725",
"0.5661414",
"0.56252795",
"0.5588799",
"0.55462325",
"0.5516231",
"0.5511294",
"0.5499417",
"0.54709876",
"0.5412701",
"0.54074687",
"0.537343... | 0.4978765 | 78 |
Devuelve un iterador por la lista de tiempos. | def times(self):
class IterTimes:
def __init__(self, st):
self.c = 0
self.st = st
def __iter__(self):
return self
def next(self):
t = self.st.time(self.c)
if t =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __iter__(self):\n start_times = (start for start, end in self.tss)\n names = (name.rstrip() for name in self.inps)\n for ind, (c, t) in enumerate(zip(names, start_times)):\n yield (c, t, ind)",
"def build_tiers(self):\n self.tiers = []\n for size in range(1,len(s... | [
"0.594252",
"0.56421316",
"0.5424925",
"0.54007185",
"0.539346",
"0.53655404",
"0.5364286",
"0.5360746",
"0.5349394",
"0.5274494",
"0.52421033",
"0.5217823",
"0.5169063",
"0.516716",
"0.5154065",
"0.51434505",
"0.5137085",
"0.5135831",
"0.5119165",
"0.5110781",
"0.5105052",
... | 0.52542615 | 10 |
Interpola linealmente el valor en el instante t | def __call__(self, t):
c = c1 = c2 = 0
d = d1 = d2 = None
while d1==None or d2==None or d<=d2:
_t = self.time(c)
if _t == None:
break
else:
d = abs(t - _t)
if d1 == None or d<d1:
c1, d1 = c, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_t(self):\n return self.t",
"def get_t_value(self):\n return float(self.data[2]) / 10",
"def Temp(t):\n return 20 # Need to link to data",
"def value(t):\r\n return t(0)",
"def lin_pol_to_TE_TM(field):\n\n pass",
"def __str__(self):\n return str(self.t1)+\"<-->t1,... | [
"0.59880507",
"0.5949386",
"0.58090144",
"0.57953244",
"0.5758886",
"0.57477516",
"0.5688287",
"0.5688287",
"0.56690115",
"0.563481",
"0.5611574",
"0.5603627",
"0.5531453",
"0.5472372",
"0.5468471",
"0.5451955",
"0.5434617",
"0.54339397",
"0.543298",
"0.5397063",
"0.5372944",... | 0.5732259 | 6 |
Arranca el reloj, si ya estaba arrancado no pasa nada. | def arranca(self):
if self.t0 == None:
self.t0 = self.timeFunc()
self.funciona = True
if not self.funciona:
self.retraso += self.timeFunc() - self.parada
self.funciona = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def array(self):",
"def __init__(self,array):\n self.arr = array\n # self.result = []",
"def __init__(self):\n self.arr = []",
"def __init__(self):\n self.arr = []",
"def __init__(self):\n self.arr = []",
"def __init__(self):\n self.arr = []",
"def abrir(self):... | [
"0.58543247",
"0.56239825",
"0.5529206",
"0.5529206",
"0.5529206",
"0.5529206",
"0.545713",
"0.53414357",
"0.52711475",
"0.5228194",
"0.5209801",
"0.52086926",
"0.5190303",
"0.51595616",
"0.5092528",
"0.507765",
"0.50522804",
"0.50134736",
"0.49910116",
"0.49833843",
"0.49538... | 0.5356167 | 7 |
Consulta el tiempo actual. | def __call__(self):
if self.funciona:
t = self.timeFunc() - self.t0 - self.retraso
elif self.t0!=None:
t = self.parada - self.t0 - self.retraso
else:
t = None
return t | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def TempsCotxe(matricula):\n con=lite.connect('parking.db')\n cursor=con.cursor()\n try:\n cursor.execute(\"SELECT (strftime('%s',DATETIME('now'))-strftime('%s',entrada))/60 from parking where id_cotxe=?\",(matricula,))\n row=cursor.fetchone()\n if row:\n if row[0] < 60:\n ... | [
"0.591941",
"0.56388557",
"0.56071705",
"0.556373",
"0.55624765",
"0.5506412",
"0.5460353",
"0.5383823",
"0.5344067",
"0.5318034",
"0.52971244",
"0.5287082",
"0.52630705",
"0.5252758",
"0.5242119",
"0.5242119",
"0.5242119",
"0.5242119",
"0.5242119",
"0.5241725",
"0.5206754",
... | 0.5652158 | 1 |
Mapping a value in a given range to another range | def mapped(val, in_min, in_max, out_min, out_max):
return (val - in_min) * (out_max - out_min) / \
(in_max - in_min) + out_min | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def map_to_range(val, old_min, old_max, new_min, new_max):\n return new_max - (val - old_min) * (new_max - new_min) / (old_max - old_min)",
"def map(value, in_low, in_high, out_low, out_high):\n # example from /animation_nodes/nodes/number/map_range.py\n # if inMin == inMax:\n # newValue = 0\n ... | [
"0.7836962",
"0.7620629",
"0.7571556",
"0.7556224",
"0.7549925",
"0.7233073",
"0.7195118",
"0.7172923",
"0.7053617",
"0.70404553",
"0.70280063",
"0.6952438",
"0.6834101",
"0.68230766",
"0.67514455",
"0.6728961",
"0.67074573",
"0.6705688",
"0.66193485",
"0.6614623",
"0.6611945... | 0.7085316 | 8 |
Terms are equal if their strings are the same | def __eq__(self, other):
return str(self) == str(other) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def distance_unigrams_same(t1, t2):\n t1_terms = make_terms_from_string(t1)\n t2_terms = make_terms_from_string(t2)\n terms1 = set(t1_terms)\n terms2 = set(t2_terms)\n shared_terms = terms1.intersection(terms2)\n #print(shared_terms)\n all_terms = terms1.union(terms2)\n #print(all_terms)\n ... | [
"0.6751587",
"0.6636538",
"0.6448691",
"0.6327863",
"0.62453604",
"0.6222981",
"0.6178543",
"0.59960103",
"0.59914863",
"0.59817404",
"0.5977805",
"0.59240603",
"0.59124815",
"0.59050536",
"0.58854413",
"0.5883479",
"0.5878619",
"0.58726865",
"0.5872482",
"0.5862645",
"0.5845... | 0.0 | -1 |
Determine if it is an atomic term (e.g. "A") or a statement/compound term (e.g. (&&,A,B,..) or (A > B)) or variable term and creates the corresponding Term. | def from_string(cls, term_string):
term_string = term_string.replace(" ", "")
if term_string in cls.term_dict:
return cls.term_dict[term_string]
if term_string[0] == NALSyntax.StatementSyntax.Start.value:
"""
Compound or Statement Term
"""
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_term(s, ctx, mctx, ops):\n s = strip_parens(s.strip())\n if re.search(\"^\\w*$\",s): # If a single word, either a variable or a constant\n if s in ops:\n return Con(ops[s], [], ctx, mctx)\n elif s in ctx:\n return Var(s, ctx, mctx)\n elif s in mctx:\n ... | [
"0.6580291",
"0.61413693",
"0.6123516",
"0.60709804",
"0.6037164",
"0.59499276",
"0.5909678",
"0.57880825",
"0.5784058",
"0.5760817",
"0.5713413",
"0.56021833",
"0.5593748",
"0.556113",
"0.5538992",
"0.550548",
"0.5455731",
"0.5445209",
"0.5441471",
"0.54201454",
"0.5406824",... | 0.72168934 | 0 |
Recursively calculate the syntactic complexity of the compound term. The connector adds 1 complexity, and the subterms syntactic complexities are summed as well. | def _calculate_syntactic_complexity(self):
count = 0
if self.connector is not None:
count = 1 # the term connector
for subterm in self.subterms:
count = count + subterm._calculate_syntactic_complexity()
return count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _calculate_syntactic_complexity(self):\n count = 1 # the copula\n for subterm in self.subterms:\n count = count + subterm._calculate_syntactic_complexity()\n\n return count",
"def _calculate_complexity(workflow):\n complexity = estimate_complexity(workflow.type_, workflow.... | [
"0.7616266",
"0.5851079",
"0.58404595",
"0.5798227",
"0.5710593",
"0.5690459",
"0.5667346",
"0.55477387",
"0.54747677",
"0.5441864",
"0.5319728",
"0.5311709",
"0.52989227",
"0.5249006",
"0.5198195",
"0.51958025",
"0.51696",
"0.51376545",
"0.50467896",
"0.5002992",
"0.4932325"... | 0.79506034 | 0 |
Create a compound term from a string representing a compound term | def from_string(cls, compound_term_string):
compound_term_string = compound_term_string.replace(" ", "")
subterms, connector, intervals = cls.parse_toplevel_subterms_and_connector(compound_term_string)
return cls(subterms, connector,intervals=intervals) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_string(cls, term_string):\n term_string = term_string.replace(\" \", \"\")\n\n if term_string in cls.term_dict:\n return cls.term_dict[term_string]\n\n if term_string[0] == NALSyntax.StatementSyntax.Start.value:\n \"\"\"\n Compound or Statement Ter... | [
"0.7619937",
"0.6340459",
"0.62865704",
"0.622182",
"0.6211368",
"0.6205652",
"0.6153318",
"0.60456955",
"0.58313286",
"0.57834095",
"0.5756795",
"0.5701587",
"0.56921804",
"0.55409914",
"0.5532965",
"0.5528887",
"0.5520905",
"0.54063135",
"0.54001784",
"0.53797454",
"0.53685... | 0.75882727 | 1 |
Parse out all toplevel subterms from a string representing a compound term compound_term_string a string representing a compound term | def parse_toplevel_subterms_and_connector(cls, compound_term_string):
compound_term_string = compound_term_string.replace(" ","")
subterms = []
intervals = []
internal_string = compound_term_string[1:-1] # string with no outer parentheses () or set brackets [], {}
# check for in... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_string(cls, compound_term_string):\n compound_term_string = compound_term_string.replace(\" \", \"\")\n subterms, connector, intervals = cls.parse_toplevel_subterms_and_connector(compound_term_string)\n return cls(subterms, connector,intervals=intervals)",
"def parse(self, string, r... | [
"0.7481961",
"0.6179253",
"0.6024916",
"0.58284104",
"0.58159286",
"0.57567114",
"0.55579245",
"0.54866225",
"0.54343325",
"0.54079",
"0.5405899",
"0.53275555",
"0.53219724",
"0.5318563",
"0.5275198",
"0.5262341",
"0.52378106",
"0.523213",
"0.5202051",
"0.50821346",
"0.507025... | 0.8231147 | 0 |
Recursively calculate the syntactic complexity of the compound term. The connector adds 1 complexity, and the subterms syntactic complexities are summed as well. | def _calculate_syntactic_complexity(self):
count = 1 # the copula
for subterm in self.subterms:
count = count + subterm._calculate_syntactic_complexity()
return count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _calculate_syntactic_complexity(self):\n count = 0\n if self.connector is not None:\n count = 1 # the term connector\n for subterm in self.subterms:\n count = count + subterm._calculate_syntactic_complexity()\n return count",
"def _calculate_complexity(workfl... | [
"0.79503584",
"0.58502394",
"0.5840956",
"0.5799161",
"0.57101554",
"0.569104",
"0.56670165",
"0.55476683",
"0.54750997",
"0.544209",
"0.53206456",
"0.5311971",
"0.5299383",
"0.5250163",
"0.51982045",
"0.51967955",
"0.51698494",
"0.5137146",
"0.50471324",
"0.50033426",
"0.493... | 0.7616813 | 1 |
Returns the term's string with intervals. | def _create_formatted_string_with_interval(self):
if isinstance(self.get_subject_term(),StatementTerm) or isinstance(self.get_subject_term(),CompoundTerm):
string = NALSyntax.StatementSyntax.Start.value + \
self.get_subject_term().get_formatted_string_with_interval()
els... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n value = []\n for term in self.terms:\n value += [term.termname]\n return '<formula: %s>' % ' + '.join(value)",
"def __str__(self):\n value = []\n for term in self.terms:\n value += [term.termname]\n return '<formula: %s>' % ' + ... | [
"0.63082343",
"0.63082343",
"0.6038259",
"0.5892248",
"0.57218105",
"0.5709738",
"0.5613051",
"0.5574001",
"0.5551552",
"0.55436116",
"0.54802537",
"0.5458659",
"0.5458",
"0.54380184",
"0.54280454",
"0.5421883",
"0.5411787",
"0.53858435",
"0.53813004",
"0.53752476",
"0.535993... | 0.71998906 | 0 |
Returns the term's string. This is very important, because terms are compared for equality using this string. | def _create_formatted_string(self):
string = NALSyntax.StatementSyntax.Start.value + \
self.get_subject_term().get_formatted_string()
string += " " + self.get_copula_string() + " "
string += self.get_predicate_term().get_formatted_string() + \
NALSyntax.StatementSyntax.En... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __repr__(self):\n\n return \"<Terms term=%s>\" % (self.word)",
"def __str__(self):\n value = []\n for term in self.terms:\n value += [term.termname]\n return '<formula: %s>' % ' + '.join(value)",
"def __str__(self):\n value = []\n for term in self.terms:... | [
"0.701907",
"0.6807694",
"0.6807694",
"0.63728356",
"0.6359468",
"0.6359468",
"0.6359468",
"0.6359468",
"0.6359468",
"0.6359468",
"0.6359468",
"0.6359468",
"0.6359468",
"0.63586587",
"0.6223569",
"0.6177496",
"0.61670923",
"0.6108228",
"0.6096044",
"0.60886693",
"0.60877323",... | 0.5575014 | 44 |
Simplifies a term and its subterms, using NAL Theorems. | def simplify(term):
simplified_term = term
if isinstance(term,StatementTerm):
simplified_term = StatementTerm(subject_term=simplify(term.get_subject_term()),
predicate_term=simplify(term.get_predicate_term()),
copula=term.get_copula(),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simplify(self, text: str):\n # sanitise the input, remove common words and swap out similar words\n text = self.sanitise(text)\n # Decided not to use stopwords because that would take out too many and then get false positives\n common_words = [\"what\", \"i\", \"you\", \"do\", \"a\"... | [
"0.58145285",
"0.57417417",
"0.5672962",
"0.5574244",
"0.5386782",
"0.52982134",
"0.5281623",
"0.5270715",
"0.5269361",
"0.524937",
"0.5215512",
"0.519514",
"0.5169542",
"0.51584274",
"0.5112584",
"0.5109358",
"0.51056045",
"0.5094979",
"0.5041347",
"0.5013541",
"0.50019133",... | 0.6677275 | 0 |
Get flatParameters note that getParameters and parameters is not equal in this case getParameters do not get parameters of output module | def getParameters(self):
params = []
for m in [self.ix, self.ih, self.fx, self.fh, self.ox, self.oh, self.ux, self.uh]:
# we do not get param of output module
l = list(m.parameters())
params.extend(l)
one_dim = [p.view(p.numel()) for p in params]
para... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flatten_parameters(self):",
"def get_params(self, deep=...):\n ...",
"def get_parameters(self):\n return(_deepcopy(self.parameters))",
"def get_params(self, deep=True):\n return super().get_params(deep=deep)",
"def get_params(self):",
"def flatten_parameters(self):\n self.... | [
"0.73429567",
"0.6564532",
"0.6384027",
"0.6347575",
"0.633167",
"0.6293811",
"0.625885",
"0.62531525",
"0.62531525",
"0.62195283",
"0.62195283",
"0.62195283",
"0.62195283",
"0.62195283",
"0.61976695",
"0.61738086",
"0.6165213",
"0.6111482",
"0.6105472",
"0.60984695",
"0.6077... | 0.63266575 | 5 |
Get flatParameters note that getParameters and parameters is not equal in this case getParameters do not get parameters of output module | def getParameters(self):
params = []
for m in [self.ix, self.ih, self.fx, self.fh, self.ox, self.oh, self.ux, self.uh]:
# we do not get param of output module
l = list(m.parameters())
params.extend(l)
one_dim = [p.view(p.numel()) for p in params]
para... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flatten_parameters(self):",
"def get_params(self, deep=...):\n ...",
"def get_parameters(self):\n return(_deepcopy(self.parameters))",
"def get_params(self, deep=True):\n return super().get_params(deep=deep)",
"def get_params(self):",
"def flatten_parameters(self):\n self.... | [
"0.73429567",
"0.6564532",
"0.6384027",
"0.6347575",
"0.633167",
"0.6293811",
"0.625885",
"0.62531525",
"0.62531525",
"0.62195283",
"0.62195283",
"0.62195283",
"0.62195283",
"0.62195283",
"0.61976695",
"0.61738086",
"0.6165213",
"0.6111482",
"0.6105472",
"0.60984695",
"0.6077... | 0.63266575 | 6 |
Child sum tree LSTM forward function | def forward(self, tree, embs, training = False):
# add singleton dimension for future call to node_forward
# embs = F.torch.unsqueeze(self.emb(inputs),1)
loss = Var(torch.zeros(1)) # init zero loss
if self.cudaFlag:
loss = loss.cuda()
for idx in range(tree.num_chil... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self, xs):\n\n xs = torch.split(xs, self.channel, -1)# list of batch, node, featdim\n xs = torch.stack(xs,2)#[batch, nodes, num_layers, num_channels]\n shape = xs.shape\n x = xs.reshape((-1,shape[2],shape[3])) # [ngraph * num_nodes , num_layers, num_channels]\n alpha... | [
"0.6560829",
"0.6491293",
"0.64687145",
"0.6263219",
"0.6240839",
"0.6211139",
"0.61944425",
"0.61904705",
"0.6172884",
"0.6169751",
"0.616302",
"0.6126835",
"0.60965496",
"0.60779876",
"0.6044476",
"0.6039012",
"0.60056037",
"0.6002348",
"0.5969338",
"0.596877",
"0.5955149",... | 0.6306742 | 3 |
Get c and h of all children | def get_child_states(self, tree):
# add extra singleton dimension in middle...
# because pytorch needs mini batches... :sad:
if tree.num_children==0:
child_c = Var(torch.zeros(1,1,self.mem_dim))
child_h = Var(torch.zeros(1,1,self.mem_dim))
if self.cudaFlag:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Children(self) -> _n_1_t_2:",
"def get_children(self, i, elems):\n # if len(elems) == 1:\n # return []\n # elif self.explored[i]:\n # return self.children[i]\n # else:\n self.children[i], self.children_elems[i] = self._get_children(list(elems)) # all_two_par... | [
"0.6792127",
"0.673864",
"0.6668528",
"0.66547626",
"0.66468894",
"0.6605106",
"0.6564175",
"0.6527869",
"0.6469268",
"0.6447035",
"0.6377662",
"0.6343646",
"0.6330529",
"0.6330529",
"0.6330529",
"0.62940097",
"0.62744546",
"0.6263438",
"0.6258187",
"0.62352306",
"0.62139827"... | 0.6630454 | 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.