\" % elt.co_name\n else:\n yield r","def load_constants():\n with open(VARIABLES_DIR / \"constants.yaml\", \"r\", encoding=\"utf-8\") as stream:\n constants = yaml.safe_load(stream)\n\n return constants","def const(string):\n\n\tconstparams = dict({\n\t\t\t\t\t'kb' : 1.3806e-23,\t# Boltzmann's constant\n\t\t\t\t\t'hbar' : 1.054e-34,\t# Planck's constant\n\t\t\t\t\t'topeta' : 1e15,\t# To peta-\n\t\t\t\t\t'totera' : 1e12,\t# To tera-\n\t\t\t\t\t'togiga' : 1e9,\t# To giga-\n\t\t\t\t\t'tomega' : 1e6,\t# To mega-\n\t\t\t\t\t'tokilo' : 1e3,\t# To kilo-\n\t\t\t\t\t'tocenti' : 1e-2,\t# To centi-\n\t\t\t\t\t'tomilli' : 1e-3,\t# To milli-\n\t\t\t\t\t'tomicro' : 1e-6,\t# To micro-\n\t\t\t\t\t'tonano' : 1e-9,\t# To nano-\n\t\t\t\t\t'topico' : 1e-12,\t# To pico-\n\t\t\t\t\t'tofemto' : 1e-15,\t# To femto-\n\t\t\t\t\t})\n\n\ttry:\n\t\treturn constparams[string]\n\texcept KeyError, e:\n\t\tprint \"KeyError: %s is not a valid key for ntpy.param.const().\" % e\n\t\traise","def get_test_modules_names() -> typing.List[str]:\n\n from services.meter.tests.unit import constants_for_tests\n return constants_for_tests.TESTS_MODULES","def _getConsts(self, imt):\r\n\r\n if (imt != self._pga and imt != self._pgv and imt != self._sa03 and\r\n imt != self._sa10 and imt != self._sa30):\r\n raise ValueError(\"Invalid IMT \" + str(imt))\r\n c = self._constants[imt]\r\n return (c)","def _boilerplate_to_python(indent):\n indent_str = \" \" * indent\n boilerplate = indent_str + \"import core.vba_library\\n\"\n boilerplate = indent_str + \"import core.vba_context\\n\"\n boilerplate += indent_str + \"from core.utils import safe_print\\n\"\n boilerplate += indent_str + \"from core.utils import safe_str_convert\\n\"\n boilerplate += indent_str + \"from core.utils import plus\\n\"\n boilerplate += indent_str + \"from core.utils import eq\\n\"\n boilerplate += indent_str + \"from core.utils import neq\\n\"\n boilerplate += indent_str + \"from core.utils import lt\\n\"\n boilerplate += indent_str + \"from core.utils import lte\\n\"\n boilerplate += indent_str + \"from core.utils import gt\\n\"\n boilerplate += indent_str + \"from core.utils import gte\\n\"\n boilerplate += indent_str + \"import core.utils\\n\"\n boilerplate += indent_str + \"from core.python_jit import update_array\\n\"\n boilerplate += indent_str + \"from core.vba_conversion import coerce_to_num\\n\"\n boilerplate += indent_str + \"from core.vba_conversion import coerce_to_int\\n\"\n boilerplate += indent_str + \"from core.vba_conversion import coerce_to_str\\n\"\n boilerplate += indent_str + \"from core.vba_conversion import coerce_to_int_list\\n\\n\"\n boilerplate += indent_str + \"try:\\n\"\n boilerplate += indent_str + \" \" * 4 + \"vm_context\\n\"\n boilerplate += indent_str + \"except (NameError, UnboundLocalError):\\n\"\n boilerplate += indent_str + \" \" * 4 + \"vm_context = context\\n\"\n return boilerplate","def get_pyxb_namespaces():\n return pyxb.namespace.utility.AvailableNamespaces()","def bpix_kw(bpixtab):\n print('Verifying the header keywords of UVIS bad pixel table {}...'.format(bpixtab))\n print('USEAFTER:')\n print(fits.getheader(bpixtab)['USEAFTER'])\n print(' ')\n print('PEDIGREE:')\n print(fits.getheader(bpixtab)['PEDIGREE'])\n print(' ')\n print('DESCRIP:')\n print(fits.getheader(bpixtab)['DESCRIP'])\n print(' ')\n print('COMMENT:')\n print(fits.getheader(bpixtab)['COMMENT'])\n print(' ')\n print('HISTORY:')\n print(fits.getheader(bpixtab)['HISTORY'])","def _dump_prefix(guard: str) -> List[str]:\n\n return [\n f\"#ifndef {guard}\",\n f\"#define {guard}\",\n \"// <<< Use Configuration Wizard in Context Menu >>>\",\n \"#ifdef USE_APP_CONFIG\",\n '#include \"app_config.h\"',\n \"#endif\"\n ]","def getModuleNames():\n import setup\n names = [e.name[1:] for e in setup.wxpExtensions]\n return names","def _sym_constant(self, table: Mapping[int, str]) -> str:\n try:\n return table[self.sym]\n except KeyError:\n return str(self.sym)","def get_macro(self, name: str) -> str:\n data = struct.pack('<HH{}s'.format(len(name)), 0, len(name), name.encode())\n return self.__intf(2, data)[2:].decode()","def imports():\n for name, val in globals().items():\n if isinstance(val, getattr(types, \"ModuleType\")):\n yield val.__name__","def getOsiVarNames( self ):\n\n if self.osiVarNames:\n return self.osiVarNames.keys()\n \n n = self.adb.get( \"nOsiVars\" )\n for indx in xrange( n ):\n name = self.adb.get( \"osiVarName\",\n indx ) \n self.osiVarNames[ name ]= indx\n\n return self.osiVarNames.keys()","def test_created():\n assert len(dir(constants)) > 300\n assert hasattr(constants, \"Planck_constant\") == True","def getInfoVariableNames(self, product):\r\n return []","def GetHeaderName(name):\n name = os.path.splitext(name)[0] + '.h'\n name = name.replace(os.sep, '/')\n return 'ppapi/c/' + name"],"string":"[\n \"def get_declarations(self):\\n return \\\"extern const unsigned int %s;\\\\n\\\" % self.name\",\n \"def get_calculable_constant_names_latex():\\n return r\\\"t_0\\\", r\\\"S_{rr}\\\", r\\\"S_{r\\\\theta}\\\", r\\\"S_{rz}\\\", r\\\"S_{zz}\\\" \\\\\\n r\\\"\\\\alpha\\\", r\\\"\\\\beta\\\", r\\\"\\\\gamma\\\", r\\\"C_{13}\\\", r\\\"C_{33}\\\", \\\\\\n r\\\"\\\\hat{E}\\\", r\\\"g_1\\\"\",\n \"def _parseKeyNames(lib):\\n _keyNames = {}\\n for attr in dir(lib): # from the modules variables\\n if attr[:6] == 'TCODK_': # get the K_* constants\\n _keyNames[getattr(lib, attr)] = attr[6:] # and make CODE=NAME pairs\\n return _keyNames\",\n \"def get_definitions(self):\\n return \\\"const unsigned int %s = 0x%xu;\\\\n\\\" % (self.name, self.address)\",\n \"def get_consts(self):\\n consts = []\\n for key in self.constants:\\n consts.append({\\n 'key': key,\\n 'value': self.constants[key],\\n })\\n return consts\",\n \"def get_predefined_constant_names_latex():\\n return \\\"t_0/t_g\\\", \\\"t_g\\\", r\\\"\\\\dot{\\\\varepsilon}\\\", \\\\\\n \\\"E_1\\\", \\\"E_3\\\", r\\\"\\\\nu_{21}\\\", r\\\"\\\\nu_{31}\\\"\",\n \"def get_defined_constants():\\n raise NotImplementedError()\",\n \"def consts(consts):\\n\\n namespace = { }\\n\\n for c in consts:\\n constname = c[\\\"constname\\\"]\\n consttype = c[\\\"consttype\\\"]\\n constval = c[\\\"constval\\\"]\\n\\n # Correct various values that won't evaluate in python.\\n if constval == \\\"( SteamItemInstanceID_t ) ~ 0\\\":\\n constval = \\\"-1\\\"\\n elif constval == \\\"( ( uint32 ) 'd' << 16U ) | ( ( uint32 ) 'e' << 8U ) | ( uint32 ) 'v'\\\":\\n constval = \\\"6579574\\\"\\n else:\\n constval = re.sub(r\\\"(0x[0-9a-fA-F]*)ull\\\", r\\\"\\\\1\\\", constval)\\n\\n # Evaluate the result, and place it into the namespace.\\n value = eval(constval, namespace, namespace)\\n namespace[constname] = value\\n\\n # Generate.\\n mapped = map_type(consttype)\\n\\n if value > 0:\\n p(f\\\"{constname} = {mapped}(0x{value:x})\\\")\\n else:\\n p(f\\\"{constname} = {mapped}({value})\\\")\",\n \"def constants(self):\\n return self._constants\",\n \"def get_constants(prefix):\\n return {getattr(socket, name): name \\n for name in dir(socket) if name.startswith(prefix)}\",\n \"def parse_defines(self):\\n for line in self.header.splitlines():\\n if line.lower().startswith(\\\"#define\\\"):\\n _, line = line.strip().split(None, 1) # remove #define\\n if \\\" \\\" in line:\\n symbol, value = line.split(None, 1)\\n if value.isdigit():\\n value = int(value)\\n elif value.startswith(\\\"0x\\\"):\\n value = int(value, 16)\\n elif value in self.types:\\n self.types[symbol] = self.types[value]\\n else:\\n symbol = line\\n value = \\\"\\\"\\n self.constants[symbol] = value\\n return self.constants\",\n \"def get_constants(prefix):\\n return {\\n getattr(socket, n): n\\n for n in dir(socket)\\n if n.startswith(prefix)\\n }\",\n \"def get_constants(prefix):\\n return dict( (getattr(socket, n), n)\\n for n in dir(socket)\\n if n.startswith(prefix)\\n )\",\n \"def gen_cheader(protocol):\\n\\ts = \\\"\\\"\\\"/* Junior Design Sp2018 Final Project\\n * Robot Firmware - RPi <-> Microcontroller Communication\\n * Nick Ames 2018\\n * WARNING: This file is automatically generated by gen-files.py\\n * Any changes you make will be erased.\\n */\\n#include <stdfix.h>\\n#include <stdint.h>\\n#include \\\"config.h\\\"\\n\\n\\\"\\\"\\\"\\n\\ts += \\\"struct comm_data_t {\\\\n\\\"\\n\\tfor r in protocol:\\n\\t\\ts += \\\"\\\\t\\\" + r.size + \\\" \\\" + r.name + \\\"; /* \\\" + r.desc + \\\" */\\\\n\\\"\\n\\ts += \\\"};\\\\n\\\\n\\\"\\n\\tfor r in protocol:\\n\\t\\ts += \\\"%s get_%s(void); /* %s */\\\\n\\\"%(r.size, r.name, r.desc)\\n\\t\\ts += \\\"void set_%s(%s); /* %s */\\\\n\\\\n\\\"%(r.name, r.size, r.desc)\\n\\ts += \\\"\\\"\\\"extern volatile struct comm_data_t Data;\\\"\\\"\\\"\\n\\treturn s\",\n \"def package_macros(self):\\n from re import sub\\n NAME = sub(r'[\\\\.\\\\-\\\\s]', '_', self.name.upper())\\n return [('HAVE_' + NAME, '1')]\",\n \"def compose_defines():\\n return \\\"\\\"\\\"\\nLIBPBDATA_INC ?=../pbdata\\nLIBPBIHDF_INC ?=../hdf\\nLIBBLASR_INC ?=../alignment\\nLIBPBDATA_LIB ?=%(thisdir)s/pbdata/\\nLIBPBIHDF_LIB ?=%(thisdir)s/hdf/\\nLIBBLASR_LIB ?=%(thisdir)s/alignment/\\nnohdf ?=1\\n\\\"\\\"\\\"%(dict(thisdir=thisdir))\",\n \"def include_constants_pi():\\n return f\\\"\\\"\\\"\\n#define PI_F 3.14159274101257f\\n#define PI_2_F 1.57079637050629f\\n#define PI_4_F 0.78539818525314f\\n\\\"\\\"\\\"\",\n \"def get_constants_list(self):\\n return [self.D1, self.D2, self.A1, self.A2, \\\\\\n self.F1, self.F2, self.S12]\",\n \"def get_constants(self):\\n temp = self._properties.get('constants', [])\\n return temp\",\n \"def constants(self):\\n return self.bot.constants\",\n \"def getCDefinesAsString( targetPlatform, targetName ):\\n Any.requireIsTextNonEmpty( targetPlatform )\\n Any.requireIsTextNonEmpty( targetName )\\n\\n fileName = os.path.join( 'build/%s/CMakeFiles/%s.dir/flags.make' %\\n ( targetPlatform, targetName ) )\\n\\n Any.requireIsDirNonEmpty( 'build/%s' % targetPlatform )\\n Any.requireIsFileNonEmpty( fileName )\\n\\n # read-in ground truth information\\n logging.debug( 'parsing %s' % fileName )\\n content = FastScript.getFileContent( fileName, splitLines=True )\\n raw_C = ''\\n raw_CPP = ''\\n raw_C_CFLAGS = ''\\n raw_CPP_CFLAGS = ''\\n regexp_C = re.compile( '^C_DEFINES\\\\s=\\\\s+(.*)$' )\\n regexp_CPP = re.compile( '^CXX_DEFINES\\\\s=\\\\s+(.*)$' )\\n regexp_C_CFLAGS = re.compile( '^C_FLAGS\\\\s=\\\\s+(.*)$' )\\n regexp_CPP_CFLAGS = re.compile( '^CXX_FLAGS\\\\s=\\\\s+(.*)$' )\\n result = ''\\n\\n for line in content:\\n tmp = regexp_C.search( line )\\n\\n if tmp:\\n raw_C = tmp.group( 1 )\\n # logging.debug( 'raw C defines: %s' % raw_C )\\n\\n tmp = regexp_CPP.search( line )\\n\\n if tmp:\\n raw_CPP = tmp.group( 1 )\\n # logging.debug( 'raw CPP defines: %s' % raw_CPP )\\n\\n tmp = regexp_C_CFLAGS.search(line)\\n\\n if tmp:\\n raw_C_CFLAGS = tmp.group(1)\\n\\n tmp = regexp_CPP_CFLAGS.search(line)\\n\\n if tmp:\\n raw_CPP_CFLAGS = tmp.group(1)\\n\\n candidates = ( shlex.split( raw_C ) +\\n shlex.split( raw_CPP ) +\\n shlex.split( raw_C_CFLAGS ) +\\n shlex.split( raw_CPP_CFLAGS ) )\\n\\n for candidate in candidates:\\n if candidate.startswith( '-D' ):\\n result += candidate + ' '\\n\\n return result\",\n \"def load_constants():\\r\\n marker_dictionary = dict()\\r\\n marker_dictionary[\\\"SP\\\"] = SP\\r\\n marker_dictionary[\\\"LCL\\\"] = LCL\\r\\n marker_dictionary[\\\"ARG\\\"] = ARG\\r\\n marker_dictionary[\\\"THIS\\\"] = THIS\\r\\n marker_dictionary[\\\"THAT\\\"] = THAT\\r\\n marker_dictionary[\\\"SCREEN\\\"] = SCREEN\\r\\n marker_dictionary[\\\"KBD\\\"] = KBD\\r\\n for i in range(0, RAM_RESERVE_END):\\r\\n marker_dictionary[\\\"R\\\"+str(i)] = i\\r\\n return marker_dictionary\",\n \"def constants(self):\\n return self._constants\",\n \"def get_constants(self):\\n return self.D1, self.D2, self.A1, self.A2, \\\\\\n self.F1, self.F2, self.S12\",\n \"def list_syms():\\n\\tSymStringVec=[];\\n\\tSymStringVec.append(\\\"CSYM\\\");\\n\\tSymStringVec.append(\\\"DSYM\\\");\\n\\tSymStringVec.append(\\\"TET_SYM\\\");\\n\\tSymStringVec.append(\\\"OCT_SYM\\\");\\n\\tSymStringVec.append(\\\"ICOS_SYM\\\");\\n\\tSymStringVec.append(\\\"ISYM\\\");\\n\\treturn SymStringVec\",\n \"def GetDefineGuardSymbol(file_name):\\n return os.path.basename(file_name).upper().replace('.', '_')\",\n \"def gyp_defines():\\n return dict(arg.split('=', 1)\\n for arg in shlex.split(os.environ.get('GYP_DEFINES', '')))\",\n \"def normalize_const(var_name):\\n return var_name.lower().split('_')\",\n \"def cblas_header_text():\\r\\n\\r\\n return \\\"\\\"\\\"\\r\\n //#include <stddef.h>\\r\\n\\r\\n #undef __BEGIN_DECLS\\r\\n #undef __END_DECLS\\r\\n #ifdef __cplusplus\\r\\n #define __BEGIN_DECLS extern \\\"C\\\" {\\r\\n #define __END_DECLS }\\r\\n #else\\r\\n #define __BEGIN_DECLS /* empty */\\r\\n #define __END_DECLS /* empty */\\r\\n #endif\\r\\n\\r\\n __BEGIN_DECLS\\r\\n\\r\\n #define MOD %\\r\\n\\r\\n /*\\r\\n * Enumerated and derived types\\r\\n */\\r\\n #define CBLAS_INDEX size_t /* this may vary between platforms */\\r\\n\\r\\n enum CBLAS_ORDER {CblasRowMajor=101, CblasColMajor=102};\\r\\n enum CBLAS_TRANSPOSE {CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113};\\r\\n enum CBLAS_UPLO {CblasUpper=121, CblasLower=122};\\r\\n enum CBLAS_DIAG {CblasNonUnit=131, CblasUnit=132};\\r\\n enum CBLAS_SIDE {CblasLeft=141, CblasRight=142};\\r\\n\\r\\n float cblas_sdsdot(const int N, const float alpha, const float *X,\\r\\n const int incX, const float *Y, const int incY);\\r\\n double cblas_dsdot(const int N, const float *X, const int incX, const float *Y,\\r\\n const int incY);\\r\\n float cblas_sdot(const int N, const float *X, const int incX,\\r\\n const float *Y, const int incY);\\r\\n double cblas_ddot(const int N, const double *X, const int incX,\\r\\n const double *Y, const int incY);\\r\\n\\r\\n /*\\r\\n * Functions having prefixes Z and C only\\r\\n */\\r\\n void cblas_cdotu_sub(const int N, const void *X, const int incX,\\r\\n const void *Y, const int incY, void *dotu);\\r\\n void cblas_cdotc_sub(const int N, const void *X, const int incX,\\r\\n const void *Y, const int incY, void *dotc);\\r\\n\\r\\n void cblas_zdotu_sub(const int N, const void *X, const int incX,\\r\\n const void *Y, const int incY, void *dotu);\\r\\n void cblas_zdotc_sub(const int N, const void *X, const int incX,\\r\\n const void *Y, const int incY, void *dotc);\\r\\n\\r\\n\\r\\n /*\\r\\n * Functions having prefixes S D SC DZ\\r\\n */\\r\\n float cblas_snrm2(const int N, const float *X, const int incX);\\r\\n float cblas_sasum(const int N, const float *X, const int incX);\\r\\n\\r\\n double cblas_dnrm2(const int N, const double *X, const int incX);\\r\\n double cblas_dasum(const int N, const double *X, const int incX);\\r\\n\\r\\n float cblas_scnrm2(const int N, const void *X, const int incX);\\r\\n float cblas_scasum(const int N, const void *X, const int incX);\\r\\n\\r\\n double cblas_dznrm2(const int N, const void *X, const int incX);\\r\\n double cblas_dzasum(const int N, const void *X, const int incX);\\r\\n\\r\\n\\r\\n /*\\r\\n * Functions having standard 4 prefixes (S D C Z)\\r\\n */\\r\\n CBLAS_INDEX cblas_isamax(const int N, const float *X, const int incX);\\r\\n CBLAS_INDEX cblas_idamax(const int N, const double *X, const int incX);\\r\\n CBLAS_INDEX cblas_icamax(const int N, const void *X, const int incX);\\r\\n CBLAS_INDEX cblas_izamax(const int N, const void *X, const int incX);\\r\\n\\r\\n /*\\r\\n * ===========================================================================\\r\\n * Prototypes for level 1 BLAS routines\\r\\n * ===========================================================================\\r\\n */\\r\\n\\r\\n /* \\r\\n * Routines with standard 4 prefixes (s, d, c, z)\\r\\n */\\r\\n void cblas_sswap(const int N, float *X, const int incX, \\r\\n float *Y, const int incY);\\r\\n void cblas_scopy(const int N, const float *X, const int incX, \\r\\n float *Y, const int incY);\\r\\n void cblas_saxpy(const int N, const float alpha, const float *X,\\r\\n const int incX, float *Y, const int incY);\\r\\n\\r\\n void cblas_dswap(const int N, double *X, const int incX, \\r\\n double *Y, const int incY);\\r\\n void cblas_dcopy(const int N, const double *X, const int incX, \\r\\n double *Y, const int incY);\\r\\n void cblas_daxpy(const int N, const double alpha, const double *X,\\r\\n const int incX, double *Y, const int incY);\\r\\n\\r\\n void cblas_cswap(const int N, void *X, const int incX, \\r\\n void *Y, const int incY);\\r\\n void cblas_ccopy(const int N, const void *X, const int incX, \\r\\n void *Y, const int incY);\\r\\n void cblas_caxpy(const int N, const void *alpha, const void *X,\\r\\n const int incX, void *Y, const int incY);\\r\\n\\r\\n void cblas_zswap(const int N, void *X, const int incX, \\r\\n void *Y, const int incY);\\r\\n void cblas_zcopy(const int N, const void *X, const int incX, \\r\\n void *Y, const int incY);\\r\\n void cblas_zaxpy(const int N, const void *alpha, const void *X,\\r\\n const int incX, void *Y, const int incY);\\r\\n\\r\\n\\r\\n /* \\r\\n * Routines with S and D prefix only\\r\\n */\\r\\n void cblas_srotg(float *a, float *b, float *c, float *s);\\r\\n void cblas_srotmg(float *d1, float *d2, float *b1, const float b2, float *P);\\r\\n void cblas_srot(const int N, float *X, const int incX,\\r\\n float *Y, const int incY, const float c, const float s);\\r\\n void cblas_srotm(const int N, float *X, const int incX,\\r\\n float *Y, const int incY, const float *P);\\r\\n\\r\\n void cblas_drotg(double *a, double *b, double *c, double *s);\\r\\n void cblas_drotmg(double *d1, double *d2, double *b1, const double b2, double *P);\\r\\n void cblas_drot(const int N, double *X, const int incX,\\r\\n double *Y, const int incY, const double c, const double s);\\r\\n void cblas_drotm(const int N, double *X, const int incX,\\r\\n double *Y, const int incY, const double *P);\\r\\n\\r\\n\\r\\n /* \\r\\n * Routines with S D C Z CS and ZD prefixes\\r\\n */\\r\\n void cblas_sscal(const int N, const float alpha, float *X, const int incX);\\r\\n void cblas_dscal(const int N, const double alpha, double *X, const int incX);\\r\\n void cblas_cscal(const int N, const void *alpha, void *X, const int incX);\\r\\n void cblas_zscal(const int N, const void *alpha, void *X, const int incX);\\r\\n void cblas_csscal(const int N, const float alpha, void *X, const int incX);\\r\\n void cblas_zdscal(const int N, const double alpha, void *X, const int incX);\\r\\n\\r\\n /*\\r\\n * ===========================================================================\\r\\n * Prototypes for level 2 BLAS\\r\\n * ===========================================================================\\r\\n */\\r\\n\\r\\n /* \\r\\n * Routines with standard 4 prefixes (S, D, C, Z)\\r\\n */\\r\\n void cblas_sgemv(const enum CBLAS_ORDER order,\\r\\n const enum CBLAS_TRANSPOSE TransA, const int M, const int N,\\r\\n const float alpha, const float *A, const int lda,\\r\\n const float *X, const int incX, const float beta,\\r\\n float *Y, const int incY);\\r\\n void cblas_sgbmv(const enum CBLAS_ORDER order,\\r\\n const enum CBLAS_TRANSPOSE TransA, const int M, const int N,\\r\\n const int KL, const int KU, const float alpha,\\r\\n const float *A, const int lda, const float *X,\\r\\n const int incX, const float beta, float *Y, const int incY);\\r\\n void cblas_strmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const float *A, const int lda, \\r\\n float *X, const int incX);\\r\\n void cblas_stbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const int K, const float *A, const int lda, \\r\\n float *X, const int incX);\\r\\n void cblas_stpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const float *Ap, float *X, const int incX);\\r\\n void cblas_strsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const float *A, const int lda, float *X,\\r\\n const int incX);\\r\\n void cblas_stbsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const int K, const float *A, const int lda,\\r\\n float *X, const int incX);\\r\\n void cblas_stpsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const float *Ap, float *X, const int incX);\\r\\n\\r\\n void cblas_dgemv(const enum CBLAS_ORDER order,\\r\\n const enum CBLAS_TRANSPOSE TransA, const int M, const int N,\\r\\n const double alpha, const double *A, const int lda,\\r\\n const double *X, const int incX, const double beta,\\r\\n double *Y, const int incY);\\r\\n void cblas_dgbmv(const enum CBLAS_ORDER order,\\r\\n const enum CBLAS_TRANSPOSE TransA, const int M, const int N,\\r\\n const int KL, const int KU, const double alpha,\\r\\n const double *A, const int lda, const double *X,\\r\\n const int incX, const double beta, double *Y, const int incY);\\r\\n void cblas_dtrmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const double *A, const int lda, \\r\\n double *X, const int incX);\\r\\n void cblas_dtbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const int K, const double *A, const int lda, \\r\\n double *X, const int incX);\\r\\n void cblas_dtpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const double *Ap, double *X, const int incX);\\r\\n void cblas_dtrsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const double *A, const int lda, double *X,\\r\\n const int incX);\\r\\n void cblas_dtbsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const int K, const double *A, const int lda,\\r\\n double *X, const int incX);\\r\\n void cblas_dtpsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const double *Ap, double *X, const int incX);\\r\\n\\r\\n void cblas_cgemv(const enum CBLAS_ORDER order,\\r\\n const enum CBLAS_TRANSPOSE TransA, const int M, const int N,\\r\\n const void *alpha, const void *A, const int lda,\\r\\n const void *X, const int incX, const void *beta,\\r\\n void *Y, const int incY);\\r\\n void cblas_cgbmv(const enum CBLAS_ORDER order,\\r\\n const enum CBLAS_TRANSPOSE TransA, const int M, const int N,\\r\\n const int KL, const int KU, const void *alpha,\\r\\n const void *A, const int lda, const void *X,\\r\\n const int incX, const void *beta, void *Y, const int incY);\\r\\n void cblas_ctrmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const void *A, const int lda, \\r\\n void *X, const int incX);\\r\\n void cblas_ctbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const int K, const void *A, const int lda, \\r\\n void *X, const int incX);\\r\\n void cblas_ctpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const void *Ap, void *X, const int incX);\\r\\n void cblas_ctrsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const void *A, const int lda, void *X,\\r\\n const int incX);\\r\\n void cblas_ctbsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const int K, const void *A, const int lda,\\r\\n void *X, const int incX);\\r\\n void cblas_ctpsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const void *Ap, void *X, const int incX);\\r\\n\\r\\n void cblas_zgemv(const enum CBLAS_ORDER order,\\r\\n const enum CBLAS_TRANSPOSE TransA, const int M, const int N,\\r\\n const void *alpha, const void *A, const int lda,\\r\\n const void *X, const int incX, const void *beta,\\r\\n void *Y, const int incY);\\r\\n void cblas_zgbmv(const enum CBLAS_ORDER order,\\r\\n const enum CBLAS_TRANSPOSE TransA, const int M, const int N,\\r\\n const int KL, const int KU, const void *alpha,\\r\\n const void *A, const int lda, const void *X,\\r\\n const int incX, const void *beta, void *Y, const int incY);\\r\\n void cblas_ztrmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const void *A, const int lda, \\r\\n void *X, const int incX);\\r\\n void cblas_ztbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const int K, const void *A, const int lda, \\r\\n void *X, const int incX);\\r\\n void cblas_ztpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const void *Ap, void *X, const int incX);\\r\\n void cblas_ztrsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const void *A, const int lda, void *X,\\r\\n const int incX);\\r\\n void cblas_ztbsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const int K, const void *A, const int lda,\\r\\n void *X, const int incX);\\r\\n void cblas_ztpsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,\\r\\n const int N, const void *Ap, void *X, const int incX);\\r\\n\\r\\n\\r\\n /* \\r\\n * Routines with S and D prefixes only\\r\\n */\\r\\n void cblas_ssymv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const float alpha, const float *A,\\r\\n const int lda, const float *X, const int incX,\\r\\n const float beta, float *Y, const int incY);\\r\\n void cblas_ssbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const int K, const float alpha, const float *A,\\r\\n const int lda, const float *X, const int incX,\\r\\n const float beta, float *Y, const int incY);\\r\\n void cblas_sspmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const float alpha, const float *Ap,\\r\\n const float *X, const int incX,\\r\\n const float beta, float *Y, const int incY);\\r\\n void cblas_sger(const enum CBLAS_ORDER order, const int M, const int N,\\r\\n const float alpha, const float *X, const int incX,\\r\\n const float *Y, const int incY, float *A, const int lda);\\r\\n void cblas_ssyr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const float alpha, const float *X,\\r\\n const int incX, float *A, const int lda);\\r\\n void cblas_sspr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const float alpha, const float *X,\\r\\n const int incX, float *Ap);\\r\\n void cblas_ssyr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const float alpha, const float *X,\\r\\n const int incX, const float *Y, const int incY, float *A,\\r\\n const int lda);\\r\\n void cblas_sspr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const float alpha, const float *X,\\r\\n const int incX, const float *Y, const int incY, float *A);\\r\\n\\r\\n void cblas_dsymv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const double alpha, const double *A,\\r\\n const int lda, const double *X, const int incX,\\r\\n const double beta, double *Y, const int incY);\\r\\n void cblas_dsbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const int K, const double alpha, const double *A,\\r\\n const int lda, const double *X, const int incX,\\r\\n const double beta, double *Y, const int incY);\\r\\n void cblas_dspmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const double alpha, const double *Ap,\\r\\n const double *X, const int incX,\\r\\n const double beta, double *Y, const int incY);\\r\\n void cblas_dger(const enum CBLAS_ORDER order, const int M, const int N,\\r\\n const double alpha, const double *X, const int incX,\\r\\n const double *Y, const int incY, double *A, const int lda);\\r\\n void cblas_dsyr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const double alpha, const double *X,\\r\\n const int incX, double *A, const int lda);\\r\\n void cblas_dspr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const double alpha, const double *X,\\r\\n const int incX, double *Ap);\\r\\n void cblas_dsyr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const double alpha, const double *X,\\r\\n const int incX, const double *Y, const int incY, double *A,\\r\\n const int lda);\\r\\n void cblas_dspr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const double alpha, const double *X,\\r\\n const int incX, const double *Y, const int incY, double *A);\\r\\n\\r\\n\\r\\n /* \\r\\n * Routines with C and Z prefixes only\\r\\n */\\r\\n void cblas_chemv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const void *alpha, const void *A,\\r\\n const int lda, const void *X, const int incX,\\r\\n const void *beta, void *Y, const int incY);\\r\\n void cblas_chbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const int K, const void *alpha, const void *A,\\r\\n const int lda, const void *X, const int incX,\\r\\n const void *beta, void *Y, const int incY);\\r\\n void cblas_chpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const void *alpha, const void *Ap,\\r\\n const void *X, const int incX,\\r\\n const void *beta, void *Y, const int incY);\\r\\n void cblas_cgeru(const enum CBLAS_ORDER order, const int M, const int N,\\r\\n const void *alpha, const void *X, const int incX,\\r\\n const void *Y, const int incY, void *A, const int lda);\\r\\n void cblas_cgerc(const enum CBLAS_ORDER order, const int M, const int N,\\r\\n const void *alpha, const void *X, const int incX,\\r\\n const void *Y, const int incY, void *A, const int lda);\\r\\n void cblas_cher(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const float alpha, const void *X, const int incX,\\r\\n void *A, const int lda);\\r\\n void cblas_chpr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const float alpha, const void *X,\\r\\n const int incX, void *A);\\r\\n void cblas_cher2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N,\\r\\n const void *alpha, const void *X, const int incX,\\r\\n const void *Y, const int incY, void *A, const int lda);\\r\\n void cblas_chpr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N,\\r\\n const void *alpha, const void *X, const int incX,\\r\\n const void *Y, const int incY, void *Ap);\\r\\n\\r\\n void cblas_zhemv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const void *alpha, const void *A,\\r\\n const int lda, const void *X, const int incX,\\r\\n const void *beta, void *Y, const int incY);\\r\\n void cblas_zhbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const int K, const void *alpha, const void *A,\\r\\n const int lda, const void *X, const int incX,\\r\\n const void *beta, void *Y, const int incY);\\r\\n void cblas_zhpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const void *alpha, const void *Ap,\\r\\n const void *X, const int incX,\\r\\n const void *beta, void *Y, const int incY);\\r\\n void cblas_zgeru(const enum CBLAS_ORDER order, const int M, const int N,\\r\\n const void *alpha, const void *X, const int incX,\\r\\n const void *Y, const int incY, void *A, const int lda);\\r\\n void cblas_zgerc(const enum CBLAS_ORDER order, const int M, const int N,\\r\\n const void *alpha, const void *X, const int incX,\\r\\n const void *Y, const int incY, void *A, const int lda);\\r\\n void cblas_zher(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const double alpha, const void *X, const int incX,\\r\\n void *A, const int lda);\\r\\n void cblas_zhpr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,\\r\\n const int N, const double alpha, const void *X,\\r\\n const int incX, void *A);\\r\\n void cblas_zher2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N,\\r\\n const void *alpha, const void *X, const int incX,\\r\\n const void *Y, const int incY, void *A, const int lda);\\r\\n void cblas_zhpr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N,\\r\\n const void *alpha, const void *X, const int incX,\\r\\n const void *Y, const int incY, void *Ap);\\r\\n\\r\\n /*\\r\\n * ===========================================================================\\r\\n * Prototypes for level 3 BLAS\\r\\n * ===========================================================================\\r\\n */\\r\\n\\r\\n /* \\r\\n * Routines with standard 4 prefixes (S, D, C, Z)\\r\\n */\\r\\n void cblas_sgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA,\\r\\n const enum CBLAS_TRANSPOSE TransB, const int M, const int N,\\r\\n const int K, const float alpha, const float *A,\\r\\n const int lda, const float *B, const int ldb,\\r\\n const float beta, float *C, const int ldc);\\r\\n void cblas_ssymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side,\\r\\n const enum CBLAS_UPLO Uplo, const int M, const int N,\\r\\n const float alpha, const float *A, const int lda,\\r\\n const float *B, const int ldb, const float beta,\\r\\n float *C, const int ldc);\\r\\n void cblas_ssyrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE Trans, const int N, const int K,\\r\\n const float alpha, const float *A, const int lda,\\r\\n const float beta, float *C, const int ldc);\\r\\n void cblas_ssyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE Trans, const int N, const int K,\\r\\n const float alpha, const float *A, const int lda,\\r\\n const float *B, const int ldb, const float beta,\\r\\n float *C, const int ldc);\\r\\n void cblas_strmm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side,\\r\\n const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA,\\r\\n const enum CBLAS_DIAG Diag, const int M, const int N,\\r\\n const float alpha, const float *A, const int lda,\\r\\n float *B, const int ldb);\\r\\n void cblas_strsm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side,\\r\\n const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA,\\r\\n const enum CBLAS_DIAG Diag, const int M, const int N,\\r\\n const float alpha, const float *A, const int lda,\\r\\n float *B, const int ldb);\\r\\n\\r\\n void cblas_dgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA,\\r\\n const enum CBLAS_TRANSPOSE TransB, const int M, const int N,\\r\\n const int K, const double alpha, const double *A,\\r\\n const int lda, const double *B, const int ldb,\\r\\n const double beta, double *C, const int ldc);\\r\\n void cblas_dsymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side,\\r\\n const enum CBLAS_UPLO Uplo, const int M, const int N,\\r\\n const double alpha, const double *A, const int lda,\\r\\n const double *B, const int ldb, const double beta,\\r\\n double *C, const int ldc);\\r\\n void cblas_dsyrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE Trans, const int N, const int K,\\r\\n const double alpha, const double *A, const int lda,\\r\\n const double beta, double *C, const int ldc);\\r\\n void cblas_dsyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE Trans, const int N, const int K,\\r\\n const double alpha, const double *A, const int lda,\\r\\n const double *B, const int ldb, const double beta,\\r\\n double *C, const int ldc);\\r\\n void cblas_dtrmm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side,\\r\\n const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA,\\r\\n const enum CBLAS_DIAG Diag, const int M, const int N,\\r\\n const double alpha, const double *A, const int lda,\\r\\n double *B, const int ldb);\\r\\n void cblas_dtrsm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side,\\r\\n const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA,\\r\\n const enum CBLAS_DIAG Diag, const int M, const int N,\\r\\n const double alpha, const double *A, const int lda,\\r\\n double *B, const int ldb);\\r\\n\\r\\n void cblas_cgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA,\\r\\n const enum CBLAS_TRANSPOSE TransB, const int M, const int N,\\r\\n const int K, const void *alpha, const void *A,\\r\\n const int lda, const void *B, const int ldb,\\r\\n const void *beta, void *C, const int ldc);\\r\\n void cblas_csymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side,\\r\\n const enum CBLAS_UPLO Uplo, const int M, const int N,\\r\\n const void *alpha, const void *A, const int lda,\\r\\n const void *B, const int ldb, const void *beta,\\r\\n void *C, const int ldc);\\r\\n void cblas_csyrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE Trans, const int N, const int K,\\r\\n const void *alpha, const void *A, const int lda,\\r\\n const void *beta, void *C, const int ldc);\\r\\n void cblas_csyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE Trans, const int N, const int K,\\r\\n const void *alpha, const void *A, const int lda,\\r\\n const void *B, const int ldb, const void *beta,\\r\\n void *C, const int ldc);\\r\\n void cblas_ctrmm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side,\\r\\n const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA,\\r\\n const enum CBLAS_DIAG Diag, const int M, const int N,\\r\\n const void *alpha, const void *A, const int lda,\\r\\n void *B, const int ldb);\\r\\n void cblas_ctrsm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side,\\r\\n const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA,\\r\\n const enum CBLAS_DIAG Diag, const int M, const int N,\\r\\n const void *alpha, const void *A, const int lda,\\r\\n void *B, const int ldb);\\r\\n\\r\\n void cblas_zgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA,\\r\\n const enum CBLAS_TRANSPOSE TransB, const int M, const int N,\\r\\n const int K, const void *alpha, const void *A,\\r\\n const int lda, const void *B, const int ldb,\\r\\n const void *beta, void *C, const int ldc);\\r\\n void cblas_zsymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side,\\r\\n const enum CBLAS_UPLO Uplo, const int M, const int N,\\r\\n const void *alpha, const void *A, const int lda,\\r\\n const void *B, const int ldb, const void *beta,\\r\\n void *C, const int ldc);\\r\\n void cblas_zsyrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE Trans, const int N, const int K,\\r\\n const void *alpha, const void *A, const int lda,\\r\\n const void *beta, void *C, const int ldc);\\r\\n void cblas_zsyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE Trans, const int N, const int K,\\r\\n const void *alpha, const void *A, const int lda,\\r\\n const void *B, const int ldb, const void *beta,\\r\\n void *C, const int ldc);\\r\\n void cblas_ztrmm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side,\\r\\n const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA,\\r\\n const enum CBLAS_DIAG Diag, const int M, const int N,\\r\\n const void *alpha, const void *A, const int lda,\\r\\n void *B, const int ldb);\\r\\n void cblas_ztrsm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side,\\r\\n const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA,\\r\\n const enum CBLAS_DIAG Diag, const int M, const int N,\\r\\n const void *alpha, const void *A, const int lda,\\r\\n void *B, const int ldb);\\r\\n\\r\\n\\r\\n /* \\r\\n * Routines with prefixes C and Z only\\r\\n */\\r\\n void cblas_chemm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side,\\r\\n const enum CBLAS_UPLO Uplo, const int M, const int N,\\r\\n const void *alpha, const void *A, const int lda,\\r\\n const void *B, const int ldb, const void *beta,\\r\\n void *C, const int ldc);\\r\\n void cblas_cherk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE Trans, const int N, const int K,\\r\\n const float alpha, const void *A, const int lda,\\r\\n const float beta, void *C, const int ldc);\\r\\n void cblas_cher2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE Trans, const int N, const int K,\\r\\n const void *alpha, const void *A, const int lda,\\r\\n const void *B, const int ldb, const float beta,\\r\\n void *C, const int ldc);\\r\\n\\r\\n void cblas_zhemm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side,\\r\\n const enum CBLAS_UPLO Uplo, const int M, const int N,\\r\\n const void *alpha, const void *A, const int lda,\\r\\n const void *B, const int ldb, const void *beta,\\r\\n void *C, const int ldc);\\r\\n void cblas_zherk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE Trans, const int N, const int K,\\r\\n const double alpha, const void *A, const int lda,\\r\\n const double beta, void *C, const int ldc);\\r\\n void cblas_zher2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,\\r\\n const enum CBLAS_TRANSPOSE Trans, const int N, const int K,\\r\\n const void *alpha, const void *A, const int lda,\\r\\n const void *B, const int ldb, const double beta,\\r\\n void *C, const int ldc);\\r\\n\\r\\n void cblas_xerbla(int p, const char *rout, const char *form, ...);\\r\\n\\r\\n __END_DECLS\\r\\n \\\"\\\"\\\"\",\n \"def get_platform_und_symbols():\\n ret = None\\n if osname_is_freebsd():\\n ret = sorted([\\\"environ\\\", \\\"__progname\\\"])\\n if is_verbose():\\n print(\\\"Checking for required UND symbols... \\\" + str(ret))\\n return ret\",\n \"def getcodedesc(code_):\\n symname_ = (ctypes.c_char * value.max_str_len)()\\n str_ = (ctypes.c_char * value.max_str_len)()\\n res = __library__.MSK_XX_getcodedesc(code_,symname_,str_)\\n if res != 0:\\n raise Error(rescode(res),Env.getcodedesc(rescode(res))[1])\\n _symname_retval = symname_.value.decode(\\\"utf-8\\\",errors=\\\"replace\\\")\\n _str_retval = str_.value.decode(\\\"utf-8\\\",errors=\\\"replace\\\")\\n return (_symname_retval,_str_retval)\",\n \"def getCDefinesAsList( targetPlatform, targetName ):\\n Any.requireIsTextNonEmpty( targetPlatform )\\n Any.requireIsTextNonEmpty( targetName )\\n\\n result = []\\n regexp = re.compile( '-D\\\\s*(.*)' )\\n\\n for token in getCDefinesAsString( targetPlatform, targetName ).split():\\n\\n if token.startswith( '-D' ):\\n tmp = regexp.search( token )\\n item = (tmp.group(1)).strip()\\n result.append( item )\\n\\n return frozenset(result)\",\n \"def extract_constants(func):\\n const_dict = {}\\n params = len(func.params)\\n new_func, consts = ExtractConstants().extract_constants(func)\\n for i, const in enumerate(consts):\\n const_dict[params + i] = const\\n\\n new_func = tvm.relay.transform.InferType()(tvm.IRModule.from_expr(new_func))[\\\"main\\\"]\\n return new_func, const_dict\",\n \"def get_constant(name, libgmt):\\n c_get_enum = libgmt.GMT_Get_Enum\\n c_get_enum.argtypes = [ctypes.c_char_p]\\n c_get_enum.restype = ctypes.c_int\\n\\n value = c_get_enum(name.encode())\\n\\n if value is None or value == -99999:\\n raise GMTCLibError(\\n \\\"Constant '{}' doesn't exits in libgmt.\\\".format(name))\\n\\n return value\",\n \"def t_CCONST(t):\\n return t\",\n \"def get_addon_consts(self) -> Dict[str, str]:\\n from azure.cli.command_modules.acs._consts import (\\n ADDONS, CONST_ACC_SGX_QUOTE_HELPER_ENABLED,\\n CONST_AZURE_KEYVAULT_SECRETS_PROVIDER_ADDON_NAME,\\n CONST_AZURE_POLICY_ADDON_NAME, CONST_CONFCOM_ADDON_NAME,\\n CONST_HTTP_APPLICATION_ROUTING_ADDON_NAME,\\n CONST_INGRESS_APPGW_ADDON_NAME,\\n CONST_INGRESS_APPGW_APPLICATION_GATEWAY_ID,\\n CONST_INGRESS_APPGW_APPLICATION_GATEWAY_NAME,\\n CONST_INGRESS_APPGW_SUBNET_CIDR, CONST_INGRESS_APPGW_SUBNET_ID,\\n CONST_INGRESS_APPGW_WATCH_NAMESPACE,\\n CONST_KUBE_DASHBOARD_ADDON_NAME, CONST_MONITORING_ADDON_NAME,\\n CONST_MONITORING_LOG_ANALYTICS_WORKSPACE_RESOURCE_ID,\\n CONST_MONITORING_USING_AAD_MSI_AUTH,\\n CONST_OPEN_SERVICE_MESH_ADDON_NAME, CONST_ROTATION_POLL_INTERVAL,\\n CONST_SECRET_ROTATION_ENABLED, CONST_VIRTUAL_NODE_ADDON_NAME,\\n CONST_VIRTUAL_NODE_SUBNET_NAME)\\n\\n addon_consts = {}\\n addon_consts[\\\"ADDONS\\\"] = ADDONS\\n addon_consts[\\n \\\"CONST_ACC_SGX_QUOTE_HELPER_ENABLED\\\"\\n ] = CONST_ACC_SGX_QUOTE_HELPER_ENABLED\\n addon_consts[\\n \\\"CONST_AZURE_POLICY_ADDON_NAME\\\"\\n ] = CONST_AZURE_POLICY_ADDON_NAME\\n addon_consts[\\\"CONST_CONFCOM_ADDON_NAME\\\"] = CONST_CONFCOM_ADDON_NAME\\n addon_consts[\\n \\\"CONST_HTTP_APPLICATION_ROUTING_ADDON_NAME\\\"\\n ] = CONST_HTTP_APPLICATION_ROUTING_ADDON_NAME\\n addon_consts[\\n \\\"CONST_INGRESS_APPGW_ADDON_NAME\\\"\\n ] = CONST_INGRESS_APPGW_ADDON_NAME\\n addon_consts[\\n \\\"CONST_INGRESS_APPGW_APPLICATION_GATEWAY_ID\\\"\\n ] = CONST_INGRESS_APPGW_APPLICATION_GATEWAY_ID\\n addon_consts[\\n \\\"CONST_INGRESS_APPGW_APPLICATION_GATEWAY_NAME\\\"\\n ] = CONST_INGRESS_APPGW_APPLICATION_GATEWAY_NAME\\n addon_consts[\\n \\\"CONST_INGRESS_APPGW_SUBNET_CIDR\\\"\\n ] = CONST_INGRESS_APPGW_SUBNET_CIDR\\n addon_consts[\\n \\\"CONST_INGRESS_APPGW_SUBNET_ID\\\"\\n ] = CONST_INGRESS_APPGW_SUBNET_ID\\n addon_consts[\\n \\\"CONST_INGRESS_APPGW_WATCH_NAMESPACE\\\"\\n ] = CONST_INGRESS_APPGW_WATCH_NAMESPACE\\n addon_consts[\\n \\\"CONST_KUBE_DASHBOARD_ADDON_NAME\\\"\\n ] = CONST_KUBE_DASHBOARD_ADDON_NAME\\n addon_consts[\\n \\\"CONST_MONITORING_ADDON_NAME\\\"\\n ] = CONST_MONITORING_ADDON_NAME\\n addon_consts[\\n \\\"CONST_MONITORING_LOG_ANALYTICS_WORKSPACE_RESOURCE_ID\\\"\\n ] = CONST_MONITORING_LOG_ANALYTICS_WORKSPACE_RESOURCE_ID\\n addon_consts[\\n \\\"CONST_OPEN_SERVICE_MESH_ADDON_NAME\\\"\\n ] = CONST_OPEN_SERVICE_MESH_ADDON_NAME\\n addon_consts[\\n \\\"CONST_VIRTUAL_NODE_ADDON_NAME\\\"\\n ] = CONST_VIRTUAL_NODE_ADDON_NAME\\n addon_consts[\\n \\\"CONST_VIRTUAL_NODE_SUBNET_NAME\\\"\\n ] = CONST_VIRTUAL_NODE_SUBNET_NAME\\n addon_consts[\\n \\\"CONST_AZURE_KEYVAULT_SECRETS_PROVIDER_ADDON_NAME\\\"\\n ] = CONST_AZURE_KEYVAULT_SECRETS_PROVIDER_ADDON_NAME\\n addon_consts[\\n \\\"CONST_SECRET_ROTATION_ENABLED\\\"\\n ] = CONST_SECRET_ROTATION_ENABLED\\n addon_consts[\\n \\\"CONST_ROTATION_POLL_INTERVAL\\\"\\n ] = CONST_ROTATION_POLL_INTERVAL\\n\\n addon_consts[\\n \\\"CONST_MONITORING_USING_AAD_MSI_AUTH\\\"\\n ] = CONST_MONITORING_USING_AAD_MSI_AUTH\\n return addon_consts\",\n \"def get_all_constants():\\n return filter(\\n lambda key: key.upper() == key and type(globals()[key]) in _ALLOWED,\\n\\n filter( # filter _PRIVATE variables\\n lambda x: not x.startswith(\\\"_\\\"),\\n globals()\\n )\\n )\",\n \"def get_checked_define_files(self):\\n return (self._files['src/config.h'],\\n self._files['src/gromacs/simd/simd.h'],\\n self._files['src/gromacs/ewald/pme_simd.h'],\\n self._files['src/gromacs/nbnxm/nbnxm_simd.h'])\",\n \"def get_symbols(self):\\n symbols = os.environ.get('SYMBOLS', 'btc,eth')\\n if not symbols:\\n return 'btc,eth'\\n return symbols\",\n \"def r_consts(size, used=None):\\n return r_symbols(size, CONST_SYMBOLS, ARGS.constant_length, used)\",\n \"def get_strings():\\n import re\\n import pathlib\\n\\n # the absolute path to the root directory\\n rootdir = pathlib.Path(__file__).resolve().parent\\n\\n # read README.md and overwrite readme\\n with open(rootdir.joinpath(\\\"README.md\\\"), 'r') as f:\\n readme = f.read()\\n\\n # read __init__.py\\n with open(rootdir.joinpath(\\\"yasynccli\\\", \\\"__init__.py\\\"), 'r') as f:\\n content = f.read()\\n\\n # version\\n version = re.search(\\\"__version__\\\\s*?=\\\\s*?(?P<version>\\\\S+?)$\\\", content, re.MULTILINE)\\n version = version.group(\\\"version\\\").strip(\\\"\\\\\\\"\\\\'\\\")\\n\\n # desc\\n desc = re.search(\\\"^\\\\\\\"\\\\\\\"\\\\\\\"(?P<desc>\\\\S.*?)$\\\", content, re.MULTILINE)\\n desc = desc.group(\\\"desc\\\")\\n\\n return version, desc, readme\",\n \"def _get_wgpu_header(*filenames):\\n # Read files\\n lines1 = []\\n for filename in filenames:\\n with open(filename) as f:\\n lines1.extend(f.readlines())\\n # Deal with pre-processor commands, because cffi cannot handle them.\\n # Just removing them, plus a few extra lines, seems to do the trick.\\n lines2 = []\\n for line in lines1:\\n if line.startswith(\\\"#\\\"):\\n continue\\n elif 'extern \\\"C\\\"' in line:\\n continue\\n line = line.replace(\\\"WGPU_EXPORT \\\", \\\"\\\")\\n lines2.append(line)\\n return \\\"\\\".join(lines2)\",\n \"def print_const(consts):\\n for const in consts:\\n print ' ',\\n change_color_by_tag(const)\\n print '{TYPE}'.format(TYPE=const['Type']),\\n print '{NAME}'.format(NAME=const['Name']),\\n print '={VALUE}'.format(VALUE=const['Value'])\",\n \"def get_candidate_names():\\n suffix = get_sharedlib_suffix()\\n LDLIBRARY = sysconfig.get_config_var(\\\"LDLIBRARY\\\")\\n if LDLIBRARY:\\n yield LDLIBRARY\\n\\n LIBRARY = sysconfig.get_config_var(\\\"LIBRARY\\\")\\n if LIBRARY:\\n yield os.path.splitext(LIBRARY)[0] + suffix\\n\\n dlprefix = \\\"\\\" if is_windows() else \\\"lib\\\"\\n sysdata = dict(\\n v=sys.version_info,\\n # VERSION is X.Y in Linux/macOS and XY in Windows:\\n VERSION=(sysconfig.get_config_var(\\\"VERSION\\\") or\\n \\\"{v.major}.{v.minor}\\\".format(v=sys.version_info)),\\n ABIFLAGS=(sysconfig.get_config_var(\\\"ABIFLAGS\\\") or\\n sysconfig.get_config_var(\\\"abiflags\\\") or \\\"\\\"),\\n )\\n\\n for stem in (\\n \\\"python{VERSION}{ABIFLAGS}\\\".format(**sysdata),\\n \\\"python{VERSION}\\\".format(**sysdata),\\n \\\"python{v.major}\\\".format(**sysdata),\\n \\\"python\\\"\\n ):\\n yield dlprefix + stem + suffix\",\n \"def getNameCode( self ):\\r\\n constTuple = self.getValue()\\r\\n if( constTuple[4] == None ): return [ constTuple[0], None ]\\r\\n return [ constTuple[0], strip( constTuple[4] ) ]\",\n \"def generate_rename_tabled(self, prefix):\\n return \\\"#define %s%s g_symbol_table.%s\\\" % (prefix, self.__name, self.__name)\",\n \"def getHeadersFromSWIG (filename):\\n stream = open(filename)\\n lines = stream.readlines()\\n stream.close()\\n\\n lines = [line for line in lines if line.strip().startswith('%include')]\\n lines = [line for line in lines if line.strip().endswith('.h')]\\n return [line.replace('%include', '').strip() for line in lines]\",\n \"def GetIndexFileHeaderText(headerinfo):#{{{\\n (dbname, version, ext, prefix) = headerinfo\\n indexFileHeaderText = []\\n indexFileHeaderText.append(\\\"DEF_VERSION %s\\\"%(version))\\n indexFileHeaderText.append(\\\"DEF_DBNAME %s\\\"%(dbname))\\n indexFileHeaderText.append(\\\"DEF_EXTENSION %s\\\"%(ext))\\n indexFileHeaderText.append(\\\"DEF_PREFIX %s\\\"%(prefix))\\n return indexFileHeaderText\",\n \"def get_name_with_lib(datablock):\\r\\n text = datablock.name\\r\\n if datablock.library:\\r\\n # text += ' (Lib: \\\"%s\\\")' % datablock.library.name\\r\\n text = \\\"L \\\" + text\\r\\n return text\",\n \"def save_all_consts_to_memory():\\n for key, value in symbol_table.dict.items():\\n if value[2] is not None:\\n save_to_memory(\\\"a\\\", \\\"b\\\", value[5], value[2])\\n # assembler_generator.add_comment(\\\"# consts saved to memory\\\")\",\n \"def parseNames(self, compiledCode):\\n res = []\\n if not compiledCode is None:\\n res = compiledCode.co_names\\n for co in compiledCode.co_consts:\\n if not co is None and isinstance(co, CodeType):\\n res += co.co_names\\n return res\",\n \"def get_schema_defs():\\n return SCHEMA_DEFS\",\n \"def GetHeaderGuardCPPVariable(fn, filename):\\n var_parts = list()\\n head = filename\\n while head:\\n head, tail = os.path.split(head)\\n var_parts.insert(0, tail)\\n if head.endswith('include') or os.path.exists(os.path.join(head, \\\"package.xml\\\")) or tail == \\\"\\\":\\n break\\n return re.sub(r'[-./\\\\s]', '_', \\\"_\\\".join(var_parts)).upper()\",\n \"def test_cime_constants(e3sm_tag='master'):\\n\\n resp = requests.get(\\n f'https://raw.githubusercontent.com/E3SM-Project/E3SM/{e3sm_tag}/'\\n f'share/util/shr_const_mod.F90')\\n\\n text = resp.text\\n\\n text = text.split('\\\\n')\\n\\n found = {}\\n for constant in constants:\\n found[constant] = False\\n\\n for line in text:\\n constant, value = _parse_value(line)\\n if constant is None:\\n continue\\n print(f'line: {line}')\\n print(f'parsed: {constant} = {value}')\\n if constant in constants:\\n if isinstance(value, float):\\n print('verifying {}'.format(constant))\\n assert value == constants[constant]\\n else:\\n print('skipping verification for {}'.format(constant))\\n\\n found[constant] = True\\n else:\\n print('not in constants')\\n\\n print('')\\n\\n all_found = True\\n for constant in found:\\n if not found[constant]:\\n print('{} was not found!'.format(constant))\\n all_found = False\\n\\n assert all_found\",\n \"def gen_get_const_table(cls, names, p, const_p):\\n s = \\\"// Store constant table for {p} to {const_p}\\\\n\\\".format(\\n const_p = const_p, p = p\\n ) \\n s += \\\"{c} = {t}[(((({p}) + 1) * {mul}) >> 8) & 7];\\\\n\\\".format(\\n c = const_p, p = p, t = names[cls.T_NAME],\\n mul = cls.deBruijnMult\\n )\\n return s\",\n \"def update_protocol(filename='../server/Protocol.h'):\\n f = open(filename, 'r')\\n for line in f.readlines():\\n l = list(filter(None, line.split(' ')))\\n if l[0] == '#define' and len(l) == 3:\\n print(l[1] + '=' + l[2][:-1])\",\n \"def get_macros(self):\\n return LEVELS.keys()\",\n \"def loaded_modules() -> List[str]:\\n return PYSTAC_IO.keys()\",\n \"def get_all_d_module_info():\\n a_local_var = 'this is local variable'\\n zzz = 5\",\n \"def _get_attrs_symbols():\\n return {\\n 'True', 'False', 'None', # those are identifiers in Python 2.7\\n 'self',\\n 'parent',\\n 'id',\\n 'uid',\\n 'context',\\n 'context_today',\\n 'active_id',\\n 'active_ids',\\n 'allowed_company_ids',\\n 'current_company_id',\\n 'active_model',\\n 'time',\\n 'datetime',\\n 'relativedelta',\\n 'current_date',\\n 'abs',\\n 'len',\\n 'bool',\\n 'float',\\n 'str',\\n 'unicode',\\n }\",\n \"def _parse_col_constants() -> Dict[str, List[str]]:\\n\\n col_type_map = {\\n k: [] for k in TEST_ARGUMENT_DATA_TYPES.keys()\\n }\\n return col_type_map\",\n \"def get_glib_cflags():\\n\\tpkgcmd = os.popen(pkg_config_path +\\n ' pkg-config --cflags glib-2.0', 'r')\\n pkgcmd_text = pkgcmd.read()\\n pkgcmd.close()\\n\\tincludes = pkgcmd_text.split()\\n\\tfor x in range(len(includes)):\\n\\t\\tincludes[x] = includes[x][2:]\\n\\t\\t\\n\\treturn includes\",\n \"def getMibSymbol(self):\\n if self.__state & self.stClean:\\n return self.__modName, self.__symName, self.__indices\\n else:\\n raise SmiError('%s object not fully initialized' % self.__class__.__name__)\",\n \"def generateColumnConsts(data):\\n\\n model = data[\\\"model\\\"]\\n global c_col\\n global col_prefix\\n global col_count\\n col_prefix = \\\"COL_%s\\\" % model[\\\"name\\\"].upper()\\n col_count = 0\\n for field in data[\\\"fields\\\"]:\\n if not field.has_key(\\\"head\\\"):\\n continue\\n try:\\n c_col.append(\\\"const int %s_%s = %d;\\\" % (col_prefix, field[\\\"name\\\"].upper(), col_count))\\n col_count += 1\\n except KeyError:\\n pass\\n c_col.append(\\\"const int %s_LAST = %d;\\\" % (col_prefix, col_count-1))\\n c_col.append(\\\"\\\\n\\\")\",\n \"def get_symbols(obj_path):\\n cmd = ['nm', obj_path]\\n res = subprocess.run(cmd, stdout=subprocess.PIPE,\\n stderr=subprocess.PIPE, check=True)\\n\\n return res.stdout.decode()\",\n \"def get_constants():\\r\\n\\r\\n dict_constants = dict()\\r\\n dict_constants['LOGIN_URL'] = \\\"https://yocket.in/account/login\\\"\\r\\n dict_constants['PAST_RESULTS_URL'] = \\\"https://yocket.in/recent-admits-rejects?page=\\\"\\r\\n dict_constants['ALL_RESULTS_URL'] = \\\"https://yocket.in/profiles/find/matching-admits-and-rejects?page=\\\"\\r\\n dict_constants['HOME_PAGE'] = 'https://yocket.in/'\\r\\n dict_constants['NUMBER_PAGE_TO_SCRAPE_FIRST'] = 1\\r\\n dict_constants['NUMBER_PAGE_TO_SCRAPE_LAST'] = 2\\r\\n dict_constants['MINIMUM_GPA'] = 7.5\\r\\n dict_constants['MINIMUM_GRE'] = 320\\r\\n dict_constants['MINIMUM_TOEFL'] = 100\\r\\n\\r\\n return dict_constants\",\n \"def _codec_names():\\n import glob\\n import os.path\\n\\n package_folder = os.path.dirname(__file__)\\n for codec_path in glob.glob(os.path.join(package_folder, \\\"cp*.py\\\")):\\n codec_name = os.path.splitext(os.path.basename(codec_path))[0]\\n yield codec_name\",\n \"def GetDefineGuardHeaderLines(output_file_name):\\n result = []\\n result.append(\\n '#ifndef %s_PREDICTION_%s_' %(_MOZC_DIR_FOR_DEFINE_GUARD,\\n GetDefineGuardSymbol(output_file_name)))\\n result.append(\\n '#define %s_PREDICTION_%s_' %(_MOZC_DIR_FOR_DEFINE_GUARD,\\n GetDefineGuardSymbol(output_file_name)))\\n return result\",\n \"def get_c_declare(r, name, sub):\\r\\n pre = \\\"\\\"\\\"\\r\\n PyObject* py_%(name)s;\\r\\n \\\"\\\"\\\" % locals()\\r\\n return pre + r.type.c_declare(name, sub)\",\n \"def get_global_variable_names(self):\\n return [b\\\"\\\".join(_i).strip().decode()\\n for _i in self._f.variables[\\\"name_glo_var\\\"][:]]\",\n \"def name_python_binary_module(self) -> str:\\n return f'_ba{self.name_compact}'\",\n \"def find_constants_referenced(self, text: str) -> list[str]:\\n aList = sorted(set(re.findall(r\\\"@[A-Za-z_][-A-Za-z0-9_]*\\\", text)))\\n # Exempt references to Leo constructs.\\n for s in ('@button', '@constants', '@data', '@language'):\\n if s in aList:\\n aList.remove(s)\\n return aList\",\n \"def _get_const_str(self):\\n const_components = []\\n for k, v in self.constargs.items():\\n v_str = f\\\"'{v}'\\\" if type(v) is str else str(v)\\n const_components.append(f\\\"{k}={v_str}\\\")\\n return \\\",\\\".join(const_components)\",\n \"def __getConsts(self, imt):\\n\\n if 'PGA' in imt:\\n c = self.__constants['pga']\\n c2 = self.__constants2['pga']\\n elif 'PGV' in imt:\\n c = self.__constants['pgv']\\n c2 = self.__constants2['pgv']\\n elif 'SA' in imt:\\n pp = imt.period\\n if pp == 0.3:\\n c = self.__constants['psa03']\\n c2 = self.__constants2['psa03']\\n elif pp == 1.0:\\n c = self.__constants['psa10']\\n c2 = self.__constants2['psa10']\\n elif pp == 3.0:\\n c = self.__constants['psa30']\\n c2 = self.__constants2['psa30']\\n else:\\n raise ValueError(\\\"Unknown SA period: %f\\\" % pp)\\n else:\\n raise ValueError(\\\"Unknown IMT %r\\\" % imt)\\n return (c, c2)\",\n \"def get_symbols(doc, lib):\\n\\n basename = lib.replace(\\\".dll\\\", \\\"\\\").lower()\\n filename = os.path.join(get_hopper_script_dir(), basename + \\\".txt\\\")\\n if not os.path.exists(filename):\\n doc.log(\\\"Symbol file not found: %s\\\" % filename)\\n return None\\n\\n symbols = {}\\n with open(filename, \\\"r\\\") as fp:\\n for i, line in enumerate(fp, 1):\\n match = symbol_line.match(line)\\n if not match:\\n doc.log(\\\"Skipping line %d: Malformed\\\" % i)\\n continue\\n\\n ordinal, name = match.group(1), match.group(2)\\n if ordinal and name:\\n symbols[ordinal] = name\\n\\n return symbols\",\n \"def getBuilderNames():\",\n \"def const(self, name):\\n return self.get_ground_vector('!Const:{}'.format(name))\",\n \"def const(self, name):\\n return self.get_ground_vector('!Const:{}'.format(name))\",\n \"def const(self, name):\\n return self.get_ground_vector('!Const:{}'.format(name))\",\n \"def make_get_python_out_struct(self):\\n res = \\\\\\n\\\"\\\"\\\"DLLEXPORT ___madz_LANG_python_TYPE_* {}_get_out_struct(){{\\n return &___madz_LANG_python_OUTPUT;\\n}}\\n\\n\\\"\\\"\\\"\\n return res.format(self.python_mangle)\",\n \"def ignore_pyc(root,names):\\n return [name for name in names if name.endswith('pyc')]\",\n \"def render_const(var_words):\\n return '_'.join(var_words).upper()\",\n \"def get_name_list(msh, varname):\\n return [str(chartostring(v)) for v in msh.variables[varname]]\",\n \"def consts(t):\\n for elt in t:\\n r = repr(elt)\\n if r.startswith(\\\"<code object\\\"):\\n yield \\\"<code object %s>\\\" % elt.co_name\\n else:\\n yield r\",\n \"def load_constants():\\n with open(VARIABLES_DIR / \\\"constants.yaml\\\", \\\"r\\\", encoding=\\\"utf-8\\\") as stream:\\n constants = yaml.safe_load(stream)\\n\\n return constants\",\n \"def const(string):\\n\\n\\tconstparams = dict({\\n\\t\\t\\t\\t\\t'kb' : 1.3806e-23,\\t# Boltzmann's constant\\n\\t\\t\\t\\t\\t'hbar' : 1.054e-34,\\t# Planck's constant\\n\\t\\t\\t\\t\\t'topeta' : 1e15,\\t# To peta-\\n\\t\\t\\t\\t\\t'totera' : 1e12,\\t# To tera-\\n\\t\\t\\t\\t\\t'togiga' : 1e9,\\t# To giga-\\n\\t\\t\\t\\t\\t'tomega' : 1e6,\\t# To mega-\\n\\t\\t\\t\\t\\t'tokilo' : 1e3,\\t# To kilo-\\n\\t\\t\\t\\t\\t'tocenti' : 1e-2,\\t# To centi-\\n\\t\\t\\t\\t\\t'tomilli' : 1e-3,\\t# To milli-\\n\\t\\t\\t\\t\\t'tomicro' : 1e-6,\\t# To micro-\\n\\t\\t\\t\\t\\t'tonano' : 1e-9,\\t# To nano-\\n\\t\\t\\t\\t\\t'topico' : 1e-12,\\t# To pico-\\n\\t\\t\\t\\t\\t'tofemto' : 1e-15,\\t# To femto-\\n\\t\\t\\t\\t\\t})\\n\\n\\ttry:\\n\\t\\treturn constparams[string]\\n\\texcept KeyError, e:\\n\\t\\tprint \\\"KeyError: %s is not a valid key for ntpy.param.const().\\\" % e\\n\\t\\traise\",\n \"def get_test_modules_names() -> typing.List[str]:\\n\\n from services.meter.tests.unit import constants_for_tests\\n return constants_for_tests.TESTS_MODULES\",\n \"def _getConsts(self, imt):\\r\\n\\r\\n if (imt != self._pga and imt != self._pgv and imt != self._sa03 and\\r\\n imt != self._sa10 and imt != self._sa30):\\r\\n raise ValueError(\\\"Invalid IMT \\\" + str(imt))\\r\\n c = self._constants[imt]\\r\\n return (c)\",\n \"def _boilerplate_to_python(indent):\\n indent_str = \\\" \\\" * indent\\n boilerplate = indent_str + \\\"import core.vba_library\\\\n\\\"\\n boilerplate = indent_str + \\\"import core.vba_context\\\\n\\\"\\n boilerplate += indent_str + \\\"from core.utils import safe_print\\\\n\\\"\\n boilerplate += indent_str + \\\"from core.utils import safe_str_convert\\\\n\\\"\\n boilerplate += indent_str + \\\"from core.utils import plus\\\\n\\\"\\n boilerplate += indent_str + \\\"from core.utils import eq\\\\n\\\"\\n boilerplate += indent_str + \\\"from core.utils import neq\\\\n\\\"\\n boilerplate += indent_str + \\\"from core.utils import lt\\\\n\\\"\\n boilerplate += indent_str + \\\"from core.utils import lte\\\\n\\\"\\n boilerplate += indent_str + \\\"from core.utils import gt\\\\n\\\"\\n boilerplate += indent_str + \\\"from core.utils import gte\\\\n\\\"\\n boilerplate += indent_str + \\\"import core.utils\\\\n\\\"\\n boilerplate += indent_str + \\\"from core.python_jit import update_array\\\\n\\\"\\n boilerplate += indent_str + \\\"from core.vba_conversion import coerce_to_num\\\\n\\\"\\n boilerplate += indent_str + \\\"from core.vba_conversion import coerce_to_int\\\\n\\\"\\n boilerplate += indent_str + \\\"from core.vba_conversion import coerce_to_str\\\\n\\\"\\n boilerplate += indent_str + \\\"from core.vba_conversion import coerce_to_int_list\\\\n\\\\n\\\"\\n boilerplate += indent_str + \\\"try:\\\\n\\\"\\n boilerplate += indent_str + \\\" \\\" * 4 + \\\"vm_context\\\\n\\\"\\n boilerplate += indent_str + \\\"except (NameError, UnboundLocalError):\\\\n\\\"\\n boilerplate += indent_str + \\\" \\\" * 4 + \\\"vm_context = context\\\\n\\\"\\n return boilerplate\",\n \"def get_pyxb_namespaces():\\n return pyxb.namespace.utility.AvailableNamespaces()\",\n \"def bpix_kw(bpixtab):\\n print('Verifying the header keywords of UVIS bad pixel table {}...'.format(bpixtab))\\n print('USEAFTER:')\\n print(fits.getheader(bpixtab)['USEAFTER'])\\n print(' ')\\n print('PEDIGREE:')\\n print(fits.getheader(bpixtab)['PEDIGREE'])\\n print(' ')\\n print('DESCRIP:')\\n print(fits.getheader(bpixtab)['DESCRIP'])\\n print(' ')\\n print('COMMENT:')\\n print(fits.getheader(bpixtab)['COMMENT'])\\n print(' ')\\n print('HISTORY:')\\n print(fits.getheader(bpixtab)['HISTORY'])\",\n \"def _dump_prefix(guard: str) -> List[str]:\\n\\n return [\\n f\\\"#ifndef {guard}\\\",\\n f\\\"#define {guard}\\\",\\n \\\"// <<< Use Configuration Wizard in Context Menu >>>\\\",\\n \\\"#ifdef USE_APP_CONFIG\\\",\\n '#include \\\"app_config.h\\\"',\\n \\\"#endif\\\"\\n ]\",\n \"def getModuleNames():\\n import setup\\n names = [e.name[1:] for e in setup.wxpExtensions]\\n return names\",\n \"def _sym_constant(self, table: Mapping[int, str]) -> str:\\n try:\\n return table[self.sym]\\n except KeyError:\\n return str(self.sym)\",\n \"def get_macro(self, name: str) -> str:\\n data = struct.pack('<HH{}s'.format(len(name)), 0, len(name), name.encode())\\n return self.__intf(2, data)[2:].decode()\",\n \"def imports():\\n for name, val in globals().items():\\n if isinstance(val, getattr(types, \\\"ModuleType\\\")):\\n yield val.__name__\",\n \"def getOsiVarNames( self ):\\n\\n if self.osiVarNames:\\n return self.osiVarNames.keys()\\n \\n n = self.adb.get( \\\"nOsiVars\\\" )\\n for indx in xrange( n ):\\n name = self.adb.get( \\\"osiVarName\\\",\\n indx ) \\n self.osiVarNames[ name ]= indx\\n\\n return self.osiVarNames.keys()\",\n \"def test_created():\\n assert len(dir(constants)) > 300\\n assert hasattr(constants, \\\"Planck_constant\\\") == True\",\n \"def getInfoVariableNames(self, product):\\r\\n return []\",\n \"def GetHeaderName(name):\\n name = os.path.splitext(name)[0] + '.h'\\n name = name.replace(os.sep, '/')\\n return 'ppapi/c/' + name\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63279045","0.6142163","0.594471","0.5942139","0.59368765","0.59215355","0.590987","0.58534914","0.57482266","0.57082814","0.5656697","0.56237125","0.55894226","0.55852455","0.5570691","0.5560409","0.5546228","0.5487835","0.5454318","0.5445472","0.5438231","0.5431478","0.54168934","0.539878","0.5372401","0.5366455","0.5365839","0.5358318","0.5319855","0.530538","0.5301711","0.52766186","0.52487016","0.52296436","0.5225606","0.5224576","0.5182079","0.5160733","0.5130271","0.5127967","0.5116287","0.5087695","0.5085727","0.5082717","0.5079234","0.5066526","0.5041545","0.50304586","0.50289917","0.50251234","0.50150204","0.50065017","0.5005424","0.5003382","0.49936035","0.4991045","0.4931618","0.49266768","0.4922245","0.4903186","0.49020082","0.4898961","0.4884125","0.4882187","0.487816","0.4874059","0.48736688","0.48620388","0.4846791","0.4840434","0.48399815","0.4825771","0.48202333","0.48089328","0.4802165","0.4791801","0.47898534","0.47898534","0.47898534","0.47798878","0.47767928","0.47744137","0.47729236","0.47700757","0.47564578","0.47552866","0.47519797","0.47365576","0.473376","0.47212726","0.47191662","0.47161847","0.471578","0.47147277","0.47088978","0.4704482","0.47038147","0.4697082","0.46929896","0.46854532"],"string":"[\n \"0.63279045\",\n \"0.6142163\",\n \"0.594471\",\n \"0.5942139\",\n \"0.59368765\",\n \"0.59215355\",\n \"0.590987\",\n \"0.58534914\",\n \"0.57482266\",\n \"0.57082814\",\n \"0.5656697\",\n \"0.56237125\",\n \"0.55894226\",\n \"0.55852455\",\n \"0.5570691\",\n \"0.5560409\",\n \"0.5546228\",\n \"0.5487835\",\n \"0.5454318\",\n \"0.5445472\",\n \"0.5438231\",\n \"0.5431478\",\n \"0.54168934\",\n \"0.539878\",\n \"0.5372401\",\n \"0.5366455\",\n \"0.5365839\",\n \"0.5358318\",\n \"0.5319855\",\n \"0.530538\",\n \"0.5301711\",\n \"0.52766186\",\n \"0.52487016\",\n \"0.52296436\",\n \"0.5225606\",\n \"0.5224576\",\n \"0.5182079\",\n \"0.5160733\",\n \"0.5130271\",\n \"0.5127967\",\n \"0.5116287\",\n \"0.5087695\",\n \"0.5085727\",\n \"0.5082717\",\n \"0.5079234\",\n \"0.5066526\",\n \"0.5041545\",\n \"0.50304586\",\n \"0.50289917\",\n \"0.50251234\",\n \"0.50150204\",\n \"0.50065017\",\n \"0.5005424\",\n \"0.5003382\",\n \"0.49936035\",\n \"0.4991045\",\n \"0.4931618\",\n \"0.49266768\",\n \"0.4922245\",\n \"0.4903186\",\n \"0.49020082\",\n \"0.4898961\",\n \"0.4884125\",\n \"0.4882187\",\n \"0.487816\",\n \"0.4874059\",\n \"0.48736688\",\n \"0.48620388\",\n \"0.4846791\",\n \"0.4840434\",\n \"0.48399815\",\n \"0.4825771\",\n \"0.48202333\",\n \"0.48089328\",\n \"0.4802165\",\n \"0.4791801\",\n \"0.47898534\",\n \"0.47898534\",\n \"0.47898534\",\n \"0.47798878\",\n \"0.47767928\",\n \"0.47744137\",\n \"0.47729236\",\n \"0.47700757\",\n \"0.47564578\",\n \"0.47552866\",\n \"0.47519797\",\n \"0.47365576\",\n \"0.473376\",\n \"0.47212726\",\n \"0.47191662\",\n \"0.47161847\",\n \"0.471578\",\n \"0.47147277\",\n \"0.47088978\",\n \"0.4704482\",\n \"0.47038147\",\n \"0.4697082\",\n \"0.46929896\",\n \"0.46854532\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6312631"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":7287,"cells":{"query":{"kind":"string","value":"Return holdout indices respecting hte temporal ordering of the data"},"document":{"kind":"string","value":"def time_series_hold_out_validation(random_state: np.random.RandomState,\n val_share: float, indices: np.ndarray, **kwargs: Any) \\\n -> Tuple[np.ndarray, np.ndarray]:\n n_prediction_steps = kwargs['n_prediction_steps']\n n_repeats = kwargs['n_repeats']\n # Time Series prediction only requires on set of prediction for each\n # This implement needs to be combined with time series forecasting dataloader, where each time an entire\n # time series is used for prediction\n cv = TimeSeriesSplit(n_splits=2, test_size=1 + n_prediction_steps * (n_repeats - 1), gap=n_prediction_steps - 1)\n\n train, val = holdout_split_forecasting(holdout=cv,\n indices=indices,\n n_prediction_steps=n_prediction_steps,\n n_repeats=n_repeats)\n return train, val"},"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_pulling_indices(self, weight):\n pass","def getBreakIndices(self):\n for i in self.raw.index[:-1]:\n if self.raw['stress'][i+1] > self.raw['stress'][i] and \\\n self.raw['stress'][i+2] < self.raw['stress'][i+1]:\n brkIdx1 = i+1 # brkIdx1: start of the first unloading\n break\n if self.reloading:\n for i in self.raw.index[brkIdx1+1:-1]:\n if self.raw['stress'][i+1] < self.raw['stress'][i] and \\\n self.raw['stress'][i+2] > self.raw['stress'][i+1]:\n brkIdx2 = i+1 # brkIdx2: end of the first unloading\n break\n # brkIdx3: Point on the NCL after the first reloading\n brkIdx3 = self.raw.query(f'stress == stress[{brkIdx1}]').index[1]\n # brkIdx4: index of the last point on the NCL\n brkIdx4 = self.raw.query('stress == stress.max()').index[0]\n self.secondUnloading = False\n else:\n brkIdx2 = self.raw.index[-1]\n brkIdx3 = None\n brkIdx4 = None\n\n self.brkIdx1 = brkIdx1\n self.brkIdx2 = brkIdx2\n self.brkIdx3 = brkIdx3\n self.brkIdx4 = brkIdx4\n return","def get_indices(waves):\n prob_ = np.abs(waves)**2\n # batch\n prob = [np.sum(prob_[i:i+4,:], axis=0) for i in range(0, len(waves[:,0]), 4)]\n prob = np.asarray(prob)\n prob_tot = np.sum(prob, axis=0)\n \n # cutoff\n length = np.size(prob[:,0])\n len10 = int(length/10)\n flags = np.zeros((prob.shape[1]), dtype=int)\n # hinges\n # 50% within 10% of corners\n\n # surface\n # 50% within 10% of surfaces\n # not already labelled hinges\n prob_left = np.sum(prob[0:len10,:], axis=0)\n frac_left = prob_left/prob_tot\n\n prob_right = np.sum(prob[length-len10:length,:], axis=0)\n frac_right = np.divide(prob_right, prob_tot)\n\n for i in range(len(flags)):\n if frac_left[i]>0.5 or frac_right[i]>0.5:\n flags[i] = 1\n \n indices = [i for i, x in enumerate(flags) if x == 1]\n indices0 = [i for i, x in enumerate(flags) if x == 0]\n \n return indices, indices0","def get_out_idx():\n exacz = pd.read_csv(f'{home}/ref/exac/exac_zscore_mimssense+stopgain_gn_checked.txt', sep='\\t')\n exacz = exacz[['gn', 'conseq', 'exac_z', 'exac_zrank']]\n\n gdi = pd.read_csv(f'{home}/work/generisk/gdi/gdi_score_pnas_gn_checked.txt', sep=\"\\t\")\n gdi = gdi[['gn', 'gdi', 'gdi_phred_raw']]\n gdi['gdi_rank'] = 100 - round(gdi['gdi'].rank() / len(gdi.index) * 100, 2)\n\n rvis = pd.read_csv(f\"{home}/ref/rvis/rvis_lite.txt\", sep='\\t')\n\n out_idx = pd.merge(exacz, gdi, on='gn', how='outer')\n out_idx = pd.merge(out_idx, rvis, on='gn', how='outer')\n\n # merge with omim\n omim = pd.read_csv(f\"{home}/ref/omim/omim_dedup.tsv\", sep='\\t', usecols='gn,inher'.split(\",\"))\n out_idx = pd.merge(out_idx, omim, on='gn', how='left')\n out_idx['inher'] = out_idx['inher'].fillna('na')\n\n # 18090\n out_idx = out_idx.loc[out_idx.conseq == 'missense_variant'].drop('conseq', axis=1)\n\n out_idx.to_pickle(f'{home}/gr/final/out_idx.pk')\n\n return out_idx","def construct_indices(after_pooling):\n our_indices = np.zeros_like(after_pooling, dtype=np.int64)\n batch_num, channel_num, row_num, col_num = after_pooling.shape\n for batch_id in range(batch_num):\n for channel_id in range(channel_num):\n for row_id in range(row_num):\n for col_id in range(col_num):\n our_indices[batch_id, channel_id, row_id, col_id] = col_num * 2 * 2 * row_id + 2 * col_id\n return torch.from_numpy(our_indices)","def _get_indexes(self, participants):\n tr_idx = int(np.floor(self.tr_size*len(participants)))\n j = self.val_size + self.tr_size\n val_idx = int(np.floor(j*len(participants)))\n return tr_idx, val_idx","def get_output_slice_idx(self, output_index):\r\n ipos = 0\r\n opos = output_index\r\n for otaps in zip(self.mitmot_out_taps()):\r\n if len(otaps) > 0:\r\n return ipos\r\n else:\r\n opos = opos - 1\r\n ipos += len(otaps)\r\n return ipos + opos","def _get_indx(self, t):\n t = np.array(t)\n a = (t[:, np.newaxis] <= self._data['stop']) & (t[:, np.newaxis] >=\n self._data['start'])\n return np.array([np.where(row)[0][0] for row in a])","def pt_index(*args):\n index = []\n x = check_pt_data(args[0])\n i = 0\n for line in args[0].Data.PTData.pt_data:\n i += 1\n if line != x[i - 1]:\n index.append(0)\n elif line == x[i - 1]:\n index.append(i)\n return index","def get_cv_indices(df, col, time_slices):\n return [\n ## get train and holdout indices for slice\n tuple(get_row_indices(df, col, slc[x]) for x in range(2))\n\n ## get indices for each slice\n for slc in time_slices\n ]","def indxmap_diff(Nd): \n\n ndims = len(Nd)\n Ndprod = numpy.prod(Nd)\n mylist = numpy.arange(0, Ndprod).astype(numpy.int32)\n mylist = numpy.reshape(mylist, Nd)\n d_indx = []\n dt_indx = []\n for pp in range(0, ndims):\n d_indx = d_indx + [ numpy.reshape( numpy.roll( mylist, +1 , pp ), (Ndprod,) ,order='C').astype(numpy.int32) ,]\n dt_indx = dt_indx + [ numpy.reshape( numpy.roll( mylist, -1 , pp ) , (Ndprod,) ,order='C').astype(numpy.int32) ,]\n\n return d_indx, dt_indx","def _sort_index(self):\n\n allAltPos = np.array(sorted(list(set(list(self.data['altitude'])))))[::-1]\n allAziPos = np.array(sorted(list(set(list(self.data['azimuth'])))))\n\n indON = [[None for azi in allAziPos] for alt in allAltPos]; indOFF = [[None for azi in allAziPos] for alt in allAltPos]\n\n for i, traceItem in enumerate(self.data):\n alt = traceItem['altitude'];azi = traceItem['azimuth'];sign = traceItem['sign']\n for j, altPos in enumerate(allAltPos):\n for k, aziPos in enumerate(allAziPos):\n if alt==altPos and azi==aziPos:\n if sign==1:\n if indON[j][k] is not None: raise LookupError('Duplication of trace items found at location:'+str([alt, azi])+'; sign: 1!')\n else: indON[j][k]=i\n\n if sign==-1:\n if indOFF[j][k] is not None: raise LookupError('Duplication of trace items found at location:'+str([alt, azi])+'; sign:-1!')\n else: indOFF[j][k]=i\n\n indON = np.array([np.array(x) for x in indON]); indOFF = np.array([np.array(x) for x in indOFF])\n\n return indON,indOFF,allAltPos,allAziPos","def get_34index_list(self):\n msk = self.load_mask()\n return [i for (i,v) in enumerate(msk) if v==1]","def time_window_bins(self, t0, tend):\n indexes = []\n for level in range(self._max_level):\n for i in range(2**level):\n local_times = self.partial_time_interval(level, i)\n if t0 >= local_times['t0'] and t0 < local_times['tend']:\n indexes.append(self._index_list(level, i))\n if tend > local_times['t0'] and tend <= local_times['tend']:\n indexes.append(self._index_list(level, i))\n if t0 <= local_times['t0'] and tend >= local_times['tend']:\n indexes.append(self._index_list(level, i))\n # Remove duplicates if they exist\n # indexes = list(dict.fromkeys(indexes)) # Python 3.7 or later (preserve order)\n indexes = list(set(indexes)) # Any Python version, but does not preserve order\n indexes = np.sort(indexes)\n return indexes","def ordered_indices(self):\n return self.base_dataset.ordered_indices()","def get_final_pruned_indices(self):\n return self.final_pruned_indices","def get_indices_input_target(num_obs, input_len, step_size, forecast_horizon, target_len):\n input_len = round(input_len) # just a precaution\n start_position = 0\n stop_position = num_obs - 1\n\n inpseq_first_idx = start_position\n inpseq_last_idx = inpseq_first_idx + input_len\n target_first_idx = inpseq_last_idx + forecast_horizon\n target_last_idx = target_first_idx + target_len\n print(\"target_last_idx = {}\".format(target_last_idx))\n print(\"stop_position = {}\".format(stop_position))\n indices = []\n while target_last_idx <= stop_position:\n indices.append((inpseq_first_idx, inpseq_last_idx, target_first_idx, target_last_idx))\n inpseq_first_idx += step_size\n inpseq_last_idx += step_size\n target_first_idx += inpseq_last_idx + forecast_horizon\n target_last_idx += target_first_idx + target_len\n return indices","def get_data_indices(aperiodic_mode):\n\n indices = {\n 'CF' : 0,\n 'PW' : 1,\n 'BW' : 2,\n 'offset' : 0,\n 'knee' : 1 if aperiodic_mode == 'knee' else None,\n 'exponent' : 1 if aperiodic_mode == 'fixed' else 2\n }\n\n return indices","def get_indexes(self, dataset):\n\n for i in range(self.max_iters):\n index = random.randint(0, len(dataset))\n gt_bboxes_i = dataset.get_ann_info(index)['bboxes']\n if len(gt_bboxes_i) != 0:\n break\n\n return index","def get_index(ks):\n unq_vals, unq_ix = np.unique(ks[:, 0], return_index=True)\n return np.vstack([unq_vals, unq_ix]).T","def test_lifted_index():\n pressure = np.array([1014., 1000., 997., 981.2, 947.4, 925., 914.9, 911.,\n 902., 883., 850., 822.3, 816., 807., 793.2, 770.,\n 765.1, 753., 737.5, 737., 713., 700., 688., 685.,\n 680., 666., 659.8, 653., 643., 634., 615., 611.8,\n 566.2, 516., 500., 487., 484.2, 481., 475., 460.,\n 400.]) * units.hPa\n temperature = np.array([24.2, 24.2, 24., 23.1, 21., 19.6, 18.7, 18.4,\n 19.2, 19.4, 17.2, 15.3, 14.8, 14.4, 13.4, 11.6,\n 11.1, 10., 8.8, 8.8, 8.2, 7., 5.6, 5.6,\n 5.6, 4.4, 3.8, 3.2, 3., 3.2, 1.8, 1.5,\n -3.4, -9.3, -11.3, -13.1, -13.1, -13.1, -13.7, -15.1,\n -23.5]) * units.degC\n dewpoint = np.array([23.2, 23.1, 22.8, 22., 20.2, 19., 17.6, 17.,\n 16.8, 15.5, 14., 11.7, 11.2, 8.4, 7., 4.6,\n 5., 6., 4.2, 4.1, -1.8, -2., -1.4, -0.4,\n -3.4, -5.6, -4.3, -2.8, -7., -25.8, -31.2, -31.4,\n -34.1, -37.3, -32.3, -34.1, -37.3, -41.1, -37.7, -58.1,\n -57.5]) * units.degC\n parcel_prof = parcel_profile(pressure, temperature[0], dewpoint[0])\n li = lifted_index(pressure, temperature, parcel_prof)\n assert_almost_equal(li, -7.9115691 * units.delta_degree_Celsius, 2)","def window_inds(dataset, window_sz, overlap):\r\n\tdata_len = len(dataset[0])\r\n\tassert window_sz < data_len\r\n\tind1 = 0\r\n\tind2 = window_sz-1\r\n\tind_list = []\r\n\tov_ind_diff = int(np.ceil(np.abs(overlap*window_sz)))\r\n\tif ov_ind_diff == window_sz:\r\n\t\tov_ind_diff += -1\r\n\twhile ind2 < data_len:\r\n\t\tind_list.append((ind1,ind2))\r\n\t\tind1 += window_sz-ov_ind_diff\r\n\t\tind2 += window_sz-ov_ind_diff\r\n\treturn ind_list","def _topological_sort_timestamp_index(self) -> Iterator[BaseTransaction]:\n raise NotImplementedError","def indices(self):\n _indices = []\n for h in self.miller.indices():\n _indices.append(self.indices_hkl(*h)[0])\n return _indices","def FindIdxValues(X):\n data = X.select_dtypes(include=[\"float64\"])\n idx = np.argwhere(~np.isnan(data.values))\n idx[:, 1] += 4 # add ID variable columns\n StoE = pd.read_csv(\"msresist/data/MS/CPTAC/IDtoExperiment.csv\")\n assert all(StoE.iloc[:, 0] == data.columns), \"Sample labels don't match.\"\n StoE = StoE.iloc[:, 1].values\n tmt = [[StoE[idx[ii][1] - 4]] for ii in range(idx.shape[0])]\n return np.append(idx, tmt, axis=1)","def _exclude_indices(self):\n idx = self._next_idx\n exclude = np.arange(idx - 1, idx + self.obs_len) % self._maxsize\n return exclude","def get_main_points(neuron):\n (branch_index,) = np.where(neuron.branch_order[neuron.n_soma:] == 2)\n (endpoint_index,) = np.where(neuron.branch_order[neuron.n_soma:] == 0)\n selected_index = np.union1d(branch_index + neuron.n_soma,\n endpoint_index + neuron.n_soma)\n selected_index = np.append(range(neuron.n_soma), selected_index)\n return selected_index","def vir_indices(self):\n indices = []\n for index,item in enumerate(self):\n if item==0:\n indices.append(index)\n return indices","def get_prediction_indices(self):\r\n if self.full_df['Dates'][0] > self.full_df['Dates'][len(self.full_df) - 1]:\r\n self.full_df = self.full_df[::-1]\r\n self.full_df.reset_index(inplace=True)\r\n self.full_df.drop('index', axis=1, inplace=True)\r\n date_condition = ((self.full_df['Dates'] <= self.pred_end) &\r\n (self.full_df['Dates'] >= self.pred_start))\r\n self.pred_indices = list(self.full_df[date_condition].index)","def step_indices(group_idx):\n ilen = step_count(group_idx) + 1\n indices = np.empty(ilen, np.int64)\n indices[0] = 0\n indices[-1] = group_idx.size\n cmp_pos = 0\n ri = 1\n for i in range(len(group_idx)):\n if group_idx[cmp_pos] != group_idx[i]:\n cmp_pos = i\n indices[ri] = i\n ri += 1\n return indices","def index(self):\n # Check is multiple orders were given\n try:\n orders = list(iter(self.orders))\n except TypeError:\n orders = [self.orders]\n sites = self._epistasismap.sites\n x = [i for i in range(1, len(sites)) if len(sites[i]) in orders]\n # Add the zeroth element if included\n if 0 in orders:\n x = [0] + x\n return np.array(x)","def bprop_sparse_tensor_get_indices(sparse_tensor, out, dout):\n return (zeros_like(sparse_tensor),)","def get_time_index():\n\n def get_common_list(map):\n res = set()\n first = True\n for _, value in map.items():\n if first:\n res = set(value)\n first = False\n else:\n res = res.intersection(value)\n return list(res)\n\n # get common time for 3 cities\n demand_map = {}\n for city in ['beijing', 'tianjing', 'guangzhou']:\n demand_map[city] = []\n for file in os.listdir(exp_data_path + os.sep + 'station' + os.sep + city):\n demand_map[city].append(file[0:12])\n\n\n # get weather time\n weather_map = {}\n for city in ['beijing', 'tianjing', 'guangzhou']:\n weather_map[city] = []\n for file in os.listdir(spider_data_path + os.sep + 'weather' + os.sep + city):\n with open(spider_data_path + os.sep + 'weather' + os.sep + city + os.sep + file) as f:\n reader = csv.reader(f)\n for line in reader:\n # t = line[0].replace(\"\\ufeff\", \"\")\n weather_map[city].append(line[0].replace(\"\\ufeff\", \"\"))\n\n demand_res = get_common_list(demand_map)\n weather_res = get_common_list(weather_map)\n res = get_common_list({'demand': demand_res, 'weather': weather_res})\n res = sorted(res)\n print(len(res))\n print(res)\n\n\n time_index = {'index': {}, 'rev_index': {}}\n index = 0\n for time in res:\n time_index['index'][index] = time\n time_index['rev_index'][time] = index\n index = index + 1\n\n file_name = exp_data_path + os.sep + 'station_list' + os.sep + 'time_index.npy'\n if os.path.exists(file_name):\n os.remove(file_name)\n np.save(file_name, time_index)","def ordered_indices(self):\r\n return np.arange(len(self), dtype=np.int64)","def _get_block_indices(y):\n block_labels, block_inv, block_sizes = np.unique(\n y, return_inverse=True, return_counts=True\n )\n\n n_blocks = len(block_labels)\n block_inds = range(n_blocks)\n\n block_vert_inds = []\n for i in block_inds:\n # get the inds from the original graph\n inds = np.where(block_inv == i)[0]\n block_vert_inds.append(inds)\n return block_vert_inds, block_inds, block_inv","def _selected_indices(self, subset):\n # We want the DataFrame to be indexed the same way its values array is\n ftr = self.frametracks.reset_index(drop=True)\n if subset is not None:\n ftr['tmpindex'] = ftr.index.values\n ftr = ftr.set_index('particle').reindex(subset).set_index('tmpindex')\n if self.autoclip:\n # Boundaries are computed for the whole system\n xmin = self.frametracks.x.min() + self.nncutoff\n xmax = self.frametracks.x.max() - self.nncutoff\n ymin = self.frametracks.y.min() + self.nncutoff\n ymax = self.frametracks.y.max() - self.nncutoff\n r = ftr.index[ (ftr.x > xmin) & (ftr.x < xmax) & \\\n (ftr.y > ymin) & (ftr.y < ymax) ].values.astype(int)\n else:\n r = ftr.index.values.astype(int)\n if self.fast:\n return np.random.permutation(r)[:int(len(r) / 10)]\n else:\n return r","def relevant_indexes(data, min_threshold):\n\n start_index = 1\n end_index = len(data) - 1\n\n for i in range(len(data)):\n if data[i] > min_threshold:\n start_index = i\n break\n\n for i in range(len(data)):\n if data[::-1][i] > min_threshold:\n end_index = i\n break\n\n return start_index, end_index","def get_index_from_well(self, well):\n pass","def sorted_index(self) -> np.ndarray:\n return np.argsort(self.result_array.sum(axis=1))[::-1]","def break_index(self, **kwargs):\n return self.peak_indices(**kwargs)[0][-1]","def get_itds(timestamps, ears, types, max_itd=800e-6, save_to_file=None, verbose=False, return_itd_indices=False):\n ears = ears.astype(np.bool)\n itds_to_return = np.zeros(timestamps.size, dtype=np.float32)\n itds_to_return.fill(-5. * max_itd)\n\n timestamps_dict = {}\n timestamp_indices_dict = {}\n for ear in np.unique(ears):\n timestamps_dict[ear] = {}\n timestamp_indices_dict[ear] = {}\n for type_of_event in np.unique(types):\n timestamps_dict[ear][type_of_event] = []\n timestamp_indices_dict[ear][type_of_event] = []\n\n for idx, (timestamp, ear, type_of_event) in enumerate(zip(timestamps, ears, types)):\n timestamps_dict[ear][type_of_event].append(timestamp)\n timestamp_indices_dict[ear][type_of_event].append(idx)\n\n if verbose:\n print('Initialized the timestamp lists.')\n\n bar = progressbar.ProgressBar() if verbose else lambda x: x\n\n for type_of_event in bar(np.unique(types)):\n timestamps_left = np.array(timestamps_dict[True][type_of_event])\n timestamp_indices_left = timestamp_indices_dict[True][type_of_event]\n timestamps_right = np.array(timestamps_dict[False][type_of_event])\n timestamp_indices_right = timestamp_indices_dict[False][type_of_event]\n\n for ts_right, ts_idx_right in zip(timestamps_right, timestamp_indices_right):\n matched_indices = np.where((timestamps_left >= ts_right - max_itd) &\n (timestamps_left < ts_right + max_itd))[0]\n if matched_indices.size > 0:\n matched_itds = ts_right - timestamps_left[matched_indices]\n min_itd = np.argmin(np.abs(matched_itds))\n itds_to_return[ts_idx_right] = matched_itds[min_itd]\n\n for ts_left, ts_idx_left in zip(timestamps_left, timestamp_indices_left):\n matched_indices = np.where((timestamps_right >= ts_left - max_itd) &\n (timestamps_right < ts_left + max_itd))[0]\n if matched_indices.size > 0:\n matched_itds = timestamps_right[matched_indices] - ts_left\n min_itd = np.argmin(np.abs(matched_itds))\n itds_to_return[ts_idx_left] = matched_itds[min_itd]\n\n itd_indices = np.where(itds_to_return > -4. * max_itd)[0]\n itds_to_return = itds_to_return[itd_indices]\n if save_to_file is not None:\n np.savez(save_to_file, timestamps=timestamps[itd_indices], ears=ears[itd_indices], types=types[itd_indices],\n itds=itds_to_return, itd_indices=itd_indices)\n\n if return_itd_indices:\n return itds_to_return, itd_indices\n\n return itds_to_return","def test_k_index():\n pressure = np.array([1014., 1000., 997., 981.2, 947.4, 925., 914.9, 911.,\n 902., 883., 850., 822.3, 816., 807., 793.2, 770.,\n 765.1, 753., 737.5, 737., 713., 700., 688., 685.,\n 680., 666., 659.8, 653., 643., 634., 615., 611.8,\n 566.2, 516., 500., 487., 484.2, 481., 475., 460.,\n 400.]) * units.hPa\n temperature = np.array([24.2, 24.2, 24., 23.1, 21., 19.6, 18.7, 18.4,\n 19.2, 19.4, 17.2, 15.3, 14.8, 14.4, 13.4, 11.6,\n 11.1, 10., 8.8, 8.8, 8.2, 7., 5.6, 5.6,\n 5.6, 4.4, 3.8, 3.2, 3., 3.2, 1.8, 1.5,\n -3.4, -9.3, -11.3, -13.1, -13.1, -13.1, -13.7, -15.1,\n -23.5]) * units.degC\n dewpoint = np.array([23.2, 23.1, 22.8, 22., 20.2, 19., 17.6, 17.,\n 16.8, 15.5, 14., 11.7, 11.2, 8.4, 7., 4.6,\n 5., 6., 4.2, 4.1, -1.8, -2., -1.4, -0.4,\n -3.4, -5.6, -4.3, -2.8, -7., -25.8, -31.2, -31.4,\n -34.1, -37.3, -32.3, -34.1, -37.3, -41.1, -37.7, -58.1,\n -57.5]) * units.degC\n ki = k_index(pressure, temperature, dewpoint)\n assert_almost_equal(ki, 33.5 * units.degC, 2)","def occ_indices(self):\n indices = []\n for index,item in enumerate(self):\n if item==1:\n indices.append(index)\n return indices","def get_continous_time_periods(binary_array):\n binary_array = np.copy(binary_array).astype(\"int8\")\n n_times = len(binary_array)\n d_times = np.diff(binary_array)\n # show the +1 and -1 edges\n pos = np.where(d_times == 1)[0] + 1\n neg = np.where(d_times == -1)[0] + 1\n\n if (pos.size == 0) and (neg.size == 0):\n if len(np.nonzero(binary_array)[0]) > 0:\n return [(0, n_times-1)]\n else:\n return []\n elif pos.size == 0:\n # i.e., starts on an spike, then stops\n return [(0, neg[0])]\n elif neg.size == 0:\n # starts, then ends on a spike.\n return [(pos[0], n_times-1)]\n else:\n if pos[0] > neg[0]:\n # we start with a spike\n pos = np.insert(pos, 0, 0)\n if neg[-1] < pos[-1]:\n # we end with aspike\n neg = np.append(neg, n_times - 1)\n # NOTE: by this time, length(pos)==length(neg), necessarily\n h = np.matrix([pos, neg])\n # print(f\"len(h[1][0]) {len(h[1][0])} h[1][0] {h[1][0]} h.size {h.size}\")\n if np.any(h):\n result = []\n for i in np.arange(h.shape[1]):\n if h[1, i] == n_times-1:\n result.append((h[0, i], h[1, i]))\n else:\n result.append((h[0, i], h[1, i]-1))\n return result\n return []","def get_max_indices(self, input):\n \n min_element = torch.min(torch.abs(input.contiguous().view(-1)))\n input_temp = input + min_element + self.epsilon\n masked_input_temp = input_temp * self.mask\n values, indices = torch.sort(masked_input_temp, dim=1, descending=True)\n\n return indices[:, :self.num_active_nodes,:]","def get_adjacent_idxs(sample, array):\n state = sample >= array # boolean array\n # Find the index where the last \"True\"\n # This is the idx lower than the sample\n idx_lower = np.where(state)[0][-1]\n\n # Find the index where the last \"False\"\n # This is the first idx lower than the sample\n idx_higher = np.where(np.logical_not(state))[0][0]\n\n return idx_lower, idx_higher","def _get_index(self):\n\n return self.index\n\n # to avoid having differences bigger than 2pi","def get_track_mask_idxes(self):\n instance_id_num_pts = defaultdict(lambda: 0)\n instance_id_lifetimes = defaultdict(lambda: [10000, -1])\n\n for frame_num, labels_per_frame in enumerate(self._frame_labels):\n for id in labels_per_frame.unique().tolist():\n instance_id_num_pts[id] += (labels_per_frame == id).long().sum().item()\n instance_id_lifetimes[id][0] = min(frame_num, instance_id_lifetimes[id][0])\n instance_id_lifetimes[id][1] = max(frame_num, instance_id_lifetimes[id][1])\n\n instance_id_lifetimes = {k: v[1] - v[0] for k, v in instance_id_lifetimes.items()}\n return self._frame_labels, instance_id_num_pts, instance_id_lifetimes","def get_indexes(self, dataset):\n\n indexs = [random.randint(0, len(dataset)) for _ in range(3)]\n return indexs","def ordered_indices(self):\r\n '''we need random order'''\r\n if self.shuffle:\r\n indices = np.random.permutation(len(self))\r\n else:\r\n indices = np.arange(len(self))\r\n '''\r\n if self.tgt_sizes is not None:\r\n indices = indices[np.argsort(self.tgt_sizes[indices], kind='mergesort')]\r\n return indices[np.argsort(self.src_sizes[indices], kind='mergesort')]\r\n '''\r\n return indices","def _get_target_index(self):\n return (self.index + self.source_window * (not self.overlapping) +\n self.offset)","def mesh_span_indices(self):\n self._ensure_mesh()\n k2m = self._knots_to_mesh\n return np.where(k2m[1:] != k2m[:-1])[0]","def create_jackknife_indexes(data):\n from numpy import arange, delete\n\n index_range = arange(0, len(data))\n return (delete(index_range, i) for i in index_range)","def _get_k_indices(self, ks):\n if self.staticneighs:\n idx_ks = ks\n else:\n idx_ks = [self.ks.index(e) for e in ks]\n return idx_ks","def get_segment_index(datadb):\n #match in time!!!!\n if cfg.use_saliency:\n segment_index_tar = util.get_time_for_visual(datadb)\n segment_index_tar_future = OrderedDict()\n for key in segment_index_tar.keys():\n segment_index_tar_future[key] = np.array(segment_index_tar[key])+max_encoder_seq_length\n return segment_index_tar,segment_index_tar_future","def get_vacancy_indices(array):\t\n\tvacancy_indices = np.argwhere(array == 0)\n\treturn vacancy_indices","def ordered_indices(self):\n return self.d1.ordered_indices()\n # RETURN BASED ON D1's sizes","def get_cached_indices(self, start=None, end=None):\n params = {}\n indices = [\n y[\"sample_identifier\"]\n for y in self.mongo_database.cache.find(\n params, {\"_id\": 0, \"sample_identifier\": 1}\n )[start:end]\n ]\n return np.unique(indices).tolist()","def computeTopSurfaceIndices(top):\n itop = np.array([(top[i,j], j, i) \\\n for i in range(top.shape[0]) \\\n for j in range(top.shape[1]) \\\n if top[i,j] >= 0])\n return itop","def objects_to_indexes(self, object_seq: Sequence[Any]) -> np.ndarray:\n res = np.zeros(len(object_seq))\n for i, obj in enumerate(object_seq):\n if obj in self.obj_to_idx:\n res[i] = self.obj_to_idx[obj]\n else:\n res[i] = self.start-1\n return res","def get_overlapping_indices(self):\n return self._get_atomic_overlaps()","def indexes(self):\r\n\r\n\r\n if not self.usesequence:\r\n\r\n if len(self.get_all_indexes()) != len(self.sortedindexes) \\\r\n or self.indexchanged or not self.sortedindexes:\r\n self.indexchanged = False\r\n self.sortedindexes = sorted(self.get_all_indexes(),\r\n key=lambda x_temp: Index(x_temp))\r\n return self.sortedindexes\r\n return self.sortedindexes\r\n else:\r\n if self.indexchanged:\r\n self.sortedindexes = self.default_dict['indexlist'].strings()\r\n return self.sortedindexes\r\n else:\r\n return self.sortedindexes","def selectCompatibleIndices(bigTimes, smallTimes):\r\n indices = []\r\n for idx, _ in enumerate(smallTimes):\r\n distances = (bigTimes - smallTimes[idx])**2\r\n def getValue(k):\r\n return distances[k]\r\n thisIndices = sorted(range(len(distances)), key=getValue)\r\n indices.append(thisIndices[0])\r\n return np.array(indices)","def get_recorded_indices(self, application_vertex, variable):\n if variable not in self.__sampling_rates:\n return []\n if self.__indexes[variable] is None:\n return range(application_vertex.n_atoms)\n return self.__indexes[variable]","def scatter_counts_to_indices(input: torch.LongTensor) -> torch.LongTensor:\n return torch.repeat_interleave(torch.arange(input.size(0), device=input.device), input).long()","def get_negative_idx(self, outputs, targets, topk=(1, )):\n max_k = max(topk)\n\n _, pred = outputs.topk(max_k, 1, True, True)\n pred = pred.t()\n correct = pred.eq(targets.view(1, -1).expand_as(pred))\n \n res = []\n for k in topk:\n negative_idx = (correct[:k].view(-1).float() == 0).nonzero()\n res.append(negative_idx)\n return res","def master_ndindex(self): # itermaster_indices(self):\n return itertools_product(\n *[range(*r) for r in self.location]\n ) # TODO check","def generate_reverse_index(self):","def get_shuffle_ids(self, bsz):\n forward_inds = torch.randperm(bsz).long().cuda()\n backward_inds = torch.zeros(bsz).long().cuda()\n value = torch.arange(bsz).long().cuda()\n backward_inds.index_copy_(0, forward_inds, value)\n return forward_inds, backward_inds","def get_selected_indices(bboxes, gt_boxes, total_pos_bboxes, total_neg_bboxes):\n # Calculate iou values between each bboxes and ground truth boxes\n iou_map = generate_iou_map(bboxes, gt_boxes)\n # Get max index value for each row\n max_indices_each_gt_box = tf.argmax(iou_map, axis=2, output_type=tf.int32)\n # IoU map has iou values for every gt boxes and we merge these values column wise\n merged_iou_map = tf.reduce_max(iou_map, axis=2)\n # Sorted iou values\n sorted_iou_map = tf.argsort(merged_iou_map, direction=\"DESCENDING\")\n # Get highest and lowest candidate indices\n pos_candidate_indices = sorted_iou_map[:, :total_pos_bboxes * 2]\n neg_candidate_indices = sorted_iou_map[:, ::-1][:, :total_neg_bboxes * 2]\n # Shuffling\n pos_candidate_indices_shuffled = tf.transpose(tf.random.shuffle(tf.transpose(pos_candidate_indices)))\n neg_candidate_indices_shuffled = tf.transpose(tf.random.shuffle(tf.transpose(neg_candidate_indices)))\n # Randomly select pos and neg indices from candidates\n pos_bbox_indices = pos_candidate_indices_shuffled[:, :total_pos_bboxes]\n neg_bbox_indices = neg_candidate_indices_shuffled[:, :total_neg_bboxes]\n gt_box_indices = tf.gather(max_indices_each_gt_box, pos_bbox_indices, batch_dims=1)\n #\n return pos_bbox_indices, neg_bbox_indices, gt_box_indices","def fft_bin_to_index(self, bins):\n idx = bins.copy()\n return idx","def tc_index(*args):\n index = []\n x = check_tc_data(args[0])\n i = 0\n for line in args[0].Data.TCData.tc_data:\n i += 1\n if line != x[i - 1]:\n index.append(0)\n elif line == x[i - 1]:\n index.append(i)\n return index","def inidices(self):\n return [Index(name, index) for name, index in self._data['indices'].iteritems()]","def racetrack_filter(reversals, h):\n\n y = reversals\n yprev = None\n ix = []\n for n, yn in enumerate(y):\n if (n == 0) or (n == y.size-1):\n yprev = yn\n ix.append(n)\n continue\n dy = yn - yprev\n if fabs(dy) > h / 2.:\n yprev = yn - dy/fabs(dy) * h/2.\n ix.append(n)\n ix = np.array(ix, dtype=int)\n return y[ix], ix","def _little_group_index(self, k: Array) -> Array:\n # calculate k' = p(k) for all p in the point group\n big_star = np.tensordot(self.point_group_.matrices(), k, axes=1)\n big_star = self.lattice.to_reciprocal_lattice(big_star) % self.lattice.extent\n # should test for pbc before taking the modulus, but the only valid wave\n # vector for non-pbc axes is 0 and 0 % anything == 0\n\n # assumes point_group_[0] is the identity\n is_in_little_group = np.all(big_star == big_star[0], axis=1)\n return np.arange(len(self.point_group_))[is_in_little_group]","def _indicies_of_periods(datetime_index, freq, use_local_time=True):\n\n if use_local_time:\n datetime_index = _tz_to_naive(datetime_index)\n\n periods = pd.period_range(datetime_index[0], datetime_index[-1], freq=freq)\n\n # Declare and initialise some constants and variables used\n # during the loop...\n\n # Find the minimum sample period.\n MIN_SAMPLE_PERIOD = int(get_sample_period(datetime_index))\n MAX_SAMPLES_PER_PERIOD = int(\n secs_per_period_alias(freq) / MIN_SAMPLE_PERIOD)\n MAX_SAMPLES_PER_2_PERIODS = MAX_SAMPLES_PER_PERIOD * 2\n n_rows_processed = 0\n boundaries = {}\n for period in periods:\n # The simplest way to get data for just a single period is to use\n # data_for_day = datetime_index[period.strftime('%Y-%m-%d')]\n # but this takes about 300ms per call on my machine.\n # So we take advantage of several features of the data to achieve\n # a 300x speedup:\n # 1. We use the fact that the data is sorted in order, hence\n # we can chomp through it in order.\n # 2. MAX_SAMPLES_PER_PERIOD sets an upper bound on the number of\n # datapoints per period. The code is conservative and uses\n # MAX_SAMPLES_PER_2_PERIODS. We only search through a small subset\n # of the available data.\n\n end_index = n_rows_processed + MAX_SAMPLES_PER_2_PERIODS\n rows_to_process = datetime_index[n_rows_processed:end_index]\n indicies_for_period = np.where(rows_to_process < period.end_time)[0]\n if indicies_for_period.size > 0:\n first_i_for_period = indicies_for_period[0] + n_rows_processed\n last_i_for_period = indicies_for_period[-1] + n_rows_processed + 1\n boundaries[period] = (first_i_for_period, last_i_for_period)\n n_rows_processed += last_i_for_period - first_i_for_period\n\n return periods, boundaries","def indices(self):\n return self._kbounded_partitions","def get_itds_v3(timestamps, ears, types, max_itd=800e-6, save_to_file=None, verbose=False, return_itd_indices=False):\n ears = ears.astype(np.bool)\n itds_to_return = np.zeros(timestamps.size, dtype=np.float32)\n itds_to_return.fill(-5. * max_itd)\n\n timestamps_dict = {}\n timestamp_indices_dict = {}\n for ear in np.unique(ears):\n timestamps_dict[ear] = {}\n timestamp_indices_dict[ear] = {}\n for type_of_event in np.unique(types):\n timestamps_dict[ear][type_of_event] = []\n timestamp_indices_dict[ear][type_of_event] = []\n\n for idx, (timestamp, ear, type_of_event) in enumerate(zip(timestamps, ears, types)):\n timestamps_dict[ear][type_of_event].append(timestamp)\n timestamp_indices_dict[ear][type_of_event].append(idx)\n\n if verbose:\n print('Initialized the timestamp lists.')\n\n bar = progressbar.ProgressBar() if verbose else lambda x: x\n\n max_num_events = 5\n\n for type_of_event in bar(np.unique(types)):\n timestamps_left = np.array(timestamps_dict[True][type_of_event])\n timestamp_indices_left = timestamp_indices_dict[True][type_of_event]\n timestamps_right = np.array(timestamps_dict[False][type_of_event])\n timestamp_indices_right = timestamp_indices_dict[False][type_of_event]\n\n num_right_events = timestamps_right.shape[0]\n\n for event_idx, (ts_right, ts_idx_right) in enumerate(zip(timestamps_right, timestamp_indices_right)):\n matched_indices = np.where((timestamps_left >= ts_right - max_itd) &\n (timestamps_left < ts_right + max_itd))[0]\n if matched_indices.size > 0:\n matched_itds = ts_right - timestamps_left[matched_indices]\n min_itd_idx_local = np.argmin(np.abs(matched_itds))\n min_itd = matched_itds[min_itd_idx_local]\n # absolute index of the itd pair event\n min_itd_ts_left = ts_right - min_itd\n # now check that the itd pair for the itd pair event is the current event\n if event_idx < max_num_events:\n min_itd_ts_right = timestamps_right[0: event_idx + max_num_events + 1]\n alt_min_itd_idx = np.argmin(np.abs(min_itd_ts_left - min_itd_ts_right))\n if alt_min_itd_idx == event_idx:\n itds_to_return[ts_idx_right] = min_itd\n else:\n min_itd_ts_right = timestamps_right[event_idx - max_num_events: event_idx + max_num_events + 1]\n alt_min_itd_idx = np.argmin(np.abs(min_itd_ts_left - min_itd_ts_right))\n if alt_min_itd_idx == max_num_events:\n itds_to_return[ts_idx_right] = min_itd\n if min_itd_ts_right[0] > min_itd_ts_left - max_itd or min_itd_ts_right[-1] < min_itd_ts_left + max_itd:\n print('[WARNING] The max_num_events is not enough, please check.')\n sys.stdout.flush()\n\n itd_indices = np.where(itds_to_return > -4. * max_itd)[0]\n itds_to_return = itds_to_return[itd_indices]\n if save_to_file is not None:\n np.savez(save_to_file, timestamps=timestamps[itd_indices], ears=ears[itd_indices], types=types[itd_indices],\n itds=itds_to_return, itd_indices=itd_indices)\n\n if return_itd_indices:\n return itds_to_return, itd_indices\n\n return itds_to_return","def get_indices(self):\r\n return self._indices","def mainIndices(self):\n return self.i1, self.i2","def get_img_indices():\n if K.image_dim_ordering() == 'th':\n return 0, 1, 2, 3\n else:\n return 0, 3, 1, 2","def getNegativeSamples(target, dataset, K):\n\n indices = [None] * K\n for k in range(K):\n newidx = dataset.sampleTokenIdx()\n while newidx == target:\n newidx = dataset.sampleTokenIdx()\n indices[k] = newidx\n return indices","def unravel_index(ijk, n):\n \n if type(ijk) is int:\n return ijk\n if len(ijk)==1:\n return ijk[0]\n\n assert (np.diff(ijk)>0).all()\n assert all([i<n for i in ijk])\n\n ix = sum([int(binom(n-1-i,len(ijk)-1)) for i in range(ijk[0])])\n for d in range(1, len(ijk)-1):\n if (ijk[d]-ijk[d-1])>1:\n ix += sum([int(binom(n-i-1,len(ijk)-d-1)) for i in range(ijk[d-1]+1, ijk[d])])\n ix += ijk[-1] -ijk[-2] -1\n return ix","def getNegativeSamples(target, dataset, K):\n\n indices = [None] * K\n for k in xrange(K):\n newidx = dataset.sampleTokenIdx()\n while newidx == target:\n newidx = dataset.sampleTokenIdx()\n indices[k] = newidx\n return indices","def getNegativeSamples(target, dataset, K):\n\n indices = [None] * K\n for k in xrange(K):\n newidx = dataset.sampleTokenIdx()\n while newidx == target:\n newidx = dataset.sampleTokenIdx()\n indices[k] = newidx\n return indices","def getNegativeSamples(target, dataset, K):\n\n indices = [None] * K\n for k in xrange(K):\n newidx = dataset.sampleTokenIdx()\n while newidx == target:\n newidx = dataset.sampleTokenIdx()\n indices[k] = newidx\n return indices","def _extract_t_indices(self, X, X2=None, dL_dK=None):\r\n\r\n # TODO: some fast checking here to see if this needs recomputing?\r\n self._t = X[:, 0]\r\n if not X.shape[1] == 2:\r\n raise ValueError('Input matrix for ode1 covariance should have two columns, one containing times, the other output indices')\r\n self._index = np.asarray(X[:, 1],dtype=np.int)\r\n # Sort indices so that outputs are in blocks for computational\r\n # convenience.\r\n self._order = self._index.argsort()\r\n self._index = self._index[self._order]\r\n self._t = self._t[self._order]\r\n self._rorder = self._order.argsort() # rorder is for reversing the order\r\n \r\n if X2 is None:\r\n self._t2 = None\r\n self._index2 = None\r\n self._order2 = self._order\r\n self._rorder2 = self._rorder\r\n else:\r\n if not X2.shape[1] == 2:\r\n raise ValueError('Input matrix for ode1 covariance should have two columns, one containing times, the other output indices')\r\n self._t2 = X2[:, 0]\r\n self._index2 = np.asarray(X2[:, 1],dtype=np.int)\r\n self._order2 = self._index2.argsort()\r\n self._index2 = self._index2[self._order2]\r\n self._t2 = self._t2[self._order2]\r\n self._rorder2 = self._order2.argsort() # rorder2 is for reversing order\r\n\r\n if dL_dK is not None:\r\n self._dL_dK = dL_dK[self._order, :]\r\n self._dL_dK = self._dL_dK[:, self._order2]","def _getscanind(self):\n \n zamin = self.za.min()\n first = np.where(self.za==zamin)[0]\n self.scan = np.zeros(self.spec.shape[0])\n if zamin < 0:\n cs = first[np.where((first - np.roll(first, 1)) != 1)[0]]\n ss = first[np.where((np.roll(first,-1) - first) != 1)[0]] + 1\n ce = ss \n se = np.roll((cs - 1) % self.za.size, -1) + 1\n for k, val in enumerate(cs):\n self.scan[val:se[k] + 1] = k\n else:\n moves = np.diff(self.za)\n max_ind = np.where(moves==moves.max())[0]\n turnover = self.za.size\n diffs = np.diff(max_ind)\n if np.unique(diffs).size > 1:\n raise ValueError, 'Can\\'t deal with non-uniform cal data yet.'\n if max_ind.size > 1:\n turnover = diffs[0]\n cs = ce = np.array([])\n ss = np.arange(self.za.size)[::turnover]\n se = np.roll((ss - 1) % self.za.size, -1)\n for k, val in enumerate(ss):\n self.scan[val:se[k] + 1] = k\n \n self.ind = {'cs': cs, 'ce': ce, 'ss': ss, 'se': se}\n self.nscan = np.unique(self.scan).size","def test_total_totals_index():\n pressure = np.array([1008., 1000., 947., 925., 921., 896., 891., 889., 866.,\n 858., 850., 835., 820., 803., 733., 730., 700., 645.,\n 579., 500., 494., 466., 455., 441., 433., 410., 409.,\n 402., 400., 390., 388., 384., 381., 349., 330., 320.,\n 306., 300., 278., 273., 250., 243., 208., 200., 196.,\n 190., 179., 159., 151., 150., 139.]) * units.hPa\n temperature = np.array([27.4, 26.4, 22.9, 21.4, 21.2, 20.7, 20.6, 21.2, 19.4,\n 19.1, 18.8, 17.8, 17.4, 16.3, 11.4, 11.2, 10.2, 6.1,\n 0.6, -4.9, -5.5, -8.5, -9.9, -11.7, -12.3, -13.7, -13.8,\n -14.9, -14.9, -16.1, -16.1, -16.9, -17.3, -21.7, -24.5, -26.1,\n -28.3, -29.5, -33.1, -34.2, -39.3, -41., -50.2, -52.5, -53.5,\n -55.2, -58.6, -65.2, -68.1, -68.5, -72.5]) * units.degC\n dewpoint = np.array([24.9, 24.6, 22., 20.9, 20.7, 14.8, 13.6, 12.2, 16.8,\n 16.6, 16.5, 15.9, 13.6, 13.2, 11.3, 11.2, 8.6, 4.5,\n -0.8, -8.1, -9.5, -12.7, -12.7, -12.8, -13.1, -24.7, -24.4,\n -21.9, -24.9, -36.1, -31.1, -26.9, -27.4, -33., -36.5, -47.1,\n -31.4, -33.5, -40.1, -40.8, -44.1, -45.6, -54., -56.1, -56.9,\n -58.6, -61.9, -68.4, -71.2, -71.6, -77.2]) * units.degC\n\n tt = total_totals_index(pressure, temperature, dewpoint)\n assert_almost_equal(tt, 45.10 * units.delta_degC, 2)","def generate_index(self):\n begin_o, end_o, begin_a, end_a = 0, 0, 0, 0\n for obs_space, act_space in zip(self.env.observation_space, self.env.action_space):\n end_o = end_o + obs_space.shape[0]\n if isinstance(act_space, Box):\n end_a = act_space.shape[0]\n else:\n end_a = act_space.n\n range_o = (begin_o, end_o)\n range_a = (begin_a, end_a)\n self.observation_index.append(range_o)\n self.action_index.append(range_a)\n begin_o = end_o\n begin_a = end_a","def getstate(self):\r\n return [self.tied_indices,\r\n self.fixed_indices,\r\n self.fixed_values,\r\n self.constrained_indices,\r\n self.constraints]","def getNeighbours(seg,meta,inversedIndex):\n return np.unique(np.fromiter( (inversedIndex[x] for x in np.concatenate([meta.loc[seg]['ins'],meta.loc[seg]['outs']])),dtype=np.int))","def test_gleckler_index(self):\n\n # generate sample data\n # sample data\n tmp = np.zeros((5, 3, 1))\n tmp[:,0,0] = np.ones(5)*1.\n tmp[:,1,0] = np.ones(5)*2.\n tmp[:,2,0] = np.ones(5)*5.\n\n # The data is like ...\n #| 1 | 2 | 5 |\n #| 1 | 2 | 5 |\n #| 1 | 2 | 5 |\n #| 1 | 2 | 5 |\n #| 1 | 2 | 5 |\n\n x = self.D.copy()\n x._temporal_subsetting(0, 4)\n\n x.data = np.ma.array(tmp, mask=tmp!=tmp)\n x.std = np.ones(x.data.shape)\n x.time[0] = pl.datestr2num('2000-02-15')\n x.time[1] = pl.datestr2num('2000-03-15')\n x.time[2] = pl.datestr2num('2000-04-15')\n x.time[3] = pl.datestr2num('2000-05-15')\n x.time[4] = pl.datestr2num('2000-06-15')\n\n y = self.D.copy()\n y._temporal_subsetting(0, 4)\n tmp = np.ones(x.data.shape) # sample data 2\n y.data = np.ma.array(tmp, mask=tmp!=tmp)\n y.time[0] = pl.datestr2num('2000-02-15')\n y.time[1] = pl.datestr2num('2000-03-15')\n y.time[2] = pl.datestr2num('2000-04-15')\n y.time[3] = pl.datestr2num('2000-05-15')\n y.time[4] = pl.datestr2num('2000-06-15')\n\n # Case 1: same area weights\n # cell area\n tmp = np.ones((3, 1))\n x.cell_area = tmp*1.\n\n #| 1-1 | 2-1 | 5-1 |\n #| 1-1 | 2-1 | 5-1 |\n #| 1-1 | 2-1 | 5-1 |\n #| 1-1 | 2-1 | 5-1 |\n #| 1-1 | 2-1 | 5-1 |\n #===================\n #| 0 | 5 | 5*4**2=5*16. = 80 |\n #==> E2 = sqrt(85./(15.))\n D = GlecklerPlot()\n r = D.calc_index(x, y, 'a', 'b', time_weighting=False)\n\n wt = np.ones(5) / 5.\n ref = np.sqrt(((85./15.) * wt).sum())\n t = np.abs(1. - r / ref)\n self.assertLess(t, 0.000001) # relative error\n\n D = GlecklerPlot()\n r = D.calc_index(x, y, 'a', 'b')\n\n wt = np.asarray([29., 31., 30., 31., 30.])\n wt = wt / wt.sum()\n ref = np.sqrt(((85./15.) * wt).sum())\n t = np.abs(1. - r / ref)\n self.assertLess(t, 0.000001) # relative error\n\n\n\n # Case 2: Different area weights\n # cell area\n tmp = np.ones((3, 1))\n tmp[1, 0] = 2.\n x.cell_area = tmp*1.\n\n #| 1-1=0 | 2-1=1 | 5-1=16 |\n #| 1-1=0 | 2-1=1 | 5-1=16 |\n #| 1-1=0 | 2-1=1 | 5-1=16 |\n #| 1-1=0 | 2-1=1 | 5-1=16 |\n #| 1-1=0 | 2-1=1 | 5-1=16 |\n #--------------------------\n # w = 0.25 w = 0.5 w=0.25|\n #--------------------------\n\n # 0.25*0 + 0.5 * 1 + 0.25 * 16 = 0 + 0.5 + 4 = 4.5\n # the mean of that is 4.5 for each timestep\n # mean because the overall weights are calculated as such that\n # they give a total weight if 1\n\n # diagnostic\n D = GlecklerPlot()\n r = D.calc_index(x, y, 'a', 'b', time_weighting=False)\n\n wt = np.ones(5) / 5.\n ref = np.sqrt((4.5 * wt).sum())\n t = np.abs(1. - r / ref)\n self.assertLess(t, 0.000001) # relative error\n\n wt = np.asarray([29., 31., 30., 31., 30.])\n wt = wt / wt.sum()\n ref = np.sqrt((4.5 * wt).sum())\n t = np.abs(1. - r / ref)\n self.assertLess(t, 0.000001) # relative error\n\n # Case 3: use different std\n x.std = np.ones(x.data.shape)\n x.std[:, 2, 0] = 0.5\n\n #| 1-1=0 | 2-1=1 | 5-1=16 / 0.5 |\n #| 1-1=0 | 2-1=1 | 5-1=16 / 0.5 |\n #| 1-1=0 | 2-1=1 | 5-1=16 / 0.5 |\n #| 1-1=0 | 2-1=1 | 5-1=16 / 0.5 |\n #| 1-1=0 | 2-1=1 | 5-1=16 / 0.5 |\n #--------------------------------\n # w = 0.25 w = 0.5 w=0.25|\n # 0 + 0.5 + 0.25*32 = 0.5 + 8 = 8.5\n\n D = GlecklerPlot()\n r = D.calc_index(x, y, 'a', 'b', time_weighting=False)\n\n wt = np.ones(5) / 5.\n ref = np.sqrt((8.5 * wt).sum())\n t = np.abs(1. - r / ref)\n self.assertLess(t, 0.000001) # relative error\n\n wt = np.asarray([29., 31., 30., 31., 30.])\n wt = wt / wt.sum()\n ref = np.sqrt((8.5 * wt).sum())\n t = np.abs(1. - r / ref)\n self.assertLess(t, 0.000001) # relative error","def ztost_ind(self, low, upp, usevar=\"pooled\"):\n tt1 = self.ztest_ind(alternative=\"larger\", usevar=usevar, value=low)\n tt2 = self.ztest_ind(alternative=\"smaller\", usevar=usevar, value=upp)\n # TODO: remove tuple return, use same as for function tost_ind\n return np.maximum(tt1[1], tt2[1]), tt1, tt2","def get_gt_hom_idxs(alt_num):\n last = -1\n hom_idxs = []\n for a in range(alt_num + 1):\n last = last + (a + 1)\n hom_idxs.append(last)\n return hom_idxs","def index_dict(self):\n msk = self.load_mask()\n mski = enumerate(msk)\n ifiltered = (i for (i, m) in mski if m == 1)\n return {i: j for (j, i) in enumerate(ifiltered)}","def index_dict(self):\n msk = self.load_mask()\n mski = enumerate(msk)\n ifiltered = (i for (i, m) in mski if m == 1)\n return {i: j for (j, i) in enumerate(ifiltered)}","def tril_indices(n,k=0):\r\n return mask_indices(n,tril,k)","def indices(self):\n return tuple([slice(*r) for r in self.location])","def create_repeated_indexes(data):\n from numpy import arange\n\n index_range = arange(0, len(data))\n return (index_range for i in index_range)","def morton_idx(pts):\n lib = _initlib()\n p = require(pts, dtype=float64, requirements=['C']) \n inv_cell_width = 1.0/8192\n npts = len(p)\n out = empty(npts, dtype=int64)\n lib.get_morton_idx(p, npts, inv_cell_width, out)\n return out"],"string":"[\n \"def get_pulling_indices(self, weight):\\n pass\",\n \"def getBreakIndices(self):\\n for i in self.raw.index[:-1]:\\n if self.raw['stress'][i+1] > self.raw['stress'][i] and \\\\\\n self.raw['stress'][i+2] < self.raw['stress'][i+1]:\\n brkIdx1 = i+1 # brkIdx1: start of the first unloading\\n break\\n if self.reloading:\\n for i in self.raw.index[brkIdx1+1:-1]:\\n if self.raw['stress'][i+1] < self.raw['stress'][i] and \\\\\\n self.raw['stress'][i+2] > self.raw['stress'][i+1]:\\n brkIdx2 = i+1 # brkIdx2: end of the first unloading\\n break\\n # brkIdx3: Point on the NCL after the first reloading\\n brkIdx3 = self.raw.query(f'stress == stress[{brkIdx1}]').index[1]\\n # brkIdx4: index of the last point on the NCL\\n brkIdx4 = self.raw.query('stress == stress.max()').index[0]\\n self.secondUnloading = False\\n else:\\n brkIdx2 = self.raw.index[-1]\\n brkIdx3 = None\\n brkIdx4 = None\\n\\n self.brkIdx1 = brkIdx1\\n self.brkIdx2 = brkIdx2\\n self.brkIdx3 = brkIdx3\\n self.brkIdx4 = brkIdx4\\n return\",\n \"def get_indices(waves):\\n prob_ = np.abs(waves)**2\\n # batch\\n prob = [np.sum(prob_[i:i+4,:], axis=0) for i in range(0, len(waves[:,0]), 4)]\\n prob = np.asarray(prob)\\n prob_tot = np.sum(prob, axis=0)\\n \\n # cutoff\\n length = np.size(prob[:,0])\\n len10 = int(length/10)\\n flags = np.zeros((prob.shape[1]), dtype=int)\\n # hinges\\n # 50% within 10% of corners\\n\\n # surface\\n # 50% within 10% of surfaces\\n # not already labelled hinges\\n prob_left = np.sum(prob[0:len10,:], axis=0)\\n frac_left = prob_left/prob_tot\\n\\n prob_right = np.sum(prob[length-len10:length,:], axis=0)\\n frac_right = np.divide(prob_right, prob_tot)\\n\\n for i in range(len(flags)):\\n if frac_left[i]>0.5 or frac_right[i]>0.5:\\n flags[i] = 1\\n \\n indices = [i for i, x in enumerate(flags) if x == 1]\\n indices0 = [i for i, x in enumerate(flags) if x == 0]\\n \\n return indices, indices0\",\n \"def get_out_idx():\\n exacz = pd.read_csv(f'{home}/ref/exac/exac_zscore_mimssense+stopgain_gn_checked.txt', sep='\\\\t')\\n exacz = exacz[['gn', 'conseq', 'exac_z', 'exac_zrank']]\\n\\n gdi = pd.read_csv(f'{home}/work/generisk/gdi/gdi_score_pnas_gn_checked.txt', sep=\\\"\\\\t\\\")\\n gdi = gdi[['gn', 'gdi', 'gdi_phred_raw']]\\n gdi['gdi_rank'] = 100 - round(gdi['gdi'].rank() / len(gdi.index) * 100, 2)\\n\\n rvis = pd.read_csv(f\\\"{home}/ref/rvis/rvis_lite.txt\\\", sep='\\\\t')\\n\\n out_idx = pd.merge(exacz, gdi, on='gn', how='outer')\\n out_idx = pd.merge(out_idx, rvis, on='gn', how='outer')\\n\\n # merge with omim\\n omim = pd.read_csv(f\\\"{home}/ref/omim/omim_dedup.tsv\\\", sep='\\\\t', usecols='gn,inher'.split(\\\",\\\"))\\n out_idx = pd.merge(out_idx, omim, on='gn', how='left')\\n out_idx['inher'] = out_idx['inher'].fillna('na')\\n\\n # 18090\\n out_idx = out_idx.loc[out_idx.conseq == 'missense_variant'].drop('conseq', axis=1)\\n\\n out_idx.to_pickle(f'{home}/gr/final/out_idx.pk')\\n\\n return out_idx\",\n \"def construct_indices(after_pooling):\\n our_indices = np.zeros_like(after_pooling, dtype=np.int64)\\n batch_num, channel_num, row_num, col_num = after_pooling.shape\\n for batch_id in range(batch_num):\\n for channel_id in range(channel_num):\\n for row_id in range(row_num):\\n for col_id in range(col_num):\\n our_indices[batch_id, channel_id, row_id, col_id] = col_num * 2 * 2 * row_id + 2 * col_id\\n return torch.from_numpy(our_indices)\",\n \"def _get_indexes(self, participants):\\n tr_idx = int(np.floor(self.tr_size*len(participants)))\\n j = self.val_size + self.tr_size\\n val_idx = int(np.floor(j*len(participants)))\\n return tr_idx, val_idx\",\n \"def get_output_slice_idx(self, output_index):\\r\\n ipos = 0\\r\\n opos = output_index\\r\\n for otaps in zip(self.mitmot_out_taps()):\\r\\n if len(otaps) > 0:\\r\\n return ipos\\r\\n else:\\r\\n opos = opos - 1\\r\\n ipos += len(otaps)\\r\\n return ipos + opos\",\n \"def _get_indx(self, t):\\n t = np.array(t)\\n a = (t[:, np.newaxis] <= self._data['stop']) & (t[:, np.newaxis] >=\\n self._data['start'])\\n return np.array([np.where(row)[0][0] for row in a])\",\n \"def pt_index(*args):\\n index = []\\n x = check_pt_data(args[0])\\n i = 0\\n for line in args[0].Data.PTData.pt_data:\\n i += 1\\n if line != x[i - 1]:\\n index.append(0)\\n elif line == x[i - 1]:\\n index.append(i)\\n return index\",\n \"def get_cv_indices(df, col, time_slices):\\n return [\\n ## get train and holdout indices for slice\\n tuple(get_row_indices(df, col, slc[x]) for x in range(2))\\n\\n ## get indices for each slice\\n for slc in time_slices\\n ]\",\n \"def indxmap_diff(Nd): \\n\\n ndims = len(Nd)\\n Ndprod = numpy.prod(Nd)\\n mylist = numpy.arange(0, Ndprod).astype(numpy.int32)\\n mylist = numpy.reshape(mylist, Nd)\\n d_indx = []\\n dt_indx = []\\n for pp in range(0, ndims):\\n d_indx = d_indx + [ numpy.reshape( numpy.roll( mylist, +1 , pp ), (Ndprod,) ,order='C').astype(numpy.int32) ,]\\n dt_indx = dt_indx + [ numpy.reshape( numpy.roll( mylist, -1 , pp ) , (Ndprod,) ,order='C').astype(numpy.int32) ,]\\n\\n return d_indx, dt_indx\",\n \"def _sort_index(self):\\n\\n allAltPos = np.array(sorted(list(set(list(self.data['altitude'])))))[::-1]\\n allAziPos = np.array(sorted(list(set(list(self.data['azimuth'])))))\\n\\n indON = [[None for azi in allAziPos] for alt in allAltPos]; indOFF = [[None for azi in allAziPos] for alt in allAltPos]\\n\\n for i, traceItem in enumerate(self.data):\\n alt = traceItem['altitude'];azi = traceItem['azimuth'];sign = traceItem['sign']\\n for j, altPos in enumerate(allAltPos):\\n for k, aziPos in enumerate(allAziPos):\\n if alt==altPos and azi==aziPos:\\n if sign==1:\\n if indON[j][k] is not None: raise LookupError('Duplication of trace items found at location:'+str([alt, azi])+'; sign: 1!')\\n else: indON[j][k]=i\\n\\n if sign==-1:\\n if indOFF[j][k] is not None: raise LookupError('Duplication of trace items found at location:'+str([alt, azi])+'; sign:-1!')\\n else: indOFF[j][k]=i\\n\\n indON = np.array([np.array(x) for x in indON]); indOFF = np.array([np.array(x) for x in indOFF])\\n\\n return indON,indOFF,allAltPos,allAziPos\",\n \"def get_34index_list(self):\\n msk = self.load_mask()\\n return [i for (i,v) in enumerate(msk) if v==1]\",\n \"def time_window_bins(self, t0, tend):\\n indexes = []\\n for level in range(self._max_level):\\n for i in range(2**level):\\n local_times = self.partial_time_interval(level, i)\\n if t0 >= local_times['t0'] and t0 < local_times['tend']:\\n indexes.append(self._index_list(level, i))\\n if tend > local_times['t0'] and tend <= local_times['tend']:\\n indexes.append(self._index_list(level, i))\\n if t0 <= local_times['t0'] and tend >= local_times['tend']:\\n indexes.append(self._index_list(level, i))\\n # Remove duplicates if they exist\\n # indexes = list(dict.fromkeys(indexes)) # Python 3.7 or later (preserve order)\\n indexes = list(set(indexes)) # Any Python version, but does not preserve order\\n indexes = np.sort(indexes)\\n return indexes\",\n \"def ordered_indices(self):\\n return self.base_dataset.ordered_indices()\",\n \"def get_final_pruned_indices(self):\\n return self.final_pruned_indices\",\n \"def get_indices_input_target(num_obs, input_len, step_size, forecast_horizon, target_len):\\n input_len = round(input_len) # just a precaution\\n start_position = 0\\n stop_position = num_obs - 1\\n\\n inpseq_first_idx = start_position\\n inpseq_last_idx = inpseq_first_idx + input_len\\n target_first_idx = inpseq_last_idx + forecast_horizon\\n target_last_idx = target_first_idx + target_len\\n print(\\\"target_last_idx = {}\\\".format(target_last_idx))\\n print(\\\"stop_position = {}\\\".format(stop_position))\\n indices = []\\n while target_last_idx <= stop_position:\\n indices.append((inpseq_first_idx, inpseq_last_idx, target_first_idx, target_last_idx))\\n inpseq_first_idx += step_size\\n inpseq_last_idx += step_size\\n target_first_idx += inpseq_last_idx + forecast_horizon\\n target_last_idx += target_first_idx + target_len\\n return indices\",\n \"def get_data_indices(aperiodic_mode):\\n\\n indices = {\\n 'CF' : 0,\\n 'PW' : 1,\\n 'BW' : 2,\\n 'offset' : 0,\\n 'knee' : 1 if aperiodic_mode == 'knee' else None,\\n 'exponent' : 1 if aperiodic_mode == 'fixed' else 2\\n }\\n\\n return indices\",\n \"def get_indexes(self, dataset):\\n\\n for i in range(self.max_iters):\\n index = random.randint(0, len(dataset))\\n gt_bboxes_i = dataset.get_ann_info(index)['bboxes']\\n if len(gt_bboxes_i) != 0:\\n break\\n\\n return index\",\n \"def get_index(ks):\\n unq_vals, unq_ix = np.unique(ks[:, 0], return_index=True)\\n return np.vstack([unq_vals, unq_ix]).T\",\n \"def test_lifted_index():\\n pressure = np.array([1014., 1000., 997., 981.2, 947.4, 925., 914.9, 911.,\\n 902., 883., 850., 822.3, 816., 807., 793.2, 770.,\\n 765.1, 753., 737.5, 737., 713., 700., 688., 685.,\\n 680., 666., 659.8, 653., 643., 634., 615., 611.8,\\n 566.2, 516., 500., 487., 484.2, 481., 475., 460.,\\n 400.]) * units.hPa\\n temperature = np.array([24.2, 24.2, 24., 23.1, 21., 19.6, 18.7, 18.4,\\n 19.2, 19.4, 17.2, 15.3, 14.8, 14.4, 13.4, 11.6,\\n 11.1, 10., 8.8, 8.8, 8.2, 7., 5.6, 5.6,\\n 5.6, 4.4, 3.8, 3.2, 3., 3.2, 1.8, 1.5,\\n -3.4, -9.3, -11.3, -13.1, -13.1, -13.1, -13.7, -15.1,\\n -23.5]) * units.degC\\n dewpoint = np.array([23.2, 23.1, 22.8, 22., 20.2, 19., 17.6, 17.,\\n 16.8, 15.5, 14., 11.7, 11.2, 8.4, 7., 4.6,\\n 5., 6., 4.2, 4.1, -1.8, -2., -1.4, -0.4,\\n -3.4, -5.6, -4.3, -2.8, -7., -25.8, -31.2, -31.4,\\n -34.1, -37.3, -32.3, -34.1, -37.3, -41.1, -37.7, -58.1,\\n -57.5]) * units.degC\\n parcel_prof = parcel_profile(pressure, temperature[0], dewpoint[0])\\n li = lifted_index(pressure, temperature, parcel_prof)\\n assert_almost_equal(li, -7.9115691 * units.delta_degree_Celsius, 2)\",\n \"def window_inds(dataset, window_sz, overlap):\\r\\n\\tdata_len = len(dataset[0])\\r\\n\\tassert window_sz < data_len\\r\\n\\tind1 = 0\\r\\n\\tind2 = window_sz-1\\r\\n\\tind_list = []\\r\\n\\tov_ind_diff = int(np.ceil(np.abs(overlap*window_sz)))\\r\\n\\tif ov_ind_diff == window_sz:\\r\\n\\t\\tov_ind_diff += -1\\r\\n\\twhile ind2 < data_len:\\r\\n\\t\\tind_list.append((ind1,ind2))\\r\\n\\t\\tind1 += window_sz-ov_ind_diff\\r\\n\\t\\tind2 += window_sz-ov_ind_diff\\r\\n\\treturn ind_list\",\n \"def _topological_sort_timestamp_index(self) -> Iterator[BaseTransaction]:\\n raise NotImplementedError\",\n \"def indices(self):\\n _indices = []\\n for h in self.miller.indices():\\n _indices.append(self.indices_hkl(*h)[0])\\n return _indices\",\n \"def FindIdxValues(X):\\n data = X.select_dtypes(include=[\\\"float64\\\"])\\n idx = np.argwhere(~np.isnan(data.values))\\n idx[:, 1] += 4 # add ID variable columns\\n StoE = pd.read_csv(\\\"msresist/data/MS/CPTAC/IDtoExperiment.csv\\\")\\n assert all(StoE.iloc[:, 0] == data.columns), \\\"Sample labels don't match.\\\"\\n StoE = StoE.iloc[:, 1].values\\n tmt = [[StoE[idx[ii][1] - 4]] for ii in range(idx.shape[0])]\\n return np.append(idx, tmt, axis=1)\",\n \"def _exclude_indices(self):\\n idx = self._next_idx\\n exclude = np.arange(idx - 1, idx + self.obs_len) % self._maxsize\\n return exclude\",\n \"def get_main_points(neuron):\\n (branch_index,) = np.where(neuron.branch_order[neuron.n_soma:] == 2)\\n (endpoint_index,) = np.where(neuron.branch_order[neuron.n_soma:] == 0)\\n selected_index = np.union1d(branch_index + neuron.n_soma,\\n endpoint_index + neuron.n_soma)\\n selected_index = np.append(range(neuron.n_soma), selected_index)\\n return selected_index\",\n \"def vir_indices(self):\\n indices = []\\n for index,item in enumerate(self):\\n if item==0:\\n indices.append(index)\\n return indices\",\n \"def get_prediction_indices(self):\\r\\n if self.full_df['Dates'][0] > self.full_df['Dates'][len(self.full_df) - 1]:\\r\\n self.full_df = self.full_df[::-1]\\r\\n self.full_df.reset_index(inplace=True)\\r\\n self.full_df.drop('index', axis=1, inplace=True)\\r\\n date_condition = ((self.full_df['Dates'] <= self.pred_end) &\\r\\n (self.full_df['Dates'] >= self.pred_start))\\r\\n self.pred_indices = list(self.full_df[date_condition].index)\",\n \"def step_indices(group_idx):\\n ilen = step_count(group_idx) + 1\\n indices = np.empty(ilen, np.int64)\\n indices[0] = 0\\n indices[-1] = group_idx.size\\n cmp_pos = 0\\n ri = 1\\n for i in range(len(group_idx)):\\n if group_idx[cmp_pos] != group_idx[i]:\\n cmp_pos = i\\n indices[ri] = i\\n ri += 1\\n return indices\",\n \"def index(self):\\n # Check is multiple orders were given\\n try:\\n orders = list(iter(self.orders))\\n except TypeError:\\n orders = [self.orders]\\n sites = self._epistasismap.sites\\n x = [i for i in range(1, len(sites)) if len(sites[i]) in orders]\\n # Add the zeroth element if included\\n if 0 in orders:\\n x = [0] + x\\n return np.array(x)\",\n \"def bprop_sparse_tensor_get_indices(sparse_tensor, out, dout):\\n return (zeros_like(sparse_tensor),)\",\n \"def get_time_index():\\n\\n def get_common_list(map):\\n res = set()\\n first = True\\n for _, value in map.items():\\n if first:\\n res = set(value)\\n first = False\\n else:\\n res = res.intersection(value)\\n return list(res)\\n\\n # get common time for 3 cities\\n demand_map = {}\\n for city in ['beijing', 'tianjing', 'guangzhou']:\\n demand_map[city] = []\\n for file in os.listdir(exp_data_path + os.sep + 'station' + os.sep + city):\\n demand_map[city].append(file[0:12])\\n\\n\\n # get weather time\\n weather_map = {}\\n for city in ['beijing', 'tianjing', 'guangzhou']:\\n weather_map[city] = []\\n for file in os.listdir(spider_data_path + os.sep + 'weather' + os.sep + city):\\n with open(spider_data_path + os.sep + 'weather' + os.sep + city + os.sep + file) as f:\\n reader = csv.reader(f)\\n for line in reader:\\n # t = line[0].replace(\\\"\\\\ufeff\\\", \\\"\\\")\\n weather_map[city].append(line[0].replace(\\\"\\\\ufeff\\\", \\\"\\\"))\\n\\n demand_res = get_common_list(demand_map)\\n weather_res = get_common_list(weather_map)\\n res = get_common_list({'demand': demand_res, 'weather': weather_res})\\n res = sorted(res)\\n print(len(res))\\n print(res)\\n\\n\\n time_index = {'index': {}, 'rev_index': {}}\\n index = 0\\n for time in res:\\n time_index['index'][index] = time\\n time_index['rev_index'][time] = index\\n index = index + 1\\n\\n file_name = exp_data_path + os.sep + 'station_list' + os.sep + 'time_index.npy'\\n if os.path.exists(file_name):\\n os.remove(file_name)\\n np.save(file_name, time_index)\",\n \"def ordered_indices(self):\\r\\n return np.arange(len(self), dtype=np.int64)\",\n \"def _get_block_indices(y):\\n block_labels, block_inv, block_sizes = np.unique(\\n y, return_inverse=True, return_counts=True\\n )\\n\\n n_blocks = len(block_labels)\\n block_inds = range(n_blocks)\\n\\n block_vert_inds = []\\n for i in block_inds:\\n # get the inds from the original graph\\n inds = np.where(block_inv == i)[0]\\n block_vert_inds.append(inds)\\n return block_vert_inds, block_inds, block_inv\",\n \"def _selected_indices(self, subset):\\n # We want the DataFrame to be indexed the same way its values array is\\n ftr = self.frametracks.reset_index(drop=True)\\n if subset is not None:\\n ftr['tmpindex'] = ftr.index.values\\n ftr = ftr.set_index('particle').reindex(subset).set_index('tmpindex')\\n if self.autoclip:\\n # Boundaries are computed for the whole system\\n xmin = self.frametracks.x.min() + self.nncutoff\\n xmax = self.frametracks.x.max() - self.nncutoff\\n ymin = self.frametracks.y.min() + self.nncutoff\\n ymax = self.frametracks.y.max() - self.nncutoff\\n r = ftr.index[ (ftr.x > xmin) & (ftr.x < xmax) & \\\\\\n (ftr.y > ymin) & (ftr.y < ymax) ].values.astype(int)\\n else:\\n r = ftr.index.values.astype(int)\\n if self.fast:\\n return np.random.permutation(r)[:int(len(r) / 10)]\\n else:\\n return r\",\n \"def relevant_indexes(data, min_threshold):\\n\\n start_index = 1\\n end_index = len(data) - 1\\n\\n for i in range(len(data)):\\n if data[i] > min_threshold:\\n start_index = i\\n break\\n\\n for i in range(len(data)):\\n if data[::-1][i] > min_threshold:\\n end_index = i\\n break\\n\\n return start_index, end_index\",\n \"def get_index_from_well(self, well):\\n pass\",\n \"def sorted_index(self) -> np.ndarray:\\n return np.argsort(self.result_array.sum(axis=1))[::-1]\",\n \"def break_index(self, **kwargs):\\n return self.peak_indices(**kwargs)[0][-1]\",\n \"def get_itds(timestamps, ears, types, max_itd=800e-6, save_to_file=None, verbose=False, return_itd_indices=False):\\n ears = ears.astype(np.bool)\\n itds_to_return = np.zeros(timestamps.size, dtype=np.float32)\\n itds_to_return.fill(-5. * max_itd)\\n\\n timestamps_dict = {}\\n timestamp_indices_dict = {}\\n for ear in np.unique(ears):\\n timestamps_dict[ear] = {}\\n timestamp_indices_dict[ear] = {}\\n for type_of_event in np.unique(types):\\n timestamps_dict[ear][type_of_event] = []\\n timestamp_indices_dict[ear][type_of_event] = []\\n\\n for idx, (timestamp, ear, type_of_event) in enumerate(zip(timestamps, ears, types)):\\n timestamps_dict[ear][type_of_event].append(timestamp)\\n timestamp_indices_dict[ear][type_of_event].append(idx)\\n\\n if verbose:\\n print('Initialized the timestamp lists.')\\n\\n bar = progressbar.ProgressBar() if verbose else lambda x: x\\n\\n for type_of_event in bar(np.unique(types)):\\n timestamps_left = np.array(timestamps_dict[True][type_of_event])\\n timestamp_indices_left = timestamp_indices_dict[True][type_of_event]\\n timestamps_right = np.array(timestamps_dict[False][type_of_event])\\n timestamp_indices_right = timestamp_indices_dict[False][type_of_event]\\n\\n for ts_right, ts_idx_right in zip(timestamps_right, timestamp_indices_right):\\n matched_indices = np.where((timestamps_left >= ts_right - max_itd) &\\n (timestamps_left < ts_right + max_itd))[0]\\n if matched_indices.size > 0:\\n matched_itds = ts_right - timestamps_left[matched_indices]\\n min_itd = np.argmin(np.abs(matched_itds))\\n itds_to_return[ts_idx_right] = matched_itds[min_itd]\\n\\n for ts_left, ts_idx_left in zip(timestamps_left, timestamp_indices_left):\\n matched_indices = np.where((timestamps_right >= ts_left - max_itd) &\\n (timestamps_right < ts_left + max_itd))[0]\\n if matched_indices.size > 0:\\n matched_itds = timestamps_right[matched_indices] - ts_left\\n min_itd = np.argmin(np.abs(matched_itds))\\n itds_to_return[ts_idx_left] = matched_itds[min_itd]\\n\\n itd_indices = np.where(itds_to_return > -4. * max_itd)[0]\\n itds_to_return = itds_to_return[itd_indices]\\n if save_to_file is not None:\\n np.savez(save_to_file, timestamps=timestamps[itd_indices], ears=ears[itd_indices], types=types[itd_indices],\\n itds=itds_to_return, itd_indices=itd_indices)\\n\\n if return_itd_indices:\\n return itds_to_return, itd_indices\\n\\n return itds_to_return\",\n \"def test_k_index():\\n pressure = np.array([1014., 1000., 997., 981.2, 947.4, 925., 914.9, 911.,\\n 902., 883., 850., 822.3, 816., 807., 793.2, 770.,\\n 765.1, 753., 737.5, 737., 713., 700., 688., 685.,\\n 680., 666., 659.8, 653., 643., 634., 615., 611.8,\\n 566.2, 516., 500., 487., 484.2, 481., 475., 460.,\\n 400.]) * units.hPa\\n temperature = np.array([24.2, 24.2, 24., 23.1, 21., 19.6, 18.7, 18.4,\\n 19.2, 19.4, 17.2, 15.3, 14.8, 14.4, 13.4, 11.6,\\n 11.1, 10., 8.8, 8.8, 8.2, 7., 5.6, 5.6,\\n 5.6, 4.4, 3.8, 3.2, 3., 3.2, 1.8, 1.5,\\n -3.4, -9.3, -11.3, -13.1, -13.1, -13.1, -13.7, -15.1,\\n -23.5]) * units.degC\\n dewpoint = np.array([23.2, 23.1, 22.8, 22., 20.2, 19., 17.6, 17.,\\n 16.8, 15.5, 14., 11.7, 11.2, 8.4, 7., 4.6,\\n 5., 6., 4.2, 4.1, -1.8, -2., -1.4, -0.4,\\n -3.4, -5.6, -4.3, -2.8, -7., -25.8, -31.2, -31.4,\\n -34.1, -37.3, -32.3, -34.1, -37.3, -41.1, -37.7, -58.1,\\n -57.5]) * units.degC\\n ki = k_index(pressure, temperature, dewpoint)\\n assert_almost_equal(ki, 33.5 * units.degC, 2)\",\n \"def occ_indices(self):\\n indices = []\\n for index,item in enumerate(self):\\n if item==1:\\n indices.append(index)\\n return indices\",\n \"def get_continous_time_periods(binary_array):\\n binary_array = np.copy(binary_array).astype(\\\"int8\\\")\\n n_times = len(binary_array)\\n d_times = np.diff(binary_array)\\n # show the +1 and -1 edges\\n pos = np.where(d_times == 1)[0] + 1\\n neg = np.where(d_times == -1)[0] + 1\\n\\n if (pos.size == 0) and (neg.size == 0):\\n if len(np.nonzero(binary_array)[0]) > 0:\\n return [(0, n_times-1)]\\n else:\\n return []\\n elif pos.size == 0:\\n # i.e., starts on an spike, then stops\\n return [(0, neg[0])]\\n elif neg.size == 0:\\n # starts, then ends on a spike.\\n return [(pos[0], n_times-1)]\\n else:\\n if pos[0] > neg[0]:\\n # we start with a spike\\n pos = np.insert(pos, 0, 0)\\n if neg[-1] < pos[-1]:\\n # we end with aspike\\n neg = np.append(neg, n_times - 1)\\n # NOTE: by this time, length(pos)==length(neg), necessarily\\n h = np.matrix([pos, neg])\\n # print(f\\\"len(h[1][0]) {len(h[1][0])} h[1][0] {h[1][0]} h.size {h.size}\\\")\\n if np.any(h):\\n result = []\\n for i in np.arange(h.shape[1]):\\n if h[1, i] == n_times-1:\\n result.append((h[0, i], h[1, i]))\\n else:\\n result.append((h[0, i], h[1, i]-1))\\n return result\\n return []\",\n \"def get_max_indices(self, input):\\n \\n min_element = torch.min(torch.abs(input.contiguous().view(-1)))\\n input_temp = input + min_element + self.epsilon\\n masked_input_temp = input_temp * self.mask\\n values, indices = torch.sort(masked_input_temp, dim=1, descending=True)\\n\\n return indices[:, :self.num_active_nodes,:]\",\n \"def get_adjacent_idxs(sample, array):\\n state = sample >= array # boolean array\\n # Find the index where the last \\\"True\\\"\\n # This is the idx lower than the sample\\n idx_lower = np.where(state)[0][-1]\\n\\n # Find the index where the last \\\"False\\\"\\n # This is the first idx lower than the sample\\n idx_higher = np.where(np.logical_not(state))[0][0]\\n\\n return idx_lower, idx_higher\",\n \"def _get_index(self):\\n\\n return self.index\\n\\n # to avoid having differences bigger than 2pi\",\n \"def get_track_mask_idxes(self):\\n instance_id_num_pts = defaultdict(lambda: 0)\\n instance_id_lifetimes = defaultdict(lambda: [10000, -1])\\n\\n for frame_num, labels_per_frame in enumerate(self._frame_labels):\\n for id in labels_per_frame.unique().tolist():\\n instance_id_num_pts[id] += (labels_per_frame == id).long().sum().item()\\n instance_id_lifetimes[id][0] = min(frame_num, instance_id_lifetimes[id][0])\\n instance_id_lifetimes[id][1] = max(frame_num, instance_id_lifetimes[id][1])\\n\\n instance_id_lifetimes = {k: v[1] - v[0] for k, v in instance_id_lifetimes.items()}\\n return self._frame_labels, instance_id_num_pts, instance_id_lifetimes\",\n \"def get_indexes(self, dataset):\\n\\n indexs = [random.randint(0, len(dataset)) for _ in range(3)]\\n return indexs\",\n \"def ordered_indices(self):\\r\\n '''we need random order'''\\r\\n if self.shuffle:\\r\\n indices = np.random.permutation(len(self))\\r\\n else:\\r\\n indices = np.arange(len(self))\\r\\n '''\\r\\n if self.tgt_sizes is not None:\\r\\n indices = indices[np.argsort(self.tgt_sizes[indices], kind='mergesort')]\\r\\n return indices[np.argsort(self.src_sizes[indices], kind='mergesort')]\\r\\n '''\\r\\n return indices\",\n \"def _get_target_index(self):\\n return (self.index + self.source_window * (not self.overlapping) +\\n self.offset)\",\n \"def mesh_span_indices(self):\\n self._ensure_mesh()\\n k2m = self._knots_to_mesh\\n return np.where(k2m[1:] != k2m[:-1])[0]\",\n \"def create_jackknife_indexes(data):\\n from numpy import arange, delete\\n\\n index_range = arange(0, len(data))\\n return (delete(index_range, i) for i in index_range)\",\n \"def _get_k_indices(self, ks):\\n if self.staticneighs:\\n idx_ks = ks\\n else:\\n idx_ks = [self.ks.index(e) for e in ks]\\n return idx_ks\",\n \"def get_segment_index(datadb):\\n #match in time!!!!\\n if cfg.use_saliency:\\n segment_index_tar = util.get_time_for_visual(datadb)\\n segment_index_tar_future = OrderedDict()\\n for key in segment_index_tar.keys():\\n segment_index_tar_future[key] = np.array(segment_index_tar[key])+max_encoder_seq_length\\n return segment_index_tar,segment_index_tar_future\",\n \"def get_vacancy_indices(array):\\t\\n\\tvacancy_indices = np.argwhere(array == 0)\\n\\treturn vacancy_indices\",\n \"def ordered_indices(self):\\n return self.d1.ordered_indices()\\n # RETURN BASED ON D1's sizes\",\n \"def get_cached_indices(self, start=None, end=None):\\n params = {}\\n indices = [\\n y[\\\"sample_identifier\\\"]\\n for y in self.mongo_database.cache.find(\\n params, {\\\"_id\\\": 0, \\\"sample_identifier\\\": 1}\\n )[start:end]\\n ]\\n return np.unique(indices).tolist()\",\n \"def computeTopSurfaceIndices(top):\\n itop = np.array([(top[i,j], j, i) \\\\\\n for i in range(top.shape[0]) \\\\\\n for j in range(top.shape[1]) \\\\\\n if top[i,j] >= 0])\\n return itop\",\n \"def objects_to_indexes(self, object_seq: Sequence[Any]) -> np.ndarray:\\n res = np.zeros(len(object_seq))\\n for i, obj in enumerate(object_seq):\\n if obj in self.obj_to_idx:\\n res[i] = self.obj_to_idx[obj]\\n else:\\n res[i] = self.start-1\\n return res\",\n \"def get_overlapping_indices(self):\\n return self._get_atomic_overlaps()\",\n \"def indexes(self):\\r\\n\\r\\n\\r\\n if not self.usesequence:\\r\\n\\r\\n if len(self.get_all_indexes()) != len(self.sortedindexes) \\\\\\r\\n or self.indexchanged or not self.sortedindexes:\\r\\n self.indexchanged = False\\r\\n self.sortedindexes = sorted(self.get_all_indexes(),\\r\\n key=lambda x_temp: Index(x_temp))\\r\\n return self.sortedindexes\\r\\n return self.sortedindexes\\r\\n else:\\r\\n if self.indexchanged:\\r\\n self.sortedindexes = self.default_dict['indexlist'].strings()\\r\\n return self.sortedindexes\\r\\n else:\\r\\n return self.sortedindexes\",\n \"def selectCompatibleIndices(bigTimes, smallTimes):\\r\\n indices = []\\r\\n for idx, _ in enumerate(smallTimes):\\r\\n distances = (bigTimes - smallTimes[idx])**2\\r\\n def getValue(k):\\r\\n return distances[k]\\r\\n thisIndices = sorted(range(len(distances)), key=getValue)\\r\\n indices.append(thisIndices[0])\\r\\n return np.array(indices)\",\n \"def get_recorded_indices(self, application_vertex, variable):\\n if variable not in self.__sampling_rates:\\n return []\\n if self.__indexes[variable] is None:\\n return range(application_vertex.n_atoms)\\n return self.__indexes[variable]\",\n \"def scatter_counts_to_indices(input: torch.LongTensor) -> torch.LongTensor:\\n return torch.repeat_interleave(torch.arange(input.size(0), device=input.device), input).long()\",\n \"def get_negative_idx(self, outputs, targets, topk=(1, )):\\n max_k = max(topk)\\n\\n _, pred = outputs.topk(max_k, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(targets.view(1, -1).expand_as(pred))\\n \\n res = []\\n for k in topk:\\n negative_idx = (correct[:k].view(-1).float() == 0).nonzero()\\n res.append(negative_idx)\\n return res\",\n \"def master_ndindex(self): # itermaster_indices(self):\\n return itertools_product(\\n *[range(*r) for r in self.location]\\n ) # TODO check\",\n \"def generate_reverse_index(self):\",\n \"def get_shuffle_ids(self, bsz):\\n forward_inds = torch.randperm(bsz).long().cuda()\\n backward_inds = torch.zeros(bsz).long().cuda()\\n value = torch.arange(bsz).long().cuda()\\n backward_inds.index_copy_(0, forward_inds, value)\\n return forward_inds, backward_inds\",\n \"def get_selected_indices(bboxes, gt_boxes, total_pos_bboxes, total_neg_bboxes):\\n # Calculate iou values between each bboxes and ground truth boxes\\n iou_map = generate_iou_map(bboxes, gt_boxes)\\n # Get max index value for each row\\n max_indices_each_gt_box = tf.argmax(iou_map, axis=2, output_type=tf.int32)\\n # IoU map has iou values for every gt boxes and we merge these values column wise\\n merged_iou_map = tf.reduce_max(iou_map, axis=2)\\n # Sorted iou values\\n sorted_iou_map = tf.argsort(merged_iou_map, direction=\\\"DESCENDING\\\")\\n # Get highest and lowest candidate indices\\n pos_candidate_indices = sorted_iou_map[:, :total_pos_bboxes * 2]\\n neg_candidate_indices = sorted_iou_map[:, ::-1][:, :total_neg_bboxes * 2]\\n # Shuffling\\n pos_candidate_indices_shuffled = tf.transpose(tf.random.shuffle(tf.transpose(pos_candidate_indices)))\\n neg_candidate_indices_shuffled = tf.transpose(tf.random.shuffle(tf.transpose(neg_candidate_indices)))\\n # Randomly select pos and neg indices from candidates\\n pos_bbox_indices = pos_candidate_indices_shuffled[:, :total_pos_bboxes]\\n neg_bbox_indices = neg_candidate_indices_shuffled[:, :total_neg_bboxes]\\n gt_box_indices = tf.gather(max_indices_each_gt_box, pos_bbox_indices, batch_dims=1)\\n #\\n return pos_bbox_indices, neg_bbox_indices, gt_box_indices\",\n \"def fft_bin_to_index(self, bins):\\n idx = bins.copy()\\n return idx\",\n \"def tc_index(*args):\\n index = []\\n x = check_tc_data(args[0])\\n i = 0\\n for line in args[0].Data.TCData.tc_data:\\n i += 1\\n if line != x[i - 1]:\\n index.append(0)\\n elif line == x[i - 1]:\\n index.append(i)\\n return index\",\n \"def inidices(self):\\n return [Index(name, index) for name, index in self._data['indices'].iteritems()]\",\n \"def racetrack_filter(reversals, h):\\n\\n y = reversals\\n yprev = None\\n ix = []\\n for n, yn in enumerate(y):\\n if (n == 0) or (n == y.size-1):\\n yprev = yn\\n ix.append(n)\\n continue\\n dy = yn - yprev\\n if fabs(dy) > h / 2.:\\n yprev = yn - dy/fabs(dy) * h/2.\\n ix.append(n)\\n ix = np.array(ix, dtype=int)\\n return y[ix], ix\",\n \"def _little_group_index(self, k: Array) -> Array:\\n # calculate k' = p(k) for all p in the point group\\n big_star = np.tensordot(self.point_group_.matrices(), k, axes=1)\\n big_star = self.lattice.to_reciprocal_lattice(big_star) % self.lattice.extent\\n # should test for pbc before taking the modulus, but the only valid wave\\n # vector for non-pbc axes is 0 and 0 % anything == 0\\n\\n # assumes point_group_[0] is the identity\\n is_in_little_group = np.all(big_star == big_star[0], axis=1)\\n return np.arange(len(self.point_group_))[is_in_little_group]\",\n \"def _indicies_of_periods(datetime_index, freq, use_local_time=True):\\n\\n if use_local_time:\\n datetime_index = _tz_to_naive(datetime_index)\\n\\n periods = pd.period_range(datetime_index[0], datetime_index[-1], freq=freq)\\n\\n # Declare and initialise some constants and variables used\\n # during the loop...\\n\\n # Find the minimum sample period.\\n MIN_SAMPLE_PERIOD = int(get_sample_period(datetime_index))\\n MAX_SAMPLES_PER_PERIOD = int(\\n secs_per_period_alias(freq) / MIN_SAMPLE_PERIOD)\\n MAX_SAMPLES_PER_2_PERIODS = MAX_SAMPLES_PER_PERIOD * 2\\n n_rows_processed = 0\\n boundaries = {}\\n for period in periods:\\n # The simplest way to get data for just a single period is to use\\n # data_for_day = datetime_index[period.strftime('%Y-%m-%d')]\\n # but this takes about 300ms per call on my machine.\\n # So we take advantage of several features of the data to achieve\\n # a 300x speedup:\\n # 1. We use the fact that the data is sorted in order, hence\\n # we can chomp through it in order.\\n # 2. MAX_SAMPLES_PER_PERIOD sets an upper bound on the number of\\n # datapoints per period. The code is conservative and uses\\n # MAX_SAMPLES_PER_2_PERIODS. We only search through a small subset\\n # of the available data.\\n\\n end_index = n_rows_processed + MAX_SAMPLES_PER_2_PERIODS\\n rows_to_process = datetime_index[n_rows_processed:end_index]\\n indicies_for_period = np.where(rows_to_process < period.end_time)[0]\\n if indicies_for_period.size > 0:\\n first_i_for_period = indicies_for_period[0] + n_rows_processed\\n last_i_for_period = indicies_for_period[-1] + n_rows_processed + 1\\n boundaries[period] = (first_i_for_period, last_i_for_period)\\n n_rows_processed += last_i_for_period - first_i_for_period\\n\\n return periods, boundaries\",\n \"def indices(self):\\n return self._kbounded_partitions\",\n \"def get_itds_v3(timestamps, ears, types, max_itd=800e-6, save_to_file=None, verbose=False, return_itd_indices=False):\\n ears = ears.astype(np.bool)\\n itds_to_return = np.zeros(timestamps.size, dtype=np.float32)\\n itds_to_return.fill(-5. * max_itd)\\n\\n timestamps_dict = {}\\n timestamp_indices_dict = {}\\n for ear in np.unique(ears):\\n timestamps_dict[ear] = {}\\n timestamp_indices_dict[ear] = {}\\n for type_of_event in np.unique(types):\\n timestamps_dict[ear][type_of_event] = []\\n timestamp_indices_dict[ear][type_of_event] = []\\n\\n for idx, (timestamp, ear, type_of_event) in enumerate(zip(timestamps, ears, types)):\\n timestamps_dict[ear][type_of_event].append(timestamp)\\n timestamp_indices_dict[ear][type_of_event].append(idx)\\n\\n if verbose:\\n print('Initialized the timestamp lists.')\\n\\n bar = progressbar.ProgressBar() if verbose else lambda x: x\\n\\n max_num_events = 5\\n\\n for type_of_event in bar(np.unique(types)):\\n timestamps_left = np.array(timestamps_dict[True][type_of_event])\\n timestamp_indices_left = timestamp_indices_dict[True][type_of_event]\\n timestamps_right = np.array(timestamps_dict[False][type_of_event])\\n timestamp_indices_right = timestamp_indices_dict[False][type_of_event]\\n\\n num_right_events = timestamps_right.shape[0]\\n\\n for event_idx, (ts_right, ts_idx_right) in enumerate(zip(timestamps_right, timestamp_indices_right)):\\n matched_indices = np.where((timestamps_left >= ts_right - max_itd) &\\n (timestamps_left < ts_right + max_itd))[0]\\n if matched_indices.size > 0:\\n matched_itds = ts_right - timestamps_left[matched_indices]\\n min_itd_idx_local = np.argmin(np.abs(matched_itds))\\n min_itd = matched_itds[min_itd_idx_local]\\n # absolute index of the itd pair event\\n min_itd_ts_left = ts_right - min_itd\\n # now check that the itd pair for the itd pair event is the current event\\n if event_idx < max_num_events:\\n min_itd_ts_right = timestamps_right[0: event_idx + max_num_events + 1]\\n alt_min_itd_idx = np.argmin(np.abs(min_itd_ts_left - min_itd_ts_right))\\n if alt_min_itd_idx == event_idx:\\n itds_to_return[ts_idx_right] = min_itd\\n else:\\n min_itd_ts_right = timestamps_right[event_idx - max_num_events: event_idx + max_num_events + 1]\\n alt_min_itd_idx = np.argmin(np.abs(min_itd_ts_left - min_itd_ts_right))\\n if alt_min_itd_idx == max_num_events:\\n itds_to_return[ts_idx_right] = min_itd\\n if min_itd_ts_right[0] > min_itd_ts_left - max_itd or min_itd_ts_right[-1] < min_itd_ts_left + max_itd:\\n print('[WARNING] The max_num_events is not enough, please check.')\\n sys.stdout.flush()\\n\\n itd_indices = np.where(itds_to_return > -4. * max_itd)[0]\\n itds_to_return = itds_to_return[itd_indices]\\n if save_to_file is not None:\\n np.savez(save_to_file, timestamps=timestamps[itd_indices], ears=ears[itd_indices], types=types[itd_indices],\\n itds=itds_to_return, itd_indices=itd_indices)\\n\\n if return_itd_indices:\\n return itds_to_return, itd_indices\\n\\n return itds_to_return\",\n \"def get_indices(self):\\r\\n return self._indices\",\n \"def mainIndices(self):\\n return self.i1, self.i2\",\n \"def get_img_indices():\\n if K.image_dim_ordering() == 'th':\\n return 0, 1, 2, 3\\n else:\\n return 0, 3, 1, 2\",\n \"def getNegativeSamples(target, dataset, K):\\n\\n indices = [None] * K\\n for k in range(K):\\n newidx = dataset.sampleTokenIdx()\\n while newidx == target:\\n newidx = dataset.sampleTokenIdx()\\n indices[k] = newidx\\n return indices\",\n \"def unravel_index(ijk, n):\\n \\n if type(ijk) is int:\\n return ijk\\n if len(ijk)==1:\\n return ijk[0]\\n\\n assert (np.diff(ijk)>0).all()\\n assert all([i<n for i in ijk])\\n\\n ix = sum([int(binom(n-1-i,len(ijk)-1)) for i in range(ijk[0])])\\n for d in range(1, len(ijk)-1):\\n if (ijk[d]-ijk[d-1])>1:\\n ix += sum([int(binom(n-i-1,len(ijk)-d-1)) for i in range(ijk[d-1]+1, ijk[d])])\\n ix += ijk[-1] -ijk[-2] -1\\n return ix\",\n \"def getNegativeSamples(target, dataset, K):\\n\\n indices = [None] * K\\n for k in xrange(K):\\n newidx = dataset.sampleTokenIdx()\\n while newidx == target:\\n newidx = dataset.sampleTokenIdx()\\n indices[k] = newidx\\n return indices\",\n \"def getNegativeSamples(target, dataset, K):\\n\\n indices = [None] * K\\n for k in xrange(K):\\n newidx = dataset.sampleTokenIdx()\\n while newidx == target:\\n newidx = dataset.sampleTokenIdx()\\n indices[k] = newidx\\n return indices\",\n \"def getNegativeSamples(target, dataset, K):\\n\\n indices = [None] * K\\n for k in xrange(K):\\n newidx = dataset.sampleTokenIdx()\\n while newidx == target:\\n newidx = dataset.sampleTokenIdx()\\n indices[k] = newidx\\n return indices\",\n \"def _extract_t_indices(self, X, X2=None, dL_dK=None):\\r\\n\\r\\n # TODO: some fast checking here to see if this needs recomputing?\\r\\n self._t = X[:, 0]\\r\\n if not X.shape[1] == 2:\\r\\n raise ValueError('Input matrix for ode1 covariance should have two columns, one containing times, the other output indices')\\r\\n self._index = np.asarray(X[:, 1],dtype=np.int)\\r\\n # Sort indices so that outputs are in blocks for computational\\r\\n # convenience.\\r\\n self._order = self._index.argsort()\\r\\n self._index = self._index[self._order]\\r\\n self._t = self._t[self._order]\\r\\n self._rorder = self._order.argsort() # rorder is for reversing the order\\r\\n \\r\\n if X2 is None:\\r\\n self._t2 = None\\r\\n self._index2 = None\\r\\n self._order2 = self._order\\r\\n self._rorder2 = self._rorder\\r\\n else:\\r\\n if not X2.shape[1] == 2:\\r\\n raise ValueError('Input matrix for ode1 covariance should have two columns, one containing times, the other output indices')\\r\\n self._t2 = X2[:, 0]\\r\\n self._index2 = np.asarray(X2[:, 1],dtype=np.int)\\r\\n self._order2 = self._index2.argsort()\\r\\n self._index2 = self._index2[self._order2]\\r\\n self._t2 = self._t2[self._order2]\\r\\n self._rorder2 = self._order2.argsort() # rorder2 is for reversing order\\r\\n\\r\\n if dL_dK is not None:\\r\\n self._dL_dK = dL_dK[self._order, :]\\r\\n self._dL_dK = self._dL_dK[:, self._order2]\",\n \"def _getscanind(self):\\n \\n zamin = self.za.min()\\n first = np.where(self.za==zamin)[0]\\n self.scan = np.zeros(self.spec.shape[0])\\n if zamin < 0:\\n cs = first[np.where((first - np.roll(first, 1)) != 1)[0]]\\n ss = first[np.where((np.roll(first,-1) - first) != 1)[0]] + 1\\n ce = ss \\n se = np.roll((cs - 1) % self.za.size, -1) + 1\\n for k, val in enumerate(cs):\\n self.scan[val:se[k] + 1] = k\\n else:\\n moves = np.diff(self.za)\\n max_ind = np.where(moves==moves.max())[0]\\n turnover = self.za.size\\n diffs = np.diff(max_ind)\\n if np.unique(diffs).size > 1:\\n raise ValueError, 'Can\\\\'t deal with non-uniform cal data yet.'\\n if max_ind.size > 1:\\n turnover = diffs[0]\\n cs = ce = np.array([])\\n ss = np.arange(self.za.size)[::turnover]\\n se = np.roll((ss - 1) % self.za.size, -1)\\n for k, val in enumerate(ss):\\n self.scan[val:se[k] + 1] = k\\n \\n self.ind = {'cs': cs, 'ce': ce, 'ss': ss, 'se': se}\\n self.nscan = np.unique(self.scan).size\",\n \"def test_total_totals_index():\\n pressure = np.array([1008., 1000., 947., 925., 921., 896., 891., 889., 866.,\\n 858., 850., 835., 820., 803., 733., 730., 700., 645.,\\n 579., 500., 494., 466., 455., 441., 433., 410., 409.,\\n 402., 400., 390., 388., 384., 381., 349., 330., 320.,\\n 306., 300., 278., 273., 250., 243., 208., 200., 196.,\\n 190., 179., 159., 151., 150., 139.]) * units.hPa\\n temperature = np.array([27.4, 26.4, 22.9, 21.4, 21.2, 20.7, 20.6, 21.2, 19.4,\\n 19.1, 18.8, 17.8, 17.4, 16.3, 11.4, 11.2, 10.2, 6.1,\\n 0.6, -4.9, -5.5, -8.5, -9.9, -11.7, -12.3, -13.7, -13.8,\\n -14.9, -14.9, -16.1, -16.1, -16.9, -17.3, -21.7, -24.5, -26.1,\\n -28.3, -29.5, -33.1, -34.2, -39.3, -41., -50.2, -52.5, -53.5,\\n -55.2, -58.6, -65.2, -68.1, -68.5, -72.5]) * units.degC\\n dewpoint = np.array([24.9, 24.6, 22., 20.9, 20.7, 14.8, 13.6, 12.2, 16.8,\\n 16.6, 16.5, 15.9, 13.6, 13.2, 11.3, 11.2, 8.6, 4.5,\\n -0.8, -8.1, -9.5, -12.7, -12.7, -12.8, -13.1, -24.7, -24.4,\\n -21.9, -24.9, -36.1, -31.1, -26.9, -27.4, -33., -36.5, -47.1,\\n -31.4, -33.5, -40.1, -40.8, -44.1, -45.6, -54., -56.1, -56.9,\\n -58.6, -61.9, -68.4, -71.2, -71.6, -77.2]) * units.degC\\n\\n tt = total_totals_index(pressure, temperature, dewpoint)\\n assert_almost_equal(tt, 45.10 * units.delta_degC, 2)\",\n \"def generate_index(self):\\n begin_o, end_o, begin_a, end_a = 0, 0, 0, 0\\n for obs_space, act_space in zip(self.env.observation_space, self.env.action_space):\\n end_o = end_o + obs_space.shape[0]\\n if isinstance(act_space, Box):\\n end_a = act_space.shape[0]\\n else:\\n end_a = act_space.n\\n range_o = (begin_o, end_o)\\n range_a = (begin_a, end_a)\\n self.observation_index.append(range_o)\\n self.action_index.append(range_a)\\n begin_o = end_o\\n begin_a = end_a\",\n \"def getstate(self):\\r\\n return [self.tied_indices,\\r\\n self.fixed_indices,\\r\\n self.fixed_values,\\r\\n self.constrained_indices,\\r\\n self.constraints]\",\n \"def getNeighbours(seg,meta,inversedIndex):\\n return np.unique(np.fromiter( (inversedIndex[x] for x in np.concatenate([meta.loc[seg]['ins'],meta.loc[seg]['outs']])),dtype=np.int))\",\n \"def test_gleckler_index(self):\\n\\n # generate sample data\\n # sample data\\n tmp = np.zeros((5, 3, 1))\\n tmp[:,0,0] = np.ones(5)*1.\\n tmp[:,1,0] = np.ones(5)*2.\\n tmp[:,2,0] = np.ones(5)*5.\\n\\n # The data is like ...\\n #| 1 | 2 | 5 |\\n #| 1 | 2 | 5 |\\n #| 1 | 2 | 5 |\\n #| 1 | 2 | 5 |\\n #| 1 | 2 | 5 |\\n\\n x = self.D.copy()\\n x._temporal_subsetting(0, 4)\\n\\n x.data = np.ma.array(tmp, mask=tmp!=tmp)\\n x.std = np.ones(x.data.shape)\\n x.time[0] = pl.datestr2num('2000-02-15')\\n x.time[1] = pl.datestr2num('2000-03-15')\\n x.time[2] = pl.datestr2num('2000-04-15')\\n x.time[3] = pl.datestr2num('2000-05-15')\\n x.time[4] = pl.datestr2num('2000-06-15')\\n\\n y = self.D.copy()\\n y._temporal_subsetting(0, 4)\\n tmp = np.ones(x.data.shape) # sample data 2\\n y.data = np.ma.array(tmp, mask=tmp!=tmp)\\n y.time[0] = pl.datestr2num('2000-02-15')\\n y.time[1] = pl.datestr2num('2000-03-15')\\n y.time[2] = pl.datestr2num('2000-04-15')\\n y.time[3] = pl.datestr2num('2000-05-15')\\n y.time[4] = pl.datestr2num('2000-06-15')\\n\\n # Case 1: same area weights\\n # cell area\\n tmp = np.ones((3, 1))\\n x.cell_area = tmp*1.\\n\\n #| 1-1 | 2-1 | 5-1 |\\n #| 1-1 | 2-1 | 5-1 |\\n #| 1-1 | 2-1 | 5-1 |\\n #| 1-1 | 2-1 | 5-1 |\\n #| 1-1 | 2-1 | 5-1 |\\n #===================\\n #| 0 | 5 | 5*4**2=5*16. = 80 |\\n #==> E2 = sqrt(85./(15.))\\n D = GlecklerPlot()\\n r = D.calc_index(x, y, 'a', 'b', time_weighting=False)\\n\\n wt = np.ones(5) / 5.\\n ref = np.sqrt(((85./15.) * wt).sum())\\n t = np.abs(1. - r / ref)\\n self.assertLess(t, 0.000001) # relative error\\n\\n D = GlecklerPlot()\\n r = D.calc_index(x, y, 'a', 'b')\\n\\n wt = np.asarray([29., 31., 30., 31., 30.])\\n wt = wt / wt.sum()\\n ref = np.sqrt(((85./15.) * wt).sum())\\n t = np.abs(1. - r / ref)\\n self.assertLess(t, 0.000001) # relative error\\n\\n\\n\\n # Case 2: Different area weights\\n # cell area\\n tmp = np.ones((3, 1))\\n tmp[1, 0] = 2.\\n x.cell_area = tmp*1.\\n\\n #| 1-1=0 | 2-1=1 | 5-1=16 |\\n #| 1-1=0 | 2-1=1 | 5-1=16 |\\n #| 1-1=0 | 2-1=1 | 5-1=16 |\\n #| 1-1=0 | 2-1=1 | 5-1=16 |\\n #| 1-1=0 | 2-1=1 | 5-1=16 |\\n #--------------------------\\n # w = 0.25 w = 0.5 w=0.25|\\n #--------------------------\\n\\n # 0.25*0 + 0.5 * 1 + 0.25 * 16 = 0 + 0.5 + 4 = 4.5\\n # the mean of that is 4.5 for each timestep\\n # mean because the overall weights are calculated as such that\\n # they give a total weight if 1\\n\\n # diagnostic\\n D = GlecklerPlot()\\n r = D.calc_index(x, y, 'a', 'b', time_weighting=False)\\n\\n wt = np.ones(5) / 5.\\n ref = np.sqrt((4.5 * wt).sum())\\n t = np.abs(1. - r / ref)\\n self.assertLess(t, 0.000001) # relative error\\n\\n wt = np.asarray([29., 31., 30., 31., 30.])\\n wt = wt / wt.sum()\\n ref = np.sqrt((4.5 * wt).sum())\\n t = np.abs(1. - r / ref)\\n self.assertLess(t, 0.000001) # relative error\\n\\n # Case 3: use different std\\n x.std = np.ones(x.data.shape)\\n x.std[:, 2, 0] = 0.5\\n\\n #| 1-1=0 | 2-1=1 | 5-1=16 / 0.5 |\\n #| 1-1=0 | 2-1=1 | 5-1=16 / 0.5 |\\n #| 1-1=0 | 2-1=1 | 5-1=16 / 0.5 |\\n #| 1-1=0 | 2-1=1 | 5-1=16 / 0.5 |\\n #| 1-1=0 | 2-1=1 | 5-1=16 / 0.5 |\\n #--------------------------------\\n # w = 0.25 w = 0.5 w=0.25|\\n # 0 + 0.5 + 0.25*32 = 0.5 + 8 = 8.5\\n\\n D = GlecklerPlot()\\n r = D.calc_index(x, y, 'a', 'b', time_weighting=False)\\n\\n wt = np.ones(5) / 5.\\n ref = np.sqrt((8.5 * wt).sum())\\n t = np.abs(1. - r / ref)\\n self.assertLess(t, 0.000001) # relative error\\n\\n wt = np.asarray([29., 31., 30., 31., 30.])\\n wt = wt / wt.sum()\\n ref = np.sqrt((8.5 * wt).sum())\\n t = np.abs(1. - r / ref)\\n self.assertLess(t, 0.000001) # relative error\",\n \"def ztost_ind(self, low, upp, usevar=\\\"pooled\\\"):\\n tt1 = self.ztest_ind(alternative=\\\"larger\\\", usevar=usevar, value=low)\\n tt2 = self.ztest_ind(alternative=\\\"smaller\\\", usevar=usevar, value=upp)\\n # TODO: remove tuple return, use same as for function tost_ind\\n return np.maximum(tt1[1], tt2[1]), tt1, tt2\",\n \"def get_gt_hom_idxs(alt_num):\\n last = -1\\n hom_idxs = []\\n for a in range(alt_num + 1):\\n last = last + (a + 1)\\n hom_idxs.append(last)\\n return hom_idxs\",\n \"def index_dict(self):\\n msk = self.load_mask()\\n mski = enumerate(msk)\\n ifiltered = (i for (i, m) in mski if m == 1)\\n return {i: j for (j, i) in enumerate(ifiltered)}\",\n \"def index_dict(self):\\n msk = self.load_mask()\\n mski = enumerate(msk)\\n ifiltered = (i for (i, m) in mski if m == 1)\\n return {i: j for (j, i) in enumerate(ifiltered)}\",\n \"def tril_indices(n,k=0):\\r\\n return mask_indices(n,tril,k)\",\n \"def indices(self):\\n return tuple([slice(*r) for r in self.location])\",\n \"def create_repeated_indexes(data):\\n from numpy import arange\\n\\n index_range = arange(0, len(data))\\n return (index_range for i in index_range)\",\n \"def morton_idx(pts):\\n lib = _initlib()\\n p = require(pts, dtype=float64, requirements=['C']) \\n inv_cell_width = 1.0/8192\\n npts = len(p)\\n out = empty(npts, dtype=int64)\\n lib.get_morton_idx(p, npts, inv_cell_width, out)\\n return out\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6033882","0.5888383","0.5833695","0.576953","0.5758707","0.56996095","0.5611121","0.5609971","0.5606583","0.5600059","0.5593295","0.5524574","0.54750305","0.54693586","0.5458139","0.54525465","0.54286104","0.54272556","0.5421725","0.5421557","0.5390778","0.53880054","0.5387267","0.5364159","0.5364121","0.5360811","0.5356435","0.53508663","0.53504926","0.53449017","0.5335162","0.5334382","0.5331971","0.53210676","0.531988","0.53169304","0.53152215","0.5313708","0.53036076","0.52851015","0.52823424","0.5278069","0.52493805","0.52385896","0.52318263","0.5230262","0.52279824","0.52243346","0.5224061","0.52186716","0.5212888","0.5212244","0.52119946","0.5198007","0.5196583","0.51939195","0.5187022","0.51819056","0.51818573","0.5179425","0.51792705","0.51747537","0.5167434","0.5162587","0.51515996","0.514822","0.51461446","0.514448","0.51372015","0.5131495","0.5129077","0.5127173","0.5126614","0.51253104","0.5121963","0.511779","0.51163375","0.51160437","0.51147854","0.51098084","0.51089597","0.5105133","0.5102285","0.5101745","0.5101745","0.5101745","0.51004386","0.5099206","0.5098707","0.5097059","0.50933266","0.50917184","0.50886965","0.50866956","0.5086004","0.50809586","0.50809586","0.50736016","0.50732815","0.5059736","0.505661"],"string":"[\n \"0.6033882\",\n \"0.5888383\",\n \"0.5833695\",\n \"0.576953\",\n \"0.5758707\",\n \"0.56996095\",\n \"0.5611121\",\n \"0.5609971\",\n \"0.5606583\",\n \"0.5600059\",\n \"0.5593295\",\n \"0.5524574\",\n \"0.54750305\",\n \"0.54693586\",\n \"0.5458139\",\n \"0.54525465\",\n \"0.54286104\",\n \"0.54272556\",\n \"0.5421725\",\n \"0.5421557\",\n \"0.5390778\",\n \"0.53880054\",\n \"0.5387267\",\n \"0.5364159\",\n \"0.5364121\",\n \"0.5360811\",\n \"0.5356435\",\n \"0.53508663\",\n \"0.53504926\",\n \"0.53449017\",\n \"0.5335162\",\n \"0.5334382\",\n \"0.5331971\",\n \"0.53210676\",\n \"0.531988\",\n \"0.53169304\",\n \"0.53152215\",\n \"0.5313708\",\n \"0.53036076\",\n \"0.52851015\",\n \"0.52823424\",\n \"0.5278069\",\n \"0.52493805\",\n \"0.52385896\",\n \"0.52318263\",\n \"0.5230262\",\n \"0.52279824\",\n \"0.52243346\",\n \"0.5224061\",\n \"0.52186716\",\n \"0.5212888\",\n \"0.5212244\",\n \"0.52119946\",\n \"0.5198007\",\n \"0.5196583\",\n \"0.51939195\",\n \"0.5187022\",\n \"0.51819056\",\n \"0.51818573\",\n \"0.5179425\",\n \"0.51792705\",\n \"0.51747537\",\n \"0.5167434\",\n \"0.5162587\",\n \"0.51515996\",\n \"0.514822\",\n \"0.51461446\",\n \"0.514448\",\n \"0.51372015\",\n \"0.5131495\",\n \"0.5129077\",\n \"0.5127173\",\n \"0.5126614\",\n \"0.51253104\",\n \"0.5121963\",\n \"0.511779\",\n \"0.51163375\",\n \"0.51160437\",\n \"0.51147854\",\n \"0.51098084\",\n \"0.51089597\",\n \"0.5105133\",\n \"0.5102285\",\n \"0.5101745\",\n \"0.5101745\",\n \"0.5101745\",\n \"0.51004386\",\n \"0.5099206\",\n \"0.5098707\",\n \"0.5097059\",\n \"0.50933266\",\n \"0.50917184\",\n \"0.50886965\",\n \"0.50866956\",\n \"0.5086004\",\n \"0.50809586\",\n \"0.50809586\",\n \"0.50736016\",\n \"0.50732815\",\n \"0.5059736\",\n \"0.505661\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":7288,"cells":{"query":{"kind":"string","value":"Standard k fold cross validation."},"document":{"kind":"string","value":"def k_fold_cross_validation(random_state: np.random.RandomState,\n num_splits: int,\n indices: np.ndarray,\n **kwargs: Any\n ) -> List[Tuple[np.ndarray, np.ndarray]]:\n shuffle = kwargs.get('shuffle', True)\n cv = KFold(n_splits=num_splits, random_state=random_state if shuffle else None, shuffle=shuffle)\n splits = list(cv.split(indices))\n return splits"},"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 k_folds_cross_validate(self, k):\n start_time = time.time()\n partition_size = int(self.num_samples / k)\n partitions = [\n (i * partition_size, (i + 1) * partition_size) for i in range(k)\n ]\n average_accuracy = 0.0\n for start, end in partitions:\n validation_input_set = self.input[start:end, :] # subset of input of size k (k samples)\n validation_output_set = self.output[start:end] # subset of output of size k (k outputs)\n training_input_set = np.delete(self.input, np.s_[start:end], 0) # subset of input excluding validation set\n training_output_set = np.delete(self.output, np.s_[start:end], 0) # subset of output excluding validation\n\n self.fit(training_input_set, training_output_set)\n accuracy = self.evaluate_acc(validation_input_set, validation_output_set)\n # print('Accuracy: ', accuracy) # accuracy of each fold\n average_accuracy += accuracy\n average_accuracy /= k\n print('Average accuracy: ', average_accuracy)\n print('Runtime: ', time.time() - start_time, 'seconds')","def k_fold_cross_validation(X, K):\n\tfor k in xrange(K):\n\t\ttraining = [i for i, x in enumerate(X) if i % K != k]\n\t\tvalidation = [i for i, x in enumerate(X) if i % K == k]\n\t\tyield training, validation","def k_fold_cross_validation(X, K, randomise = False):\n\tif randomise: from random import shuffle; X=list(X); shuffle(X)\n\tfor k in xrange(K):\n\t\ttraining = [x for i, x in enumerate(X) if i % K != k]\n\t\tvalidation = [x for i, x in enumerate(X) if i % K == k]\n\t\tyield training, validation","def cross_validation(self, k=5):\n test_errors, train_errors = [], []\n\n # For leave out cross validation k = n\n if k == -1:\n k = len(data)\n\n for _ in range(k):\n shuffled_data = data.copy()\n\n # Do not shuffle data for leave one out cross validation\n if k != -1:\n # Copy the original data and shuffle it\n np.random.shuffle(shuffled_data)\n\n # Divide it into k folds\n split = int(((k - 1) / k) * len(data))\n train_data = shuffled_data[:split]\n test_data = shuffled_data[split:]\n\n # Find train_X, train_Y, test_X, test_Y\n # KNN requires access to training data to determine error\n self.train_X = np.asarray(train_data[:, :6])\n self.train_Y = np.asarray(train_data[:, 7])\n\n test_X = np.asarray(test_data[:, :6])\n test_Y = np.asarray(test_data[:, 7])\n\n # Use (k-1) part for training and 1 part for testing\n self.fit(self.train_X, self.train_Y)\n test_error = self.compute_error(test_X, test_Y)\n train_error = self.compute_error(self.train_X, self.train_Y)\n test_errors.append(test_error)\n train_errors.append(train_error)\n\n # Average the error\n avg_train_error = np.round(np.average(np.asarray(train_errors), axis=0), 3)\n avg_test_error = np.round(np.average(np.asarray(test_errors), axis=0), 3)\n print(\"The average error of {} is - Train : {}\\tTest : {} Overfit : {}\".format(self.method,\n avg_train_error, avg_test_error,\n avg_test_error > avg_train_error))\n return avg_test_error, avg_train_error","def cross_validation(self):\r\n kfold = KFold(10, shuffle=True, random_state=1)\r\n data = self.read_data()\r\n # error from each kth iteration\r\n errors = []\r\n for train, test in kfold.split(data):\r\n\r\n #Splitting into test and training data\r\n X_test, Y_test = data[test][:, 1], data[test][:, 2]\r\n X_train, Y_train = data[train][:, 1], data[train][:, 2]\r\n\r\n #Training on the split data\r\n weights, design_matrix = self.train(X_train, Y_train)\r\n\r\n y_pred = self.make_prediction(X_test, weights)\r\n self.plot(y_true=Y_test, y_pred=y_pred, x=X_test)\r\n\r\n #error matrix\r\n errors.append(np.mean(y_pred - Y_test) ** 2)\r\n\r\n #cross-validation parameter taken as mean of errors obtained from each iteration\r\n print(\"%0.10f mean with a standard deviation of %0.10f across the k-folds\" % (np.mean(errors), np.std(errors)))","def k_cross_fold_validation( data, labels, k=5):\n rf = RandomForestClassifier(n_estimators=25)\n predictions, indexes = [], []\n size = data.shape[0]\n step_size = int(size / 5)\n for i in range(k):\n indexes.append(range(i*k, min(i*k + k, size)))\n xtrain = np.array(data)\n ytrain = np.array(labels)\n\n # picks test slices\n xtest = xtrain[i*k:i*k + k]\n ytest = ytrain[i*k:i*k + k]\n\n # removes test slices from the training sets\n xtrain = np.delete(xtrain, np.s_[i*k:i*k + k], axis=0)\n ytrain = np.delete(ytrain, np.s_[i*k:i*k + k], axis=0)\n\n \n rf = rf.fit(xtrain, ytrain)\n prediction = rf.predict(xtest)\n\n predictions.append(prediction.tolist())\n \n return np.array(predictions), np.array(indexes)","def cross_validation(whole_train_data, whole_train_labels, k, k_fold):\n accuracies = []\n for i in range(k_fold):\n train_data, train_labels, validation_data, validation_labels = split_train_and_validation(whole_train_data, whole_train_labels, i, k_fold)\n accuracy = knn(train_data, train_labels, validation_data, validation_labels, k)\n accuracies.append(accuracy)\n avg_accuracy = np.mean(accuracies)\n return avg_accuracy","def cross_validate(cv, x, y, k=1):\n indices = np.arange(len(x))\n np.random.shuffle(indices)\n stepsize = int(len(x) / cv)\n metrics = np.zeros(4)\n for i in range(cv):\n logging.info(f\"Cross-validation fold {i+1}\")\n\n # Slice test set out of data\n test_indices = indices[i*stepsize:i*stepsize+stepsize]\n x_test = x[test_indices]\n y_test = y[test_indices]\n\n # Everything else is the training set\n x_train = np.copy(x)\n x_train = np.delete(x_train, test_indices, axis=0)\n y_train = np.copy(y)\n y_train = np.delete(y_train, test_indices, axis=0)\n\n metrics += evaluate(knn(x_test, x_train, y_train, k), y_test)\n metrics /= cv\n\n print(metrics)\n return metrics","def cross_validation(self, k_folds, **inputs):\n self.cv_stats, self.cv_traces = [], []\n self.k_folds = k_folds\n inputs = self._clean_inputs(inputs)\n for i, fold in enumerate(k_folds):\n train, test = fold\n input_train, input_test = {}, {}\n for name, data in inputs.items():\n if name in self.cv_vars:\n input_train[name] = data[train]\n input_test[name] = data[test]\n else:\n input_train[name] = data\n input_test[name] = data\n trace = self.run(**input_train)\n stats = self.calculate_statistics(trace, **input_test)\n self.cv_traces.append(trace)\n self.cv_stats.append(stats)\n return self.cv_traces, self.cv_stats","def kfold_cross_validation(X, n_splits=5):\n\n #Define variables\n X_train_folds = []\n X_test_folds = []\n indexes = list(range(len(X)))\n index = 0\n\n #Create folds\n for i in range(n_splits):\n test = []\n train = []\n #Determine how many to put in test\n if((len(X) % n_splits) > i):\n numTest = len(X) // n_splits +1\n else:\n numTest = len(X) // n_splits\n for j in range(numTest):\n if(index < len(X)):\n test.append(index)\n indexes.pop(indexes.index(index))\n index = index + 1\n for index1 in indexes:\n train.append(index1)\n X_test_folds.append(test)\n X_train_folds.append(train)\n indexes = list(range(len(X)))\n\n return X_train_folds, X_test_folds","def kFoldCrossVal(self, k):\n # shuffle\n df = self.df.sample(frac=1)\n # chunk into k folds\n #fold_idxs = [range(i, self.len_, k) for i in xrange(k)] TODO: pointers ?\n df_arr = [df[i::k] for i in xrange(k)]\n\n for i, validate in enumerate(df_arr):\n train_list = df_arr[:i] + df_arr[i+1:]\n train = pd.concat(train_list, axis=0)\n assert len(train) + len(validate) == len(df)\n yield (train, validate)","def fold(self, k):\n if not (0 < k < 5):\n raise ValueError('almazan cross-evaluation proposes a k=4 k-cross evaluation, {} out of range'.format(k))\n test_idcs = [idx for idx, fold in enumerate(self.fold_idcs) if fold == k]\n train_idcs = list(set(range(len(self))).difference(set(test_idcs)))\n return self.sub_set(train_idcs), self.sub_set(test_idcs)","def kfold_cross_validation(X, n_splits=5):\r\n X_train_folds = []\r\n X_test_folds = []\r\n\r\n x_len = len(X)\r\n \r\n fold_modulus = x_len % n_splits\r\n \r\n start_idx = 0\r\n for fold in range(n_splits): \r\n\r\n if fold < fold_modulus:\r\n fold_size = x_len // n_splits + 1\r\n else:\r\n fold_size = x_len // n_splits\r\n\r\n fold_end = (start_idx + fold_size) - 1\r\n\r\n tmp = []\r\n for i in range(start_idx, fold_end + 1):\r\n tmp.append(i)\r\n X_test_folds.append(tmp)\r\n\r\n tmp = []\r\n for i in range(0, x_len):\r\n if i not in X_test_folds[fold]:\r\n tmp.append(i)\r\n X_train_folds.append(tmp)\r\n\r\n start_idx = fold_size + start_idx \r\n\r\n return X_train_folds, X_test_folds","def crossValidate(x_training_data, y_training_data, test_size_percentage, k_values):\n data_length = len(x_training_data)\n foldSize = int(round(data_length * test_size_percentage)) # size of each temporary test data\n groups = int(data_length/foldSize + 1) # # of groups\n\n best_score = 0\n best_k = 0\n\n for k in k_values: # Test different values of k\n score = 0\n for i in range(0, data_length, foldSize): # Switch section of test data\n \n x_temp_test = x_training_data[i:i+foldSize] # get temporary data to test\n known_y_test = y_training_data[i:i+foldSize] # we already know their labels\n x_temp_training = np.append(x_training_data[0:i], x_training_data[i+foldSize:], axis=0) # the rest is our temporary training data\n y_temp_training = np.append(y_training_data[0:i], y_training_data[i+foldSize:], axis=0)\n\n y_temp_test = knnForAll(x_temp_training, y_temp_training, x_temp_test, k) # labels determined for a current k value\n\n for i in range(len(known_y_test)): # Score how well this value of k did based \n if y_temp_test[i] == known_y_test[i]: # on how well it matches the known labels\n score += 1\n\n print(\"k:\",k,\"-- % correct: \",\"{:0.2f}\".format(score/data_length)) # print accuracy for training data \n if score > best_score: # Choose the best k value up to this point\n best_score = score\n best_k = k\n\n return best_k","def cross_valid(model,x,folds,metric,verbose=True): \r\n\r\n score=[]\r\n \r\n\r\n kf = KFold(folds,shuffle=False,random_state=0) \r\n\r\n\r\n i=0\r\n for train_index, test_index in kf.split(x):\r\n\r\n xtrain = x[train_index,:]\r\n xtest = x[test_index,:]\r\n\r\n model.fit(xtrain[:,:-1],xtrain[:,-1])\r\n\r\n ypred = model.predict(xtest[:,:-1])\r\n\r\n ytrue= xtest[:,-1] \r\n \r\n \r\n if metric == 'mae':\r\n score.append(mae(ytrue,ypred))\r\n elif metric == 'mse':\r\n score.append(mse(ytrue,ypred))\r\n elif metric == 'rrmse':\r\n score.append(rrmse(ytrue,ypred))\r\n\r\n else:\r\n score.append(rmse(xtest[:,-1],ypred))\r\n\r\n if verbose:\r\n print('-'*30)\r\n print(f'\\nFold {i+1} out of {folds}')\r\n print(f'{metric}: {score[i]}')\r\n\r\n i+=1\r\n\r\n if verbose:\r\n print(f'\\n Overall Score:')\r\n print(f'{metric}: Mean: {np.mean(score)} Std: {np.std(score)}')\r\n\r\n\r\n return score","def cross_validation(features, target, n_neighbors=5, n_folds=5):\n clf = KNeighborsClassifier(n_neighbors=n_neighbors)\n cv_scores = cross_val_score(clf, features, target, cv=n_folds)\n # print each cv score (accuracy) and average them\n print('Cross Validation Scores Mean: %.2f' % (np.mean(cv_scores) * 100))","def nestedKFoldValidation(k, X, y, kernel):\n\n print(\"running k-folds cross validation to find best slack C\")\n\n # list of slack variable values used to test the SVM with\n C_list = [0.001, 0.01, 0.1, 1.0, 10.0, 100, 1000]\n # number of iterations to run the bootstrapping\n B = 30\n\n sample_list = list(range(len(y)))\n np.random.shuffle(sample_list)\n\n # splitting list into k folds\n foldSize = len(y)//k\n folds = [sample_list[i*foldSize:(i+1)*foldSize] for i in range(k)]\n\n # add remaining items to the last fold\n folds[-1] += sample_list[foldSize*k:]\n\n test_results = {}\n for test in folds:\n print('==== next outer fold ====')\n # python dictionary to keep track of errors\n error_dict = {}\n for validation in folds:\n # do not want identical test and validation folds\n if validation == test:\n continue\n\n # training data is all folds except for test and validation\n train = [f for f in folds if f != test and f != validation][0]\n # find errors across all parameters\n for c in C_list:\n alg = SVC(C=c, kernel=kernel)\n alg.fit(X[train], y[train])\n err = np.mean(y[validation] != alg.predict(X[validation]))\n # keep track of all errors\n if c not in error_dict:\n error_dict[c] = {}\n error_dict[c]['err'] = []\n error_dict[c]['model'] = alg\n error_dict[c]['err'].append(err)\n\n # finding the best parameter from the inner loop\n bestC = -1\n bestError = 1.0\n for c in error_dict:\n print('c=', c, 'err=', np.mean(error_dict[c]['err']))\n err = np.mean(error_dict[c]['err'])\n if err < bestError:\n bestError = err\n bestC = c\n print('best c from inner loop is', bestC)\n\n # testing the best model from the inner loop against test data\n train_err = np.mean(y[test] != alg.predict(X[test]))\n if bestC not in test_results:\n test_results[bestC] = []\n test_results[bestC].append(train_err)\n\n for c in test_results:\n print('c=', c,\n 'mean error=', np.mean(test_results[c]),\n 'stddev of errors=', np.std(test_results[c]))","def kFoldCrossValidation(self, n_splits ):\n X = self.X\n y = self.y\n\n k_fold = KFold(n_splits)\n model = self.model\n\n for train, test in k_fold.split(X):\n model.fit(X[train], y[train])\n p = model.predict( X[test] )\n # Add line for scores\n\n return model #return scores here?","def k_fold_cross_validation(data, K, randomise = False, random_seed=None, structured=None):\n if randomise:\n import random\n if random_seed != None:\n random.seed(random_seed)\n random.shuffle(data.data)\n datatr=data.make_clone()\n datatst=data.make_clone()\n\n for k in xrange(K):\n datatr.data = []\n index_tr = []\n datatst.data = []\n index_tst = []\n for i, x in enumerate(data.data) :\n if i % K != k :\n datatr.data.append(x)\n index_tr.append(i)\n else :\n datatst.data.append(x)\n index_tst.append(i)\n yield datatr, datatst, index_tr, index_tst","def generate_k_folds(dataset, k):\n\n # TODO: finish this.\n folds = []\n dataset = np.concatenate((dataset[0], np.array(dataset[1]).reshape(-1,1)), axis=1)\n dataset_shape = dataset.shape\n shape_test_set = int(round(dataset_shape[0]/k,0))\n split_dataset = np.array_split(dataset,k,axis=0)\n for i in range(k):\n test_set = split_dataset[i]\n c = [k for j,k in enumerate(split_dataset) if j!=i]\n training_set = np.concatenate(c,axis=0)\n if test_set.shape[0] != shape_test_set:\n step = test_set.shape[0] - shape_test_set\n test_set = test_set[:-step,:]\n training_set = np.concatenate((training_set, test_set[-step:,:]), axis=0)\n r_test_set = (test_set[:,:-1], list(test_set[:,-1]))\n r_train_set = (training_set[:,:-1], list(training_set[:,-1]))\n folds.append((r_train_set, r_test_set))\n return folds","def cross_validation(y, x, K, model, lambda_, gamma, max_iters, initial_w, num_epochs=1, shuffle=True, seed=1):\n data_size = len(y) ## Number of data points\n x = np.array(x)\n y = np.array(y)\n\n count = 0\n batch_size = int(data_size/K) ## Data size assumed to multiple of K\n err_val = np.zeros(num_epochs*K)\n err_train = np.zeros(num_epochs*K)\n\n # Set random seed such that model comparison is uniform and consistent\n np.random.seed(seed)\n\n # Number of times K-fold cross validation is repeated\n for epoch in range(num_epochs):\n print(\"epoch = {}\".format(epoch))\n # Randomize to remove ordering in the input data\n if shuffle == True:\n shuffle_ind = np.random.permutation(np.arange(data_size))\n y_shuffle = y[shuffle_ind]\n x_shuffle = x[shuffle_ind]\n else:\n y_shuffle = y\n x_shuffle = x\n\n # K-fold cross validation\n for k in range(0,K):\n print(\"k = {}\".format(k))\n\n # Select validation data in kth fold\n start_val_ind = k*batch_size\n end_val_ind = (k+1)*batch_size\n y_val = y_shuffle[start_val_ind: end_val_ind]\n x_val = x_shuffle[start_val_ind: end_val_ind]\n\n # Select training data in kth fold\n train_ind = np.setxor1d(range(0,data_size),range(start_val_ind,end_val_ind))\n y_train = y_shuffle[train_ind]\n x_train = x_shuffle[train_ind]\n\n # Logistic regression and reg_logistic_regression models\n if ((model=='logistic_regression') or (model=='reg_logistic_regression')):\n if model=='logistic_regression': ## Train the model\n w, loss = logistic_regression((1+y_train)/2, x_train, initial_w, max_iters, gamma)\n elif model=='reg_logistic_regression':\n w, loss = reg_logistic_regression((1+y_train)/2, x_train, lambda_, initial_w, max_iters, gamma)\n # Predict on validation and training data\n y_pred_val = np.ones(len(y_val))\n y_pred_val[sigmoid(np.dot(x_val,w)) <= 0.5] = -1\n y_pred_train = np.ones(len(y_train))\n y_pred_train[sigmoid(np.dot(x_train,w)) <= 0.5] = -1\n\n\n # Least squares models\n else:\n if model == 'least_squares': ## Least squares regression using normal equation\n w, loss = least_squares(y_train, x_train)\n elif model == 'least_squares_GD': ## Least squares regression using gradient descent\n w, loss = least_squares_GD(y_train, x_train, initial_w, max_iters, gamma)\n elif model == 'least_squares_SGD': ## Least squares regression using stochastic gradient descent\n w, loss = least_squares_SGD(y_train, x_train, initial_w, max_iters, gamma)\n elif model == 'ridge_regression': ## Ridge regression\n w, loss = ridge_regression(y_train, x_train, lambda_)\n else:\n print(\"Unknown model\")\n # Predict on validation and training data\n y_pred_val = predict_labels(w, x_val) ## Predict on validation data\n y_pred_train = predict_labels(w, x_train) ## Predict on training data\n\n err_val[count] = sum(y_pred_val!=y_val)/len(y_val) ## Accuaracy on Validation data\n err_train[count] = sum(y_pred_train!=y_train)/len(y_train) ## Accuaracy on training data\n count+=1\n\n ## Average error over all folds of cross validation\n avg_val_err = np.mean(err_val)\n avg_train_err = np.mean(err_train)\n\n ## Return optimal weight, loss, average validation error, average training error\n return w, loss, avg_val_err, avg_train_err","def crossValidate(k, epochs, hyperparams, data, trainFunc, testFunc, report=None):\n \n if not (report == None):\n tabs = '\\t' * report;\n print tabs, 'Performing %d-fold cross validation...' % k;\n \n # create vars to save the best hyperparameters and their performance\n bestTheta = None;\n bestRate = float(\"-inf\");\n \n # create queue for worker threads to post results to\n queue = mp.Queue();\n \n # create train/test folds\n numPerFold = len(data) // k;\n numLeftOver = len(data) % k;\n folds = [data[i*numPerFold:i*numPerFold+numPerFold] for i in range(0, k)];\n if numLeftOver > 0:\n folds[-1].extend(data[-numLeftOver:]); \n \n # create a list of tuples; each tuple defining a unique assignment of hyperparameters \n thetas = list(itertools.product(*hyperparams));\n \n # create worker threads try all combinations of hyperparameters \n workers = []; \n for theta in thetas: \n p = mp.Process(target=cvWorker, args=(epochs, theta, folds, trainFunc, \\\n testFunc, report, queue));\n workers.append(p)\n \n # start worker threads and wait for them to finish\n for p in workers:\n p.start();\n for p in workers:\n p.join()\n \n if not (report == None):\n print tabs, 'All worker threads have terminated.';\n \n # read results out of queue \n while not queue.empty():\n [theta, rate] = queue.get();\n if rate > bestRate:\n bestTheta = theta\n bestRate = rate;\n \n return bestTheta;","def executeKFoldValidation(train_data, train_labels, val_data, val_labels, test_data, test_labels,\n images_47, labels_47, images_84, labels_84, all_unseen_images, all_unseen_labels):\n if run_k_fold_validation:\n print(\"In executingKFoldValidation\")\n\n # this is doing it manually:\n kfold = StratifiedKFold(n_splits=k_fold_num, shuffle=True)\n\n test_scores_list = []\n unseen_47_scores_list = []\n unseen_84_scores_list = []\n all_unseen_scores_list = []\n\n test_matrix_list = []\n matrix_47_list = []\n matrix_84_list = []\n all_matrix_list = []\n kf_counter = 0\n\n for train, test in kfold.split(train_data, train_labels):\n kf_counter += 1\n print('KFold #:', kf_counter)\n\n model = buildClassifier()\n # fit the model\n model.fit(train_data[train],\n train_labels[train],\n epochs=epochs,\n validation_data=(val_data, val_labels),\n batch_size=batch_size\n )\n\n unseen_47_scores = model.evaluate(images_47, labels_47, batch_size=batch_size)\n unseen_47_scores_list.append(unseen_47_scores[1] * 100)\n unseen_84_scores = model.evaluate(images_84, labels_84, batch_size=batch_size)\n unseen_84_scores_list.append(unseen_84_scores[1] * 100)\n test_scores = model.evaluate(test_data, test_labels, batch_size=batch_size)\n test_scores_list.append(test_scores[1] * 100)\n all_unseen_score = model.evaluate(all_unseen_images, all_unseen_labels, batch_size=batch_size)\n all_unseen_scores_list.append(all_unseen_score[1] * 100)\n\n # show confusion matrix\n test_confusion_matrix, confusion_matrix_47, confusion_matrix_84, all_confusion_matrix = \\\n gettingKFoldConfusionMatrix(test_data, test_labels, images_47, labels_47, images_84, labels_84,\n all_unseen_images,\n all_unseen_labels, kf_counter)\n test_matrix_list.append(test_confusion_matrix)\n matrix_47_list.append(confusion_matrix_47)\n matrix_84_list.append(confusion_matrix_84)\n all_matrix_list.append(all_confusion_matrix)\n\n test_scores_mean = np.mean(test_scores_list)\n test_scores_std = np.std(test_scores_list)\n unseen_47_mean = np.mean(unseen_47_scores_list)\n unseen_47_std = np.std(unseen_47_scores_list)\n unseen_84_mean = np.mean(unseen_84_scores_list)\n unseen_84_std = np.std(unseen_84_scores_list)\n all_unseen_mean = np.mean(all_unseen_scores_list)\n all_unseen_std = np.std(all_unseen_scores_list)\n\n print(\"Test Scores: \" + str(test_scores_list))\n print(\"Test Scores Mean: \" + str(test_scores_mean))\n print(\"Test Scores Std: \" + str(test_scores_std))\n print(\"Unseen 47 Scores: \" + str(unseen_47_scores_list))\n print(\"Unseen 47 Scores Mean: \" + str(unseen_47_mean))\n print(\"Unseen 47 Scores Std: \" + str(unseen_47_std))\n print(\"Unseen 84 Scores: \" + str(unseen_84_scores_list))\n print(\"Unseen 84 Scores Mean: \" + str(unseen_84_mean))\n print(\"Unseen 84 Scores Std: \" + str(unseen_84_std))\n print(\"All Unseen Scores: \" + str(all_unseen_scores_list))\n print(\"All Unseen Scores Mean: \" + str(all_unseen_mean))\n print(\"All Unseen Scores Std: \" + str(all_unseen_std))\n print(\"Test Confusion Matrices: \" + str(test_matrix_list))\n print(\"47 Confusion Matrices: \" + str(matrix_47_list))\n print(\"84 Confusion Matrices: \" + str(matrix_84_list))\n print(\"All Confusion Matrices: \" + str(all_matrix_list))\n\n excel_headers.append(\"Test Scores Mean\")\n excel_dictionary.append(test_scores_mean)\n excel_headers.append(\"Test Scores Std\")\n excel_dictionary.append(test_scores_std)\n excel_headers.append(\"Unseen 47 Scores Mean\")\n excel_dictionary.append(unseen_47_mean)\n excel_headers.append(\"Unseen 47 Scores Std\")\n excel_dictionary.append(unseen_47_std)\n excel_headers.append(\"Unseen 84 Scores Mean\")\n excel_dictionary.append(unseen_84_mean)\n excel_headers.append(\"Unseen 84 Scores Std\")\n excel_dictionary.append(unseen_84_std)\n excel_headers.append(\"All Unseen Scores Mean\")\n excel_dictionary.append(all_unseen_mean)\n excel_headers.append(\"All Unseen Scores Std\")\n excel_dictionary.append(all_unseen_std)\n\n plt.plot(test_scores_list, color='red', label='Testing Scores')\n plt.plot(unseen_47_scores_list, color='blue', label='Unseen 47 Scores')\n plt.plot(unseen_84_scores_list, color='black', label='Unseen 84 Scores')\n plt.plot(all_unseen_scores_list, color='green', label='Unseen Scores')\n plt.xlabel('Folds')\n plt.ylabel('Accuracy')\n plt.legend()\n\n plt.show()","def cross_validation(y, tx, k_fold, fit_function, score_function, seed=1, **fit_function_kwargs):\n k_indices = build_k_indices(y, k_fold, seed)\n score_te = 0\n\n for k in range(k_fold):\n te_indices = k_indices[k]\n tr_indices = k_indices[~(np.arange(k_indices.shape[0]) == k)].reshape(-1)\n\n y_te, x_te = y[te_indices], tx[te_indices]\n y_tr, x_tr = y[tr_indices], tx[tr_indices]\n\n w, fit_loss = fit_function(y_tr, x_tr, **fit_function_kwargs)\n score_te += score_function(y_te, x_te, w)\n\n return score_te/k_fold","def cross_validation(ww_data, rw_data, k):\n # shuffle the data\n np.random.shuffle(ww_data)\n np.random.shuffle(rw_data)\n\n # calculate cutoff for each partition\n cutoff = ww_data.shape[0]//k\n redArr = []\n whiteArr = []\n tmpStart = 0\n tmpEnd = cutoff\n \n # create a list of k partitions for red and white data\n for x in range(k):\n if x != k-1:\n redArr.append(rw_data[tmpStart:tmpEnd])\n whiteArr.append(ww_data[tmpStart:tmpEnd])\n else:\n redArr.append(rw_data[tmpStart:])\n whiteArr.append(ww_data[tmpStart:])\n tmpStart+=cutoff\n tmpEnd+=cutoff\n\n\n redTraining = np.array(())\n whiteTraining = np.array(())\n accuracy = 0\n count = 0\n \n for x in range(k):\n # creates Test data set\n tmpRedTest = redArr[x]\n tmpWhiteTest = whiteArr[x]\n \n # creates list of partitons for training data set\n if x!=k-1:\n redTrainingList = redArr[:x] + redArr[x+1:]\n whiteTrainingList = whiteArr[:x] + whiteArr[x+1:]\n else:\n redTrainingList = redArr[:x]\n whiteTrainingList = whiteArr[:x]\n\n # stacks each training list into one nparray\n redTraining = np.vstack(redTrainingList)\n whiteTraining = np.vstack(whiteTrainingList)\n\n accuracy += experiment(whiteTraining, redTraining, tmpWhiteTest, tmpRedTest)\n count += 1\n # calculates accuracy and returns it\n result = accuracy/count\n return result","def crossValidate(dataset, folds):\n\tshuffle(dataset)\n\tcv_results = []\n\tprecision_recall_acc = []\n\tfoldSize = int(len(dataset)/folds)\n\tfor i in range(0,len(dataset),foldSize):\n\t\t# preparing data\n\t\tvalD = dataset[i:i+foldSize]\n\t\ttestD = dataset[:i]+dataset[i+foldSize:] #list(set(dataset)-set(dataset[i:i+foldSize]))\n\t\t# Training\n\t\tprint(\"*\"*60)\n\t\tprint(\"Training on data-set size \"+str(len(testD))+\" of batch \"+str(i/(foldSize)))\n\t\tclassi = trainClassifier(testD)\n\t\t# Prediction on validation data \n\t\tprint(\"Predicting on heldout data-set size...\"+str(len(valD))+\" of batch \"+str(i/(foldSize)))\n\t\ty_true = list(map(lambda t: t[1], valD))\n\t\ty_pred = predictLabels(valD,classi)\t\t\n\t\t# Performance Metrics\t\t\n\t\t# average based on macro as it calculate metrics for each label, and find their unweighted mean.\n\t\tprecision_recall = list(precision_recall_fscore_support(y_true, y_pred, average='macro'))\n\t\tacc = accuracy_score(y_true,y_pred)\n\t\tprecision_recall[-1] = acc\n\t\tprint(precision_recall)\n\t\tprecision_recall_acc.append(precision_recall)\n\tdf = pd.DataFrame(precision_recall_acc,columns = [\"Precision\",\"Recall\",\"F1 score\",\"Accuracy Score\"])\n\tprint(df)\n\tcv_results = df.mean().tolist()\n\treturn cv_results","def cross_validation(self, X, y, n_folds=5, shuffle=True, evaluation_metric='top30'):\n # WE DON'T USE THIS\n # We use basic train-test split to evaluate or models as a first approach\n # We will then use CV for searching the best parameters via random search\n pass","def cross_validate(model, X, y, folds=5, epochs=5, batch_size=32, callbacks=None, shuffle=False, random_state=None):\n\n # Initalize KFold\n kfolds = KFold(n_splits=folds, random_state=random_state, shuffle=shuffle)\n all_metrics = []\n\n # To build the model\n if type(model).__name__ == 'SVDpp':\n model.implicit_feedback(X[:10, :])\n model(X[:10, :])\n\n # Workaround to reset weights after each fold fit\n weights = model.get_weights()\n i = 1\n\n for train, val in kfolds.split(X, y):\n\n # Gather implicit feedback if model is SVD++\n if type(model).__name__ == 'SVDpp':\n model.implicit_feedback(X[train])\n\n print(f'\\nFitting on Fold {i}')\n # Train and evaluate metrics\n history = model.fit(\n X[train], y[train], batch_size=batch_size, epochs=epochs, callbacks=callbacks)\n print(f'\\nEvaluating on Fold {i}')\n fold_score = history.model.evaluate(X[val], y[val])\n all_metrics.append(fold_score)\n\n # Reset Weights\n model.set_weights(weights)\n\n i += 1\n\n all_metrics = np.array(all_metrics)\n\n for i, metric in enumerate(model.metrics_names):\n print(f'Mean {metric.capitalize()} : {np.mean(all_metrics.T[i])}')\n\n return all_metrics","def _kfold_cross_val(self, training_elms: np.ndarray) -> None:\n kf = model_selection.KFold(\n n_splits=config.folds, shuffle=True, random_state=config.seed\n )\n self.df[\"elm_events\"] = training_elms\n self.df[\"fold\"] = -1\n for f_, (_, valid_idx) in enumerate(kf.split(X=training_elms)):\n self.df.loc[valid_idx, \"fold\"] = f_","def cross_validation(self, x, t, k=5):\n print(\"Cross validation of the SVM Model...\")\n\n # Initialize best error / hyperparameters\n best_error = float('inf')\n best_reg = 0\n best_deg = 0\n\n # Cross-validation 80-20\n N = len(x)\n N_train = math.floor(0.8 * N)\n t = t.reshape((N,))\n\n #Initialize the grid search\n\n log_min_reg = np.log(0.001)\n log_max_reg = np.log(1000)\n reg_list = np.logspace(log_min_reg, log_max_reg, num=7, base=math.e)\n\n min_deg = 1\n max_deg = 4\n\n for deg in range(min_deg, max_deg):\n for reg in reg_list:\n errors = np.zeros(k)\n for j in range(k):\n map_index = list(zip(x, t))\n random.shuffle(map_index)\n random_x, random_t = zip(*map_index)\n\n train_x = random_x[:N_train]\n valid_x = random_x[N_train:]\n train_t = random_t[:N_train]\n valid_t = random_t[N_train:]\n\n self.model = SVC(gamma='auto', kernel='poly', degree=deg, C=reg, cache_size=1000)\n self.train(train_x, train_t)\n\n error_valid = np.array([self.error(x_n, t_n) for t_n, x_n in zip(valid_t, valid_x)])\n errors[j] = error_valid.mean()\n\n mean_error = np.mean(errors)\n print(mean_error)\n if mean_error < best_error:\n best_error = mean_error\n best_reg = reg\n best_deg = deg\n print(\"The new best hyper parameters are : \", best_reg, best_deg)\n\n print(\"Best hyper parameters are : \", best_reg, best_deg)\n print(\"Validation error : \", 100 * best_error, \"%\")\n self.model = SVC(gamma='auto', kernel='poly', degree=best_deg, C=best_reg)\n self.train(x, t)","def _cross_val(self, X, y, classifier, nfolds=10):\n\n # Make sure dimensions agree\n assert X.shape[0] == y.shape[0], \"Number of observations should equal\" \\\n \"number of labels.\"\n\n # Concatenate data in order to shuffle without changing X-y correspondence\n data = np.c_[X, y]\n\n # Shuffle data (swaps rows when 2D - works OK for us)\n np.random.seed(42)\n np.random.shuffle(data)\n\n # Split data into (almost) equal folds (returns a list of arrays)\n # and we cast the list into a numpy array in order to do list indexing\n data = np.array(np.array_split(data, nfolds))\n\n # Do the k-fold cross-validation\n accs = []\n for k in range(nfolds):\n # Get current test set\n X_k_test = data[k][:, :-1]\n y_k_test = data[k][:, -1]\n\n # Get remaining indices and current training set\n remaining_idx = [i for i, v in enumerate(data) if i != k]\n X_k_train = np.vstack(data[remaining_idx])[:, :-1]\n y_k_train = np.vstack(data[remaining_idx])[:, -1]\n\n # Fit and predict with classifier\n classifier.fit(X_k_train, y_k_train)\n yhat = classifier.predict(X_k_test)\n\n # Store error rate\n accs.append(self._accuracy(y_k_test, yhat))\n\n return np.array(accs)","def __implement_cross_validation(self, X, y, model):\n\n skfolds = StratifiedKFold(n_splits=3, random_state=42)\n\n for train_index, test_index in skfolds.split(X, y):\n clone_clf = clone(model)\n X_train_folds = X[train_index]\n y_train_folds = y[train_index]\n X_test_fold = X[test_index]\n y_test_fold = y[test_index]\n\n clone_clf.fit(X_train_folds, y_train_folds)\n y_pred = clone_clf.predict(X_test_fold)\n n_correct = sum(y_pred == y_test_fold)\n message = \"ratio of correct predictions: \", n_correct / len(y_pred)\n self.__logger.info(message)","def k_fold_cross_validation(self, K: int=5, rem_day4:bool=True, smote: bool=True, shuffle: bool=False) -> dict:\n k_folds = {}\n\n for k in range(K):\n k_folds[k] = {\"X_train\": [], \"X_test\": [], \"y_test\": [], \"y_train\": []}\n for df in self.dataframes:\n header = set(df['label'].tolist())\n # Removing Day 4\n trails = set()\n for i in header:\n trail = eval(i)\n if trail[0] != 4:\n trails.add(i)\n else:\n if not(rem_day4):\n trails.add(i)\n\n header = trails\n\n for trial in header:\n # geting rows with (day, Trail)-label\n rows = df.loc[df['label'] == trial].to_numpy()\n # getting response label\n response = rows[0][-1]\n # getting the actual data from the matrix\n rows = np.delete(rows, np.s_[0,1,-1], axis=1)\n\n chunks = np.array_split(rows, K)\n for chunk in chunks[k]:\n k_folds[k][\"X_test\"].append(chunk.astype(np.float))\n k_folds[k][\"y_test\"].append(response)\n\n train_chunks = np.delete(chunks, k, axis=0)\n for chunk in train_chunks:\n for ch in chunk:\n k_folds[k][\"X_train\"].append(ch.astype(np.float))\n k_folds[k][\"y_train\"].append(response)\n\n\n for k in range(K):\n\n self.X_test = np.asarray(k_folds[k][\"X_test\"])\n self.y_test = np.asarray(k_folds[k][\"y_test\"])\n self.X_train = np.asarray(k_folds[k][\"X_train\"])\n self.y_train = np.asarray(k_folds[k][\"y_train\"])\n\n if smote:\n self.use_SMOTE()\n\n if shuffle:\n self.shuffle_labels()\n\n k_folds[k][\"X_test\"] = self.X_test\n k_folds[k][\"X_train\"] = self.X_train\n k_folds[k][\"y_test\"] = self.y_test\n k_folds[k][\"y_train\"] = self.y_train\n\n return k_folds","def crossValidate(self, args):\n\n ##################################\n # Read the training data\n ##################################\n if not os.path.isdir(args.annotationPath):\n print('annotation path does not exist: {}' \\\n .format(args.annotationPath))\n return -1\n\n data = self.readData(args.annotationPath)\n\n ############################\n # Execute the K-Fold cross validation\n ############################\n\n x = []\n y = []\n l = []\n for subject, df in data.items():\n lx = df[['gradient', 'rate']].values.tolist()\n #lx = df[['rate']].values.tolist()\n ly = np.array(df[['immersion']].values.tolist()).squeeze(-1)\n x.extend(lx)\n y.extend(ly.tolist())\n l.append(len(lx))\n\n x = np.array(x)\n y = np.array(y)\n\n print('Executing cross-validation with k = {}...'.format(args.k))\n clf = StructuredPerceptron(random_state=2)\n scores = []\n folds = SequenceKFold(l, n_folds=args.k)\n for train_idx, train_len, test_idx, test_len in folds:\n xTrain = x[train_idx]\n yTrain = y[train_idx]\n clf.fit(xTrain, yTrain, train_len)\n\n xTest = x[test_idx]\n yTest = y[test_idx]\n yPred = clf.predict(xTest, test_len)\n scores.append(accuracy_score(yTest, yPred))\n\n scores = np.array(scores)\n print(scores)\n print('Result of the K-Fold CV: {:3f} (+- {:3f})' \\\n .format(scores.mean(), 2 * scores.std()))\n\n ############################\n # Execute the Leave-One-Out cross validation\n ############################\n\n\n return 0","def cross_validation(self, cv, lambdas, lambda_name, seed=1, skip=False, plot=False, **kwargs):\n np.set_printoptions(precision=4)\n k_indices = build_k_indices(self.train_y, cv, seed)\n # define lists to store the loss of training data and test data\n err_tr = []\n err_te = []\n weights = []\n print(\"K-fold ({}) cross validation to examine [{}]\".\n format(cv, lambdas))\n for lamb in lambdas:\n print(\"For lambda: {}\".format(lamb))\n _mse_tr = []\n _mse_te = []\n _weight = []\n for k in range(cv):\n print('Cross valid iteration {}'.format(k))\n weight, loss_tr, loss_te = self._loop_cross_validation(self.train_y, self.train_x,\n k_indices, k,\n lamb, lambda_name, **kwargs)\n _mse_tr += [loss_tr]\n _mse_te += [loss_te]\n _weight.append(weight)\n if skip:\n break\n avg_tr = np.average(_mse_tr)\n avg_te = np.average(_mse_te)\n err_tr += [avg_tr]\n err_te += [avg_te]\n weights.append(_weight)\n print(\"\\t train error {}, \\t valid error {}\".\n format(avg_tr, avg_te))\n # Select the best parameter during the cross validations.\n print('K-fold cross validation result: \\n {} \\n {}'.\n format(err_tr, err_te))\n # Select the best based on least err_te\n min_err_te = np.argmin(err_te)\n print('Best err_te result {}, lambda {}'.\n format(err_te[min_err_te], lambdas[min_err_te]))\n if plot:\n from plots import cross_validation_visualization\n cross_validation_visualization(lambdas, err_tr, err_te, title=lambda_name,\n error_name=self.loss_function_name)\n else:\n save_numpy_array(lambdas, err_tr, err_te, names=['lambda', 'err_tr', 'err_te'], title=self.regularizer.name)\n\n return weights[min_err_te], lambdas[min_err_te], (err_tr, err_te)","def cross_validation(exp_name):\n click.echo(\"Mode: Cross-validation.\")\n # defaults = get_defaults()\n\n # fitted_model_filename = add_extension(fitted_model_filename)\n\n # derive final path for fitted model as base output path for fitted models + model filename\n # fitted_model_path = os.path.join(defaults.OUTPUT.FITTED_MODELS_PATH, fitted_model_filename)\n # new_options = [\"OUTPUT.FITTED_MODEL_PATH\", fitted_model_path]\n\n # don't reserve dev set at this point since we need to do it in each cv fold\n boot_data = bootstrap(new_options=None, mode=\"cv\")\n\n defaults = boot_data['defaults']\n X_train, y_train = boot_data['data']\n\n cv = RepeatedStratifiedKFold(n_splits=defaults.EVAL.N_SPLITS,\n n_repeats=defaults.EVAL.N_REPEATS,\n random_state=defaults.MISC.SEED)\n\n s = time.time()\n outer_results, outer_preds = cross_validate(X=X_train, y=y_train,\n cv=cv,\n conf=defaults)\n print(\"Execution time: %s seconds.\" % (time.time() - s))\n\n # dump results\n # fitted_model_best_params_path = os.path.join(defaults.OUTPUT.PARAMS_PATH,\n # \"best_params_{}.pkl\".format(fitted_model_filename.split('.')[0]))\n\n outer_results_formatted = show_cross_val_results(outer_results, conf=defaults)\n\n cv_results_path = os.path.join(defaults.OUTPUT.RESULTS_PATH, \"cv_results_{}.csv\".format(exp_name))\n outer_results_formatted.to_csv(cv_results_path)\n\n # save predictions\n outer_preds_path = os.path.join(defaults.OUTPUT.PREDS_PATH, \"cv_pooled_preds_{}.pkl\".format(exp_name))\n save_obj(outer_preds, outer_preds_path)","def kfold_cross_validate(\n num_folds: int,\n config: Union[dict, str],\n dataset: str = None,\n data_format: str = None,\n skip_save_training_description: bool = False,\n skip_save_training_statistics: bool = False,\n skip_save_model: bool = False,\n skip_save_progress: bool = False,\n skip_save_log: bool = False,\n skip_save_processed_input: bool = False,\n skip_save_predictions: bool = False,\n skip_save_eval_stats: bool = False,\n skip_collect_predictions: bool = False,\n skip_collect_overall_stats: bool = False,\n output_directory: str = \"results\",\n random_seed: int = default_random_seed,\n gpus: Union[str, int, List[int]] = None,\n gpu_memory_limit: Optional[float] = None,\n allow_parallel_threads: bool = True,\n backend: Union[Backend, str] = None,\n logging_level: int = logging.INFO,\n **kwargs,\n) -> Tuple[dict, dict]:\n # if config is a path, convert to dictionary\n if isinstance(config, str): # assume path\n config = load_yaml(config)\n backend = initialize_backend(backend or config.get(\"backend\"))\n\n # check for k_fold\n if num_folds is None:\n raise ValueError(\"k_fold parameter must be specified\")\n\n logger.info(f\"starting {num_folds:d}-fold cross validation\")\n\n # create output_directory if not available\n if not os.path.isdir(output_directory):\n os.mkdir(output_directory)\n\n # prepare data for k-fold processing\n # use Ludwig's utility to facilitate creating a dataframe\n # that is used as the basis for creating folds\n\n dataset, _, _, _ = load_dataset_uris(dataset, None, None, None, backend)\n\n # determine data format of provided dataset\n if not data_format or data_format == \"auto\":\n data_format = figure_data_format(dataset)\n\n data_df = load_dataset(dataset, data_format=data_format, df_lib=backend.df_engine.df_lib)\n\n kfold_cv_stats = {}\n kfold_split_indices = {}\n\n for train_indices, test_indices, fold_num in generate_kfold_splits(data_df, num_folds, random_seed):\n with tempfile.TemporaryDirectory() as temp_dir_name:\n curr_train_df = data_df.iloc[train_indices]\n curr_test_df = data_df.iloc[test_indices]\n\n kfold_split_indices[\"fold_\" + str(fold_num)] = {\n \"training_indices\": train_indices,\n \"test_indices\": test_indices,\n }\n\n # train and validate model on this fold\n logger.info(f\"training on fold {fold_num:d}\")\n\n model = LudwigModel(\n config=config,\n logging_level=logging_level,\n backend=backend,\n gpus=gpus,\n gpu_memory_limit=gpu_memory_limit,\n allow_parallel_threads=allow_parallel_threads,\n )\n (eval_stats, train_stats, preprocessed_data, output_directory) = model.experiment(\n training_set=curr_train_df,\n test_set=curr_test_df,\n experiment_name=\"cross_validation\",\n model_name=\"fold_\" + str(fold_num),\n skip_save_training_description=skip_save_training_description,\n skip_save_training_statistics=skip_save_training_statistics,\n skip_save_model=skip_save_model,\n skip_save_progress=skip_save_progress,\n skip_save_log=skip_save_log,\n skip_save_processed_input=skip_save_processed_input,\n skip_save_predictions=skip_save_predictions,\n skip_save_eval_stats=skip_save_eval_stats,\n skip_collect_predictions=skip_collect_predictions,\n skip_collect_overall_stats=skip_collect_overall_stats,\n output_directory=os.path.join(temp_dir_name, \"results\"),\n random_seed=random_seed,\n )\n\n # augment the training statistics with scoring metric from\n # the hold out fold\n train_stats_dict = dataclasses.asdict(train_stats)\n train_stats_dict[\"fold_eval_stats\"] = eval_stats\n\n # collect training statistics for this fold\n kfold_cv_stats[\"fold_\" + str(fold_num)] = train_stats_dict\n\n # consolidate raw fold metrics across all folds\n raw_kfold_stats = {}\n for fold_name in kfold_cv_stats:\n curr_fold_eval_stats = kfold_cv_stats[fold_name][\"fold_eval_stats\"]\n for of_name in curr_fold_eval_stats:\n if of_name not in raw_kfold_stats:\n raw_kfold_stats[of_name] = {}\n fold_eval_stats_of = curr_fold_eval_stats[of_name]\n\n for metric in fold_eval_stats_of:\n if metric not in {\n \"predictions\",\n \"probabilities\",\n \"confusion_matrix\",\n \"overall_stats\",\n \"per_class_stats\",\n \"roc_curve\",\n \"precision_recall_curve\",\n }:\n if metric not in raw_kfold_stats[of_name]:\n raw_kfold_stats[of_name][metric] = []\n raw_kfold_stats[of_name][metric].append(fold_eval_stats_of[metric])\n\n # calculate overall kfold statistics\n overall_kfold_stats = {}\n for of_name in raw_kfold_stats:\n overall_kfold_stats[of_name] = {}\n for metric in raw_kfold_stats[of_name]:\n mean = np.mean(raw_kfold_stats[of_name][metric])\n std = np.std(raw_kfold_stats[of_name][metric])\n overall_kfold_stats[of_name][metric + \"_mean\"] = mean\n overall_kfold_stats[of_name][metric + \"_std\"] = std\n\n kfold_cv_stats[\"overall\"] = overall_kfold_stats\n\n logger.info(f\"completed {num_folds:d}-fold cross validation\")\n\n return kfold_cv_stats, kfold_split_indices","def stratified_kfold_cross_validation(X, y, n_splits=5):\n\n #Define variables\n X_train_folds = []\n X_test_folds = []\n\n #Create dictionary \n y_dict = myutils.group_by(y)\n\n #Split data\n folds = [[] for _ in range(n_splits)]\n for category in y_dict.keys():\n index = y_dict[category]\n for i in range(len(index)):\n folds[i % n_splits].append(index[i])\n\n #Add data to train and testing sets\n for i in range(n_splits):\n train = []\n for j in range(n_splits):\n if i != j:\n for item in folds[j]:\n train.append(item)\n test = folds[i]\n X_train_folds.append(train)\n X_test_folds.append(test)\n \n return X_train_folds, X_test_folds","def tenfold_cross_validation(X, y):\n\n i = 0\n x_score = []\n y_score = []\n\n for i in range(1, 11):\n for train_index, test_index in KFold(10).split(X):\n x_train, x_test = X[train_index], X[test_index]\n y_train, y_test = y[train_index], y[test_index]\n\n # change the parameters to see how each parameter affects the l1inear classifier\n linear_classifier = linear_model.SGDClassifier(max_iter=1000, tol=1e-3)\n\n # start training the classifier\n linear_classifier.fit(x_train, y_train)\n\n # create and plot the confusion matrix\n # cross validation done with cross_val_\n y_train_pred = cross_val_predict(linear_classifier, x_test, y_test, cv=10)\n\n print(\"\\n Statistics and Confusion matrix obtained with pandas_ml: \\n\")\n cm = ConfusionMatrix(y_test, y_train_pred)\n stats = cm.stats()\n\n file = open(\"linear_classification_9000_cross_validation_\" + str(i) + \".txt\", \"w\")\n file.write(str(stats))\n file.close()\n\n # cm.print_stats()\n # print confusion matrix\n cm.plot(normalized=True)\n plt.show()","def cross_validation_score(X_data, y_data, model, folds=5):\n\n # Shuffle index\n index = np.random.permutation(len(X_data))\n\n fold_size = int(len(X_data) / folds)\n scores = []\n for i in range(folds):\n \n # Partition Data\n X_train, X_val = partition_data(X_data[index], folds, i + 1, fold_size)\n y_train, y_val = partition_data(y_data[index], folds, i + 1, fold_size)\n\n # Train Model\n print(f\"Training on Fold: {i + 1}\")\n model.fit(X_train, y_train)\n\n # Predict Values on Validation Set\n val_pred = model.predict(X_val)\n\n # Get Accuracy\n score = accuracy_score(y_val, val_pred)\n scores.append(score)\n \n return sum(scores) / len(scores)","def HypeNKFoldCV(x,\n group_cols,\n target_col,\n clf,\n nfolds,\n kfolds,\n alpha,\n noise_std,\n scorer):\n ## all indices\n all_idx = x.copy().index.values\n ## will shuffle indices for randomisation\n np.random.shuffle(all_idx)\n ## outer splits indices\n outer_splits = np.array_split(all_idx, nfolds)\n ## scorer results\n scores_val = []\n ## outer cycle\n for i in range(nfolds):\n ## keep `i`-th fold for validation\n val_idx = outer_splits[i]\n x_val = x.loc[val_idx].copy()\n ## choose all but `i`-th split\n inner_idx = np.concatenate(outer_splits[:i] + outer_splits[(i + 1):])\n ## further randomise training indices\n np.random.shuffle(inner_idx)\n ## split others further\n inner_splits = np.array_split(inner_idx, kfolds)\n ## training data frame\n x_train = x.loc[inner_idx].copy()\n ## iterate over group cols\n for group_col in group_cols:\n n_col_name = '_'.join([group_col, target_col])\n ## encode using division into KFolds\n x_train.loc[:, n_col_name] = KFoldTargetEncoding(x_train[[group_col, target_col]].copy(),\n inner_splits,\n group_col,\n target_col,\n n_col_name,\n alpha,\n noise_std)\n ## filling in the same column on val\n ## using whole `x_train`\n x_val.loc[:, n_col_name] = targetEncoding(x_train.loc[:, [group_col, target_col]],\n x_val.loc[:, [group_col]],\n group_col,\n target_col,\n alpha,\n noise_std)\n\n ## will train on x_train\n ## will validate on x_val\n if 'fit' in dir(clf):\n clf.fit(x_train.drop(target_col, axis=1), x_train[target_col])\n preds_val = clf.predict(x_val.drop(target_col, axis=1))\n elif 'train' in dir(clf):\n clf.train(x_train.drop(target_col, axis=1), x_train[target_col])\n preds_val = clf.test(x_val.drop(target_col, axis=1)).argmax(axis=1)\n else:\n raise Exception(\"`clf` must contain either (`fit` and `predict`) or\"\n \" (`train` and `test`) methods\")\n scores_val.append(scorer(x_val[target_col], preds_val))\n del x_val, preds_val, x_train\n return scores_val","def stratified_kfold_cross_validation(X, y, n_splits=5):\r\n indices = [x for x in range(0, len(X))]\r\n labels = []\r\n uniq_feat = []\r\n\r\n for idx,clss in enumerate(y):\r\n\r\n if clss in uniq_feat:\r\n labels[uniq_feat.index(clss)].append(indices[idx])\r\n else:\r\n labels.append([indices[idx]])\r\n uniq_feat.append(clss)\r\n \r\n index = 0\r\n X_test_folds = [[] for _ in range(0, n_splits)]\r\n\r\n for label in labels:\r\n for val in label:\r\n fold_idx = index%n_splits\r\n X_test_folds[fold_idx].append(val)\r\n index += 1\r\n \r\n X_train_folds = [[] for _ in range(0, n_splits)]\r\n\r\n for i in range(0, len(X)):\r\n for j in range(0, n_splits):\r\n if i not in X_test_folds[j]:\r\n X_train_folds[j].append(i)\r\n \r\n return X_train_folds, X_test_folds","def cross_validation(self, x, t, k=5):\n print(\"Cross validation of the Decision Tree Classifier...\")\n bestCriteria = ''\n bestMax_depth= 2\n bestError = float('inf')\n\n N = len(x)\n N_train = math.floor(0.8 * N)\n\n dicCriteria = ['gini', 'entropy']\n min_depth = 2\n max_depth = 40\n\n for crit in dicCriteria:\n for d in range(min_depth, max_depth):\n errors = np.zeros(k)\n\n for j in range(k):\n map_index = list(zip(x, t))\n random.shuffle(map_index)\n random_X, random_t = zip(*map_index)\n\n train_x = random_X[:N_train]\n valid_x = random_X[N_train:]\n train_t = random_t[:N_train]\n valid_t = random_t[N_train:]\n\n self.model = tree.DecisionTreeClassifier(max_depth=d, criterion=crit)\n self.train(train_x, train_t)\n error_valid = np.array([self.error(x_n, t_n)\n for t_n, x_n in zip(valid_t, valid_x)])\n errors[j] = error_valid.mean()\n\n mean_error = np.mean(errors)\n if mean_error < bestError:\n bestError = mean_error\n bestCriteria = crit\n bestMax_depth = d\n print(\"The new best hyper parameters are : \", bestMax_depth, bestCriteria)\n\n print(\"Best hyper parameters are : \", bestMax_depth, bestCriteria)\n print(\"Validation error : \", 100 * bestError, \"%\")\n self.model = tree.DecisionTreeClassifier(max_depth=bestMax_depth, criterion=bestCriteria)\n self.train(x, t)","def crossValidation(training, k, performance):\n\n predictions = []\n accuracy = []\n\n for index in range(1, 6):\n # print index\n temp = list(range(1, 6))\n temp.remove(index)\n # print 'index: ' + str(index) + ', temp: ' + str(temp)\n\n for x in range(len(training.get_group(index))):\n if x % 100 != 0:\n continue\n target = training.get_group(index).values.tolist()[x][-1]\n # if x % 500 == 0:\n # print 'index: ' + str(index) + ', x: ' + str(x)\n neighbors = []\n distances = []\n for validationSet in temp:\n getDistances(training.get_group(validationSet).values.tolist(), training.get_group(index).values.tolist()[x], distances)\n # Sort the distances list by the distance\n distances.sort(key = lambda item: item[1])\n # print distances\n # Select first k closest elements to return as the neighbors\n for x in range(k):\n neighbors.append(distances[x][0])\n\n result=getResponse(neighbors)\n\n # print distances\n # print neighbors\n # print result\n predictions.append(result)\n # print 'result: ' + str(result)\n # print 'target: ' + str(target)\n # print 'result == target: ' + str(result == target)\n if result == target:\n accuracy.append((True, target))\n else:\n accuracy.append((False, target))\n\n count = 0\n for item in accuracy:\n if item[0] == True:\n count += 1\n\n # print 'number of instances: ' + str(len(accuracy)) + ' number correct: ' + str(count)\n\n count = 0\n for item in accuracy:\n if item[0] == True:\n count += 1\n\n # Add the current k-value and its accuracy for this run to dictionary\n performance[k] = count / len(accuracy)\n\n print performance\n return performance","def __cross_validation(self, classifier, X, y, k, stratify=True):\n\t\tif k == X.shape[0]:\t\t# leave-one-out\n\t\t\tkf = model_selection.KFold(n_splits=k)\n\t\telse:\n\t\t\tif stratify:\n\t\t\t\tkf = model_selection.StratifiedKFold(n_splits=k, shuffle=True, random_state=0)\n\t\t\telse:\n\t\t\t\tkf = model_selection.KFold(n_splits=k, shuffle=True, random_state=0)\n\n\t\t# training data and predictions for each fold\n\t\ty_train_list = []\n\t\ty_train_pred_list = []\n\t\ty_train_prob_list = []\n\t\ty_val_list = []\n\t\ty_val_pred_list = []\n\t\ty_val_prob_list = []\n\n\t\tfor train_idx, val_idx in kf.split(X, y):\n\t\t\tX_train, X_val = X.iloc[train_idx], X.iloc[val_idx]\n\t\t\ty_train, y_val = y.iloc[train_idx], y.iloc[val_idx]\n\t\t\ty_train_list.append(y_train)\n\t\t\ty_val_list.append(y_val)\n\n\t\t\t# catch convergence warning\n\t\t\twith warnings.catch_warnings():\n\t\t\t\twarnings.filterwarnings('error', category=exceptions.ConvergenceWarning)\n\t\t\t\ttry:\n\t\t\t\t\tclassifier = classifier.fit(X_train, y_train)\n\t\t\t\texcept exceptions.ConvergenceWarning:\n\t\t\t\t\tModel.counter -= 1\n\t\t\t\t\traise\n\n\t\t\ty_train_pred_list.append(classifier.predict(X_train))\n\t\t\ty_val_pred_list.append(classifier.predict(X_val))\n\t\t\ty_train_prob_list.append(classifier.predict_proba(X_train))\n\t\t\ty_val_prob_list.append(classifier.predict_proba(X_val))\n\n\t\tif k == X.shape[0]:\t\t# leave-one-out\n\t\t\ty_val = np.hstack(y_val_list)\n\t\t\ty_val_pred = np.hstack(y_val_pred_list)\n\t\t\ty_val_prob = np.vstack(y_val_prob_list)\n\n\t\t\treturn ModelMetrics(classifier, y_train_list, y_train_pred_list, y_train_prob_list, 'cv'), \\\n\t\t\t\tModelMetrics(classifier, y_val, y_val_pred, y_val_prob, 'loo')\n\t\telse:\n\t\t\treturn ModelMetrics(classifier, y_train_list, y_train_pred_list, y_train_prob_list, 'cv'), \\\n\t\t\t\tModelMetrics(classifier, y_val_list, y_val_pred_list, y_val_prob_list, 'cv')","def cv(data, folds, model):\n def rmsle(predicted, actual):\n # Root Mean Squared Logarithmic Error\n return mean_squared_error(\n np.log(predicted+1),\n np.log(actual+1)\n ) ** 0.5\n\n errors = []\n print \" Cross Validation in progress...\"\n kf = cross_validation.KFold(n=len(data.index), n_folds=folds)\n for i, (train_index, validation_index) in enumerate(kf):\n print ' F%d.' % i\n train = data.iloc[train_index]\n validation = data.iloc[validation_index]\n\n model.fit(train)\n prediction = model.predict(validation)\n actual = data.iloc[validation_index]['count'].as_matrix()\n error = rmsle(prediction, actual)\n errors.append(error)\n return np.mean(errors)","def cross_validate(self, inss, num_folds, folds_name=None, gen_folds=False):\n kcv = CrossValidation(num_folds, inss, self.train, self.rank_inss)\n\n # loads/generates folds\n if gen_folds:\n kcv.create_folds(group_by=\"session\")\n if folds_name is not None:\n kcv.save_folds(folds_name)\n else:\n kcv.load_folds(folds_name)\n\n # Cross validation\n inss = kcv.run()\n inss.__class__ = CERInstances\n for ins in inss.get_all():\n ins.__class__ = CERInstance\n return inss","def nested_cv(X, y, model, n_splits, n_folds, unique_id):\n \n cv = StratifiedKFold(n_splits=n_splits,\n shuffle=True,\n random_state=42) # Outer CV\n \n i_start = 0\n i_list = []\n results_df = None\n cv_path = unique_id + '_NestedCV.pkl'\n \n if os.path.isfile(cv_path) == True: # If CV is incomplete, resume\n results_df = pd.read_pickle(cv_path)\n i_start = results_df.Outer_fold.max() + 1\n print('Resuming cross-validation from fold ' + str(i_start + 1))\n \n # Generate indices to split data by StratifiedKFold\n # Append indices for each fold to list \n for tr_i, te_i in cv.split(X,y):\n i_list.append([tr_i, te_i])\n \n # For each fold...\n for i in range(i_start, len(i_list)):\n results_list = []\n print('Beginning fold ' + str(i+1) + ' of ' + str(len(i_list)))\n \n # Split data into training and test tests\n X_train = X.loc[X.index.intersection(i_list[i][0])]\n y_train = y.loc[y.index.intersection(i_list[i][0])]\n X_test = X.loc[X.index.intersection(i_list[i][1])]\n y_test = y.loc[y.index.intersection(i_list[i][1])]\n\n start = time.time()\n \n # Fit the HyperoptEstimator to training data (optimise model)\n model.fit(X_train,\n y_train,\n n_folds=n_folds, # Inner stratified k-fold CV\n cv_shuffle=True)\n \n end = time.time()\n duration = end - start\n\n # Use optimised model to predict labels for test data\n y_pred = model.predict(X_test)\n score = f1_score(y_test, y_pred, average='weighted') # Evaluate\n \n # Everything below: formats and/or calculates results for output file\n sorted_labels = np.sort(y_test.unique())\n unweighted_score = f1_score(y_test, y_pred,\n average=None,\n labels=sorted_labels)\n c_matrix = confusion_matrix(y_test, y_pred,\n labels=sorted_labels)\n\n for trial in range(len(model.trials.trials)):\n if model.trials.trials[trial].get('result').get('status') == 'ok':\n trial_loss = model.trials.trials[trial].get('result').get('loss')\n trial_duration = model.trials.trials[trial].get('result').get('duration')\n else:\n trial_loss = np.nan\n trial_duration = np.nan\n \n results_list.append([i,\n score,\n unweighted_score,\n le.inverse_transform(sorted_labels),\n c_matrix,\n duration,\n trial,\n trial_loss,\n trial_duration])\n \n append_df = pd.DataFrame(results_list,\n columns=['Outer_fold',\n 'Outer_score',\n 'Outer_unweighted_scores',\n 'Outer_unweighted_score_labels',\n 'Outer_confusion_matrix',\n 'Outer_training_duration',\n 'Trial',\n 'Trial_loss',\n 'Trial_duration'])\n if i == i_start:\n if results_df is not None:\n final_df = pd.concat([results_df,\n append_df],\n ignore_index=True)\n else:\n final_df = append_df\n final_df.to_pickle(cv_path)\n \n else:\n results_df = pd.read_pickle(cv_path)\n final_df = pd.concat([results_df,\n append_df],\n ignore_index=True)\n final_df.to_pickle(cv_path)","def crossValidationKfold(automodel, \r\n X, y,\r\n params_automl : dict = {},\r\n score_function = accuracy_score,\r\n cv : int = 3,\r\n shuffle: bool = True,\r\n verbose : bool = True,\r\n allmetrics: bool = False):\r\n if(isinstance(X, pd.DataFrame) or isinstance(y, pd.DataFrame)):\r\n X = X.values\r\n y = y.values\r\n skf = StratifiedKFold(n_splits = cv, \r\n shuffle = shuffle, \r\n random_state = 42)\r\n if(allmetrics):\r\n train_scores = {'accuracy' : [], \r\n 'roc_auc': [], \r\n 'f1' : [], \r\n 'recall' : [], \r\n 'precision': []}\r\n test_scores = {'accuracy' : [], \r\n 'roc_auc': [], \r\n 'f1' : [], \r\n 'recall' : [], \r\n 'precision': []}\r\n else:\r\n train_scores = np.empty((cv, ))\r\n test_scores = np.empty((cv, ))\r\n for idx, (idx_tr, idx_ts) in enumerate(skf.split(X, y)):\r\n X_tr, X_ts = X[idx_tr], X[idx_ts]\r\n y_tr, y_ts = y[idx_tr], y[idx_ts] \r\n am = automodel(**params_automl)\r\n am.fit(X_tr, y_tr)\r\n if(not allmetrics):\r\n \r\n train_scores[idx] = score_function(am.predict(X_tr), y_tr)\r\n test_scores[idx] = score_function(am.predict(X_ts), y_ts)\r\n if(verbose):\r\n print('it: {} train score: {:.3f}, val score: {:.3f}'.format(idx, \r\n train_scores[idx],\r\n test_scores[idx]))\r\n else:\r\n train_current = {}\r\n test_current = {}\r\n for name, metric in all_metrics_classifications.items():\r\n train_current[name] = metric(am.predict(X_tr), y_tr)\r\n test_current[name] = metric(am.predict(X_ts), y_ts)\r\n train_scores[name].append(train_current[name])\r\n test_scores[name].append(test_current[name])\r\n \r\n if(verbose):\r\n print('it: {} train scores: {}, val scores: {}'.format(idx, train_current,\r\n test_current))\r\n\r\n if(not allmetrics):\r\n return test_scores.mean(), test_scores.std()\r\n else:\r\n # -- calculate means of all metrics-- #\r\n return dict(map(lambda kv: (kv[0], np.asarray(kv[1]).mean()), test_scores.items()))","def cross_validation_experiment(train_data, train_labels):\n accuracies = []\n for i in range(1, 200):\n avg = cross_validation(train_data, train_labels, i, 10)\n accuracies.append(avg)\n fig = plt.figure()\n dim = np.arange(1,len(accuracies)+1)\n plt.plot(dim,accuracies, label='Accuracy')\n plt.xlabel('k')\n plt.ylabel('accuracy')\n plt.grid()\n plt.legend()\n plt.tight_layout()\n fig.savefig('knn_cross_validation.png')\n best_k = np.argmax(accuracies)+1\n return best_k","def train_kfold(self, blank_model, model_params, dataset, batch_size, drop_last_batch=True):\n kfold = StratifiedKFold(n_splits=self.cv, shuffle=True)\n best_val_loss = 999999\n best_cv = 0\n best_model = None\n for i, (train_idx, test_idx) in enumerate(kfold.split(dataset, dataset.targets)):\n # Initialize model\n #model = copy.deepcopy(blank_model)\n model = blank_model(**model_params).to(model_params['device'])\n print(model.dev)\n #print(model_params['device'])\n print('Training fold %d'%(i), flush=True)\n train_ds = torch.utils.data.Subset(dataset, train_idx)\n test_ds = torch.utils.data.Subset(dataset, test_idx)\n train_loader = torch.utils.data.DataLoader(train_ds, batch_size=batch_size, shuffle=True, drop_last=drop_last_batch, num_workers=self.num_work)\n test_loader = torch.utils.data.DataLoader(test_ds, batch_size=batch_size, shuffle=True, drop_last=drop_last_batch, num_workers=self.num_work)\n # Train model\n epoch_hist = model.train_model(train_loader, test_loader=test_loader, n_epochs=self.n_epochs, learning_rate=self.lr, train_patience=self.train_p, test_patience=self.test_p, save_model=False)\n # Save attributes\n self.cv_res_dict[i]['history'] = epoch_hist\n if 'valid_loss' in epoch_hist.keys():\n self.cv_res_dict[i]['best_valid_loss'] = np.min(epoch_hist['valid_loss'])\n #if self.return_model:\n #self.cv_res_dict[i]['model'] = model\n if best_val_loss > np.min(epoch_hist['valid_loss']):\n best_val_loss = np.min(epoch_hist['valid_loss'])\n best_cv = i\n best_model = model\n # Save if save all\n if self.save_all:\n full_path = self.path_dir+self.model_prefix+'fold_'+str(i)+'.pt'\n print('Saving model at %s'%(full_path), flush=True)\n torch.save(model.state_dict(), full_path)\n\n # delete model from memory ?\n del model\n if model_params['device'] == torch.device('cuda'):\n torch.cuda.empty_cache()\n\n self.best_cv = best_cv\n print('Best Fold: %d'%(self.best_cv), flush=True)\n # Save best model to path\n if self.save_best and not self.save_all:\n path_best = self.path_dir+self.model_prefix+'best_fold.pt'\n print('Saving best model at %s'%(path_best), flush=True)\n torch.save(best_model.state_dict(), path_best)\n elif self.save_best and self.save_all:\n print('Best model already saved for fold %d'%(self.best_cv), flush=True)\n\n return","def __init__(self, splits):\n\t\tself.kfold = KFold(splits)","def main():\n # Read in trainingSet and testSet as a DataFrame\n trainingOriginal = pd.read_csv(\n filepath_or_buffer=\"~/Desktop/KNN Implementation/adult.train.5fold.csv\")\n testOriginal = pd.read_csv(filepath_or_buffer=\"~/Desktop/KNN Implementation/adult.test.csv\")\n\n # Select only the numeric data\n training = pd.DataFrame(trainingOriginal.select_dtypes(['number']))\n training = pd.concat([training.reset_index(drop=True),\n trainingOriginal['earns'].reset_index(drop=True)], axis=1)\n\n # Select only the numeric data\n test = pd.DataFrame(testOriginal.select_dtypes(['number']))\n test = pd.concat([test.reset_index(drop=True),\n testOriginal['earns'].reset_index(drop=True)], axis=1)\n\n # Normalize the columns for training and test\n # print training['age'].min()\n # print training['age'].max()\n # print training.head()\n\n # Run max-min normalization on numerical columns for testing and training data\n for i in range(6):\n training.iloc[:, i] = (training.iloc[:, i]- training.iloc[:, i].min())/(training.iloc[:, i].max() - training.iloc[:, i].min())\n test.iloc[:, i] = (test.iloc[:, i]- test.iloc[:, i].min())/(test.iloc[:, i].max() - test.iloc[:, i].min())\n\n # Convert the 'earns' column to boolean as follows\n training['earns'] = training['earns'] == '>50K'\n test['earns'] = test['earns'] == ' >50K'\n\n # Group the training set by the fold attribute as given by the dataset\n trainingForFinal = training\n training = training.groupby('fold')\n\n # Since we want to consider odd k-values from 1 to 39, construct a list with these values\n kList = []\n for i in range(40):\n if i % 2 == 1:\n kList.append(i)\n\n # Empty dictionary to hold performance of each k-values and its accuracy\n performance = {}\n\n # Compute the performance for each k-value\n for k in kList:\n performance = crossValidation(training, k, performance)\n\n # Sort the performance dictionary by its accuracy (value)\n performance = sorted(performance.items(), key=operator.itemgetter(1), reverse=True)\n\n # Open file to write results\n file = open('grid.results.txt', 'w')\n # Write the results to file\n file.write(\"K | Accuracy\\n\")\n for item in performance:\n if item[0] < 10:\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\n')\n else:\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\n')\n # Close file\n file.close()\n\n # The best K is the one at the top of the list after the sorting\n bestK = performance[0][0]\n\n print 'Running Test Set with K = ' + str(bestK)\n\n applyModel(test,trainingForFinal,bestK)","def cross_validation(self, stock_data):\n\n self.X_train, self.X_test, self.y_train, self.y_test = cross_validation.train_test_split(stock_data['X'], stock_data['Y'], test_size=0.2, train_size=0.8, random_state=3)","def validate_kfold(\n x: ndarray,\n y: ndarray,\n x_sample_dim: int,\n y_sample_dim: int,\n n_splits: int,\n stratify: bool,\n models: List[Model],\n generator: RandomGenerator,\n save_fold_accs: bool,\n) -> List[KFoldResults]:\n # don't work with original arrays which may have sample index in strange location\n length = int(x.shape[x_sample_dim])\n idx = np.arange(0, length, dtype=int)\n # convert to labels if we have a one-hot (will fail for dummy coding)\n # y_split = np.argmax(y, axis=1 - int(np.abs(y_sample_dim))) if y.ndim == 2 else y\n y_split = np.argmax(y, axis=1 - np.abs(y_sample_dim).astype(int)) if y.ndim == 2 else y\n\n # can't trust kfold shuffling in multiprocessing, shuffle ourselves\n generator.shuffle(idx)\n y_split = y_split[idx]\n\n kfolder = StratifiedKFold if stratify else KFold\n kfold = kfolder(n_splits=n_splits, shuffle=False)\n\n results = []\n for model, (train_idx, val_idx) in zip(models, kfold.split(idx, y_split)):\n x_train = array_indexer(x, x_sample_dim, train_idx)\n y_train = array_indexer(y, y_sample_dim, train_idx)\n model.fit(x_train, y_train)\n\n acc = None\n y_pred = None\n if save_fold_accs:\n x_val = array_indexer(x, x_sample_dim, val_idx)\n y_val = array_indexer(y, y_sample_dim, val_idx)\n y_pred = model.predict(x_val)\n acc = 1 - np.mean(get_y_error(y_pred, y_val, y_sample_dim))\n results.append(KFoldResults(model, acc, y_pred, val_idx))\n\n return results","def _do_training_cross_validation(self) -> None:\n\n cfg = self.cfg_\n fit_kwargs = {'classes': list(self.data_.classes)}\n\n # Store all of the samples used during cross-validation\n self.y_training_set_all_ = list(self._generate_samples(self.train_ids_, 'y'))\n\n # Initialize learner objects with the optimal set of parameters\n # learned from the grid search round (one for each\n # sub-experiment of the cross-validation round)\n for learner, learner_name in zip(self.learners_, self.learner_names_):\n self.cv_learners_[learner_name] = \\\n [learner(**self.learner_gs_cv_params_[learner_name])\n for i in range(len(self.data_.training_set))]\n\n # Make a list of empty lists corresponding to each estimator\n # instance for each learner, which will be used to store the\n # performance metrics for each cross-validation\n # leave-one-fold-out sub-experiment\n self.cv_learner_stats_ = [[] for _ in cfg.learners]\n\n # Fit the `SelectPercentile` feature selector (if applicable)\n if cfg.feature_selection_percentile != 1.0:\n loginfo('Removing {0}% of the features during training round...'\n .format(100 - 100*cfg.feature_selection_percentile))\n feature_selector = \\\n (SelectPercentile(chi2,\n percentile=100*cfg.feature_selection_percentile)\n .fit(self._vectorize_and_sparsify_data(self.training_vec_,\n self.train_ids_),\n self.y_training_set_all_))\n\n # For each fold of the training set, train on all of the other\n # folds and evaluate on the one left out fold\n for i, held_out_fold in enumerate(self.data_.training_set):\n\n loginfo('Cross-validation sub-experiment #{0} in progress'\n .format(i + 1))\n\n # Use each training fold (except for the held-out set) to\n # incrementally build up the model\n training_folds = (self.data_.training_set[:i]\n + self.data_.training_set[i + 1:])\n y_train_all = []\n for j, training_fold in enumerate(training_folds):\n\n # Get the training data\n y_train = list(self._generate_samples(training_fold, 'y'))\n y_train_all.extend(y_train)\n X_train = self._vectorize_and_sparsify_data(self.training_vec_,\n training_fold)\n if cfg.feature_selection_percentile != 1.0:\n X_train = feature_selector.transform(X_train)\n\n # Iterate over the learners\n for learner_name in self.learner_names_:\n\n # Partially fit each estimator with the new training\n # data (specifying the `classes` keyword argument if\n # this is the first go-round and it's a learner that\n # requires this to be specified initially)\n (self.cv_learners_[learner_name][i]\n .partial_fit(X_train,\n y_train,\n **fit_kwargs if not j and learner_name\n in self.requires_classes_kwarg_\n else {}))\n\n # Get mean and standard deviation for actual values\n y_train_all = np.array(y_train_all)\n y_train_mean = y_train_all.mean()\n y_train_std = y_train_all.std()\n\n # Get test data\n y_test = list(self._generate_samples(held_out_fold, 'y'))\n X_test = self._vectorize_and_sparsify_data(self.training_vec_,\n held_out_fold)\n if cfg.feature_selection_percentile != 1.0:\n X_test = feature_selector.transform(X_test)\n\n # Make predictions with the modified estimators\n for j, learner_name in enumerate(self.learner_names_):\n\n # Make predictions with the given estimator,rounding the\n # predictions\n y_test_preds = \\\n np.round(self.cv_learners_[learner_name][i].predict(X_test))\n\n # Rescale the predicted values based on the\n # mean/standard deviation of the actual values and\n # fit the predicted values within the original scale\n # (i.e., no predicted values should be outside the range\n # of possible values)\n y_test_preds_dict = \\\n ex.rescale_preds_and_fit_in_scale(y_test_preds,\n self.data_.classes,\n y_train_mean,\n y_train_std)\n\n if cfg.rescale:\n y_test_preds = y_test_preds_dict['rescaled']\n else:\n y_test_preds = y_test_preds_dict['fitted_only']\n\n # Evaluate the predictions and add to list of evaluation\n # reports for each learner\n (self.cv_learner_stats_[j]\n .append(ex.evaluate_predictions_from_learning_round(\n y_test=y_test,\n y_test_preds=y_test_preds,\n classes=self.data_.classes,\n prediction_label=cfg.prediction_label,\n non_nlp_features=cfg.non_nlp_features,\n nlp_features=cfg.nlp_features,\n learner=self.cv_learners_[learner_name][i],\n learner_name=learner_name,\n games=cfg.games,\n test_games=cfg.games,\n _round=i + 1,\n iteration_rounds=self.data_.folds,\n n_train_samples=len(y_train_all),\n n_test_samples=len(held_out_fold),\n rescaled=cfg.rescale,\n transformation_string=self.transformation_string_,\n bin_ranges=cfg.bin_ranges)))","def cv_multiclass_fold(Y,num_fold=10):\n\t\n (K,N) = Y.shape\n indices = dict()\n Nk = dict()\n for k in range(K):\n # select indices belonging to class k\n indices[k] = list((Y[k,:]==1).nonzero()[0])\n rand.shuffle(indices[k])\n Nk[k] = len(indices[k])/num_fold\n\t\n index_list = []\n\n for k in range(K):\n for i in range(num_fold-1):\n # split class-k indices into num_fold random sets\n try:\n index_list[i].extend(indices[k][Nk[k]*i:Nk[k]*(i+1)])\n except IndexError:\n index_list.append([])\n index_list[i].extend(indices[k][Nk[k]*i:Nk[k]*(i+1)])\n try:\n index_list[num_fold-1].extend(indices[k][Nk[k]*(num_fold-1):])\n except IndexError:\n index_list.append([])\n index_list[num_fold-1].extend(indices[k][Nk[k]*(num_fold-1):])\n\n return index_list","def Kfold_LR(X, y, n, rs=None):\n scoring_metrics = ['neg_mean_absolute_error',\n 'neg_mean_squared_error',\n 'neg_root_mean_squared_error',\n 'r2']\n lr = LinearRegression()\n # kf = KFold(n_splits=n, shuffle=True, random_state=rs)\n tss2 = TimeSeriesSplit(n_splits=n)\n result = cross_validate(lr, X, y, cv=tss2, scoring=scoring_metrics,\n return_train_score=True, return_estimator=True)\n return pd.DataFrame(result), result['estimator'][-1]","def makeFolds(data, k):\r\n # randomize columns\r\n order = data.columns.tolist()\r\n random.shuffle(order)\r\n # split into folds (specified by k)\r\n folds = []\r\n fold = 0\r\n dist = len(order) / k\r\n while fold < k:\r\n start = int(round(fold * dist))\r\n end = int(round(start + dist))\r\n folds.append(order[start:end])\r\n fold = fold + 1\r\n return folds","def cross_validation(y, x, k_indices, k, initial_w, model_name, max_iters=0, gamma=0, lambda_=0):\n # get k'th subgroup in test, others in train\n test_idx = k_indices[k]\n idx_tr = np.arange(len(k_indices))\n train_idx = k_indices[idx_tr != k]\n train_idx = train_idx.flatten()\n\n # form data with polynomial degree\n #x_tr = build_poly(x[train_idx], degree)\n #x_te = build_poly(x[test_idx], degree)\n x_tr = x[train_idx]\n x_te = x[test_idx]\n y_tr = y[train_idx]\n y_te = y[test_idx]\n\n # applying the model \n #initial_w = np.zeros(x_tr.shape[1])\n if(model_name == 'least_squares_GD'):\n w_star, mse = least_squares_GD(y_tr, x_tr, initial_w, max_iters, gamma)\n elif(model_name == 'least_squares_SGD'):\n w_star, mse = least_squares_SGD(y_tr, x_tr, initial_w, max_iters, gamma)\n elif(model_name == 'least_squares'):\n w_star, mse = least_squares(y_tr, x_tr)\n elif(model_name == 'ridge_regression'):\n w_star, mse = ridge_regression(y_tr, x_tr, lambda_)\n elif(model_name == 'logistic_regression'):\n w_star, mse = logistic_regression(y_tr, x_tr, initial_w, max_iters, gamma)\n elif(model_name == 'reg_logistic_regression'):\n w_star, mse = reg_logistic_regression(y_tr, x_tr, lambda_, initial_w, max_iters, gamma)\n \n\n # calculate the loss for train and test data\n if(model_name == 'logistic_regression' or model_name == 'reg_logistic_regression'):\n #loss_tr = compute_loss_LG(y_tr, x_tr, w_star)\n y_te_ = (1+y_te)/2\n loss_te = compute_loss_LG(y_te_, x_te, w_star)\n #print(loss_te)\n mod_pred = predict_labels(w_star, x_te, logistic = True)\n #mod_pred = (1+mod_pred)/2\n acc = calculate_accuracy(mod_pred, y_te)\n else:\n #loss_tr = compute_loss_MSE(y_tr, x_tr, w_star)\n loss_te = compute_loss_MSE(y_te, x_te, w_star)\n mod_pred = predict_labels(w_star, x_te)\n acc = calculate_accuracy(mod_pred, y_te)\n\n return acc, loss_te","def cv_5_fold(dataFrame):\n dataframe_collection = {}\n i = 0\n j = 0\n l = 0\n guessed_right = 0\n k = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39]\n\n k_values = []\n # array to store the accuracy evaluation for each number of K\n accuracy_values = {}\n\n myDict = {}\n for j in range(len(k)): # for all values of K neighbour\n\n print(k[j])\n predicted_right = 0\n total_number = 0\n five_accuracies = []\n for i in range(0, 5):\n #aggregating dataframes by fold - e.g. 1 fold becomes test dataframe; 2,3,4,5 folds become one training dataframe\n trainingDataFrame = dataFrame.loc[dataFrame[15] != (i / 4.00)]\n trainingDataFrame = trainingDataFrame.drop([15], axis=1).reset_index(drop=True)\n testDataFrame = dataFrame.loc[dataFrame[15] == (i / 4.00)]\n testDataFrame = testDataFrame.drop([15], axis=1).reset_index(drop=True)\n\n # output is an array of predicted income values for testDataFrame\n output = knn(trainingDataFrame, testDataFrame, k[j])\n\n # for every fold validation loop calculate the accuracy:\n for instance in range(len(testDataFrame)):\n # checking number of right predictions\n if (output[instance] == testDataFrame[14].iloc[instance]):\n predicted_right += 1.00\n total_number += 1.00\n\n # calculate accuracy as percentage of number of prediction divided by total\n accuracy = (predicted_right / total_number) * 100.0\n # add acccuracies for each of the 5 fold tests to an array\n five_accuracies.append(accuracy)\n\n # PROVIDE FINAL EVALUATION FOR K = J, BY FINDING OUT AVERAGE ACCURACY OF THE FIVE FOLD LOOPS:\n evaluation = 0.0\n for accuracy in range(len(five_accuracies)):\n evaluation += five_accuracies[accuracy]\n\n evaluation = evaluation / 5\n\n accuracy_values.update({k[j]: evaluation})\n\n accuracy_values = collections.OrderedDict(sorted(accuracy_values.items()))\n\n # compute which number of neigbors garners greatest accuracy:\n maxAccuracy = 0\n best_neighbour = 0\n # loop through dictionary values:\n for v in accuracy_values.items():\n # if the value is greater than the current maximum, make it the maximum\n if (v[1] > maxAccuracy):\n maxAccuracy = v[1]\n best_neighbour = v[0]\n\n print(\"Max accuracy \", maxAccuracy)\n print(\"Best Neighbor: \", best_neighbour)\n\n # make a text file containing the K-number and associated accuracy:\n str_x = \"k value | accuracy\" + \"\\n\"\n for k, v in accuracy_values.items():\n str_x += str(k) + \" | \" + str(v) + \"\\n\"\n print(str_x)\n\n text_file = open(\"grid.results.txt\", 'w')\n text_file.write(str_x)\n text_file.close()","def get_folds(X, y, k):\n # temporarily change the 1/-1 nature of y to 1/0\n _y = (y + 1) / 2\n # partition the examples into postive and negative sets\n positive_indices = np.where(_y)[0]\n negative_indices = np.where(_y - 1)[0]\n assert len(positive_indices) + len(negative_indices) == len(y)\n\n # shuffle both lists\n np.random.shuffle(positive_indices)\n np.random.shuffle(negative_indices)\n\n # create k buckets of indices of (approximately) equal size\n positive_folds_indices = \\\n np.array(np.array_split(positive_indices, k))\n negative_folds_indices = \\\n np.array(np.array_split(negative_indices, k))\n\n train_X, train_y, test_X, test_y = [], [], [], []\n for i in range(k):\n train_folds = np.concatenate((np.arange(0, i), np.arange(i+1, k)))\n pos_train_indices = np.concatenate(positive_folds_indices[train_folds])\n neg_train_indices = np.concatenate(negative_folds_indices[train_folds])\n pos_test_indices = positive_folds_indices[i]\n neg_test_indices = negative_folds_indices[i]\n\n train_X.append(\n np.concatenate((X[pos_train_indices], X[neg_train_indices]))\n )\n train_y.append(\n np.concatenate((y[pos_train_indices], y[neg_train_indices]))\n )\n test_X.append(\n np.concatenate((X[pos_test_indices], X[neg_test_indices]))\n )\n test_y.append(\n np.concatenate((y[pos_test_indices], y[neg_test_indices]))\n )\n\n return zip(train_X, train_y, test_X, test_y)","def split_label_for_crossValidation(labels, k_fold = 3):\n\ttest_labels = []\n\ttest_num = len(labels) / k_fold\n\n\tfor i in range(test_num):\n\t\ttest_labels.append(labels.pop(random.randint(0,len(labels) - 1)))\n\n\tvalid_labels = labels\n\n\treturn (test_labels, valid_labels)","def cross_validate(self, X, y):\n roc_ap = []\n kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=0)\n for train_ix, test_ix in kfold.split(X, y):\n train_X, test_X = X.iloc[train_ix, :], X.iloc[test_ix, :]\n train_y, test_y = y[train_ix], y[test_ix]\n self.train(train_X, train_y)\n roc_ap.append(self.test(test_X, test_y))\n return roc_ap","def __init__(self, splits):\n\t\tself.kfold = StratifiedKFold(splits)","def cross_validate(self, curr_dataset, num_folds, max_depth, min_samples_per_node,\n is_stratified=True, print_tree=False, seed=None, print_samples=False,\n use_stop_conditions=False, max_p_value_chi_sq=0.1):\n classifications = [0] * curr_dataset.num_samples\n num_correct_classifications = 0\n num_correct_classifications_wo_unkown = 0\n total_cost = 0.0\n total_cost_wo_unkown = 0.0\n classified_with_unkown_value_array = [False] * curr_dataset.num_samples\n num_unkown = 0\n unkown_value_attrib_index_array = [0] * curr_dataset.num_samples\n max_depth_per_fold = []\n num_nodes_per_fold = []\n num_valid_nominal_attributes_in_root_per_fold = []\n num_values_root_attribute_list = []\n num_trivial_splits = 0\n time_taken_pruning_per_fold = []\n num_nodes_pruned_per_fold = []\n num_correct_trivial_classifications = 0\n\n fold_count = 0\n\n sample_indices_and_classes = list(enumerate(curr_dataset.sample_class))\n if seed is not None:\n random.seed(seed)\n np.random.seed(seed)\n random.shuffle(sample_indices_and_classes)\n shuffled_sample_indices, shuffled_sample_classes = zip(*sample_indices_and_classes)\n\n if is_stratified:\n for (training_randomized_indices,\n validation_randomized_indices) in StratifiedKFold(n_splits=num_folds).split(\n shuffled_sample_indices,\n shuffled_sample_classes):\n\n training_samples_indices = [shuffled_sample_indices[index]\n for index in training_randomized_indices]\n validation_sample_indices = [shuffled_sample_indices[index]\n for index in validation_randomized_indices]\n\n if print_samples:\n print('Samples used for validation in this fold:')\n print(validation_sample_indices)\n print()\n\n ((curr_classifications,\n curr_num_correct_classifications,\n curr_num_correct_classifications_wo_unkown,\n curr_total_cost,\n curr_total_cost_wo_unkown,\n curr_classified_with_unkown_value_array,\n curr_num_unkown,\n curr_unkown_value_attrib_index_array),\n curr_max_depth,\n curr_time_taken_pruning,\n curr_num_nodes_pruned) = self.train_and_test(curr_dataset,\n training_samples_indices,\n validation_sample_indices,\n max_depth,\n min_samples_per_node,\n use_stop_conditions,\n max_p_value_chi_sq)\n max_depth_per_fold.append(curr_max_depth)\n num_nodes_per_fold.append(self.get_root_node().get_num_nodes())\n num_valid_nominal_attributes_in_root_per_fold.append(\n sum(self._root_node.valid_nominal_attribute))\n try:\n root_node_split_attrib = self.get_root_node().node_split.separation_attrib_index\n if curr_dataset.valid_nominal_attribute[root_node_split_attrib]:\n num_values_root_attribute_list.append(sum(\n num_samples > 0\n for num_samples in self.get_root_node().contingency_tables[\n root_node_split_attrib].values_num_samples))\n except AttributeError:\n num_trivial_splits += 1\n for curr_index, validation_sample_index in enumerate(validation_sample_indices):\n classifications[validation_sample_index] = curr_classifications[curr_index]\n classified_with_unkown_value_array[validation_sample_index] = (\n curr_classified_with_unkown_value_array[curr_index])\n unkown_value_attrib_index_array[validation_sample_index] = (\n curr_unkown_value_attrib_index_array[curr_index])\n num_correct_classifications += curr_num_correct_classifications\n num_correct_classifications_wo_unkown += curr_num_correct_classifications_wo_unkown\n total_cost += curr_total_cost\n total_cost_wo_unkown += curr_total_cost_wo_unkown\n num_unkown += curr_num_unkown\n num_correct_trivial_classifications += round(\n len(validation_sample_indices) *\n (self.get_trivial_accuracy(validation_sample_indices) / 100.0))\n\n fold_count += 1\n time_taken_pruning_per_fold.append(curr_time_taken_pruning)\n num_nodes_pruned_per_fold.append(curr_num_nodes_pruned)\n\n if print_tree:\n print()\n print('-' * 50)\n print('Fold:', fold_count)\n self.save_tree()\n else:\n for (training_samples_indices,\n validation_sample_indices) in KFold(n_splits=num_folds).split(\n shuffled_sample_indices):\n\n ((curr_classifications,\n curr_num_correct_classifications,\n curr_num_correct_classifications_wo_unkown,\n curr_total_cost,\n curr_total_cost_wo_unkown,\n curr_classified_with_unkown_value_array,\n curr_num_unkown,\n curr_unkown_value_attrib_index_array),\n curr_max_depth,\n curr_time_taken_pruning,\n curr_num_nodes_pruned) = self.train_and_test(curr_dataset,\n training_samples_indices,\n validation_sample_indices,\n max_depth,\n min_samples_per_node,\n use_stop_conditions,\n max_p_value_chi_sq)\n max_depth_per_fold.append(curr_max_depth)\n num_nodes_per_fold.append(self.get_root_node().get_num_nodes())\n num_valid_nominal_attributes_in_root_per_fold.append(\n sum(self._root_node.valid_nominal_attribute))\n try:\n root_node_split_attrib = self.get_root_node().node_split.separation_attrib_index\n if curr_dataset.valid_nominal_attribute[root_node_split_attrib]:\n num_values_root_attribute_list.append(sum(\n num_samples > 0\n for num_samples in self.get_root_node().contingency_tables[\n root_node_split_attrib].values_num_samples))\n except AttributeError:\n num_trivial_splits += 1\n for curr_index, validation_sample_index in enumerate(validation_sample_indices):\n classifications[validation_sample_index] = curr_classifications[curr_index]\n classified_with_unkown_value_array[validation_sample_index] = (\n curr_classified_with_unkown_value_array[curr_index])\n unkown_value_attrib_index_array[validation_sample_index] = (\n curr_unkown_value_attrib_index_array[curr_index])\n num_correct_classifications += curr_num_correct_classifications\n num_correct_classifications_wo_unkown += curr_num_correct_classifications_wo_unkown\n total_cost += curr_total_cost\n total_cost_wo_unkown += curr_total_cost_wo_unkown\n num_unkown += curr_num_unkown\n num_correct_trivial_classifications += round(\n len(validation_sample_indices) *\n (self.get_trivial_accuracy(validation_sample_indices) / 100.0))\n\n fold_count += 1\n time_taken_pruning_per_fold.append(curr_time_taken_pruning)\n num_nodes_pruned_per_fold.append(curr_num_nodes_pruned)\n\n if print_tree:\n print()\n print('-' * 50)\n print('Fold:', fold_count)\n self.save_tree()\n\n return (classifications,\n num_correct_classifications,\n num_correct_classifications_wo_unkown,\n total_cost,\n total_cost_wo_unkown,\n classified_with_unkown_value_array,\n num_unkown,\n unkown_value_attrib_index_array,\n time_taken_pruning_per_fold,\n num_nodes_pruned_per_fold,\n max_depth_per_fold,\n num_nodes_per_fold,\n num_valid_nominal_attributes_in_root_per_fold,\n num_values_root_attribute_list,\n num_trivial_splits,\n 100.0 * num_correct_trivial_classifications / curr_dataset.num_samples)","def kfold_scoring(self, data_frame, target, pipeline):\n\n fold_score = []\n macro = ['recall', 'f1', 'precision']\n number_of_folds = -1\n Folds = {}\n\n kf = KFold(n_splits=10, random_state=None, shuffle=True)\n\n for train_index, test_index in kf.split(data_frame):\n X_train = data_frame[train_index]\n X_test = data_frame[test_index]\n y_train = target[train_index]\n y_test = target[test_index]\n number_of_folds = number_of_folds + 1\n # Append the predicted labels.\n y_predict = self.fit_predict_model(X_train, y_train, X_test, pipeline)\n\n Folds[str(number_of_folds)] = {\n \"predicted\": y_predict,\n \"Actual\": y_test\n }\n\n if self.problem_type == 'regression':\n if self.scoring is not None:\n result = self.regression_scoring_function[self.scoring](y_predict, y_test)\n else:\n result = self.regression_scoring_function['r2_score'](y_predict, y_test)\n else:\n if self.scoring is not None:\n if self.scoring not in macro:\n result = self.classification_scoring_function[self.scoring](\n y_predict, y_test)\n else:\n result = self.classification_scoring_function[self.scoring](\n y_predict, y_test, average='macro')\n else:\n result = self.classification_scoring_function['f1'](\n y_predict, y_test, average='macro')\n\n fold_score.append(result)\n self.pipeline_dict['folds'] = Folds\n return np.mean(fold_score)","def cross_validation(self, x, t):\n # Initialize accuracy / hyperparameters\n best_accuracy = 0.0\n best_reg = 0.0\n\n # Cross-validation 80-20\n N = x.shape[0]\n N_train = int(math.floor(0.8 * N))\n\n # Initialize the grid search hyperparameters\n min_reg = 0.001\n max_reg = 1000\n log_min_reg = np.log(min_reg)\n log_max_reg = np.log(max_reg)\n reg_list = np.logspace(log_min_reg, log_max_reg, num=7, base=math.e)\n\n for reg in reg_list:\n accuracy = np.zeros((self.k_fold))\n for i in range(self.k_fold):\n map_index = list(zip(x, t))\n random.shuffle(map_index)\n random_x, random_t = zip(*map_index)\n\n train_x = random_x[:N_train]\n valid_x = random_x[N_train:]\n train_t = random_t[:N_train]\n valid_t = random_t[N_train:]\n\n self.model = sklearn.neural_network.MLPClassifier(self.hidden_layer_sizes,\n activation=self.activation,\n alpha=reg, max_iter=1000, \n random_state=self.random_state)\n self.train(train_x, train_t)\n accuracy[i] = self.model.score(valid_x, valid_t)\n\n mean_accuracy = np.mean(accuracy)\n # print(mean_accuracy)\n if mean_accuracy > best_accuracy:\n best_accuracy = mean_accuracy\n best_reg = reg\n print(\"The new best hyperparameters are : \", best_reg)\n\n print(\"Best hyperparameters are : \", best_reg)\n print(\"Valid Accuracy :\", best_accuracy)\n self.reg = best_reg\n self.model = sklearn.neural_network.MLPClassifier(self.hidden_layer_sizes,\n activation=self.activation,\n alpha=best_reg, max_iter=1000, \n random_state=self.random_state)\n self.train(x, t)","def cross_validation(y, x, k_indices, k, lambda_, degree):\n # ***************************************************\n # INSERT YOUR CODE HERE\n # get k'th subgroup in test, others in train: TODO\n # ***************************************************\n all_indices = np.arange(y.shape[0])\n excepted = np.setdiff1d(all_indices,k_indices[k])\n x_test = x[k_indices[k]]\n y_test = y[k_indices[k]]\n x_train = x[excepted]\n y_train = y[excepted]\n # ***************************************************\n # INSERT YOUR CODE HERE\n # form data with polynomial degree: TODO\n # ***************************************************\n x_train_extended = build_poly(x_train, degree)\n #print(x_train_extended.shape)\n x_test_extended = build_poly(x_test, degree)\n #print(x_test_extended.shape)\n # ***************************************************\n # INSERT YOUR CODE HERE\n # ridge regression: TODO\n # ***************************************************\n loss_tr,w_tr = ridge_regression(y_train,x_train_extended,lambda_)\n #print(\"One new regression\")\n #print(w_tr)\n loss_te = compute_loss(y_test,x_test_extended,w_tr)\n # ***************************************************\n # INSERT YOUR CODE HERE\n # calculate the loss for train and test data: TODO\n # ***************************************************\n return loss_tr, loss_te","def cross_validate_model(self, X_train, y_train):\n\n\t\t# Build a stratified k-fold cross-validator object\n\t\tskf = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)\n\n\t\t'''\n\t\tEvaluate the score by cross-validation\n\t\tThis fits the classification model on the training data, according to the cross-validator\n\t\tand reports the scores.\n\t\tAlternative: sklearn.model_selection.cross_validate\n\t\t'''\n\t\tscores = cross_val_score(self.classifier, X_train, y_train, scoring='accuracy', cv=skf)\n\n\t\tprint(\"%.2f seconds: Cross-validation finished\" % time.process_time())\n\n\t\t# Log the cross-validation scores, the mean score and the 95% confidence interval, according to:\n\t\t# http://scikit-learn.org/stable/modules/cross_validation.html#computing-cross-validated-metrics\n\t\t# https://en.wikipedia.org/wiki/Standard_error#Assumptions_and_usage\n\t\t# print(\"Scores = %s\" % scores)\n\t\t# print(\"Accuracy: %0.2f (±%0.2f)\" % (scores.mean()*100, scores.std()*2*100))\n\t\t# ↳ https://docs.scipy.org/doc/numpy/reference/generated/numpy.std.html","def cross_validation_step_sgd(ratings, k_fold=4, gamma=0.01, num_features=25,\n lambda_user=0.1, lambda_item=0.7, num_epochs=20, verbose=False):\n tr_errors = []\n te_errors = []\n folds = k_fold_split(ratings, k=k_fold)\n for fold in range(k_fold):\n print('Fold {}/{}'.format(fold+1, k_fold))\n train, test = split_matrix(ratings, folds[fold])\n train_rmse, test_rmse, _, _ = matrix_factorization_sgd(train, test, gamma=gamma, num_features=num_features,\n lambda_user=lambda_user, lambda_item=lambda_item,\n num_epochs=num_epochs, verbose=verbose)\n tr_errors.append(train_rmse)\n te_errors.append(test_rmse)\n return np.mean(tr_errors), np.mean(te_errors)","def cross_validation(y, x, k_indices, k, lambda_):\n\n # get k'th subgroup in test, others in train\n te_indice = k_indices[k]\n x_te = x[te_indice]\n y_te = y[te_indice]\n\n tr_indice = k_indices[~(np.arange(k_indices.shape[0]) == k)]\n tr_indice = tr_indice.reshape(-1)\n x_tr = x[tr_indice]\n y_tr = y[tr_indice]\n\n score_table = []\n\n # ridge regression\n #print('Ridge inside cross val started')\n weights, loss = ridge_regression(y_tr, x_tr, lambda_)\n\n y_te_predict = predict_labels(weights, x_te)\n score = (y_te_predict == y_te).mean()\n score_table.append(score)\n\n # calculate the loss for train and test data\n e_tr = y_tr - x_tr.dot(weights)\n loss_tr = np.sqrt(2 * compute_mse(e_tr))\n\n e_te = y_te - x_te.dot(weights)\n loss_te = np.sqrt(2 * compute_mse(e_te))\n\n return loss_tr, loss_te, np.array(score_table)","def k_fold_linear(data: pd.DataFrame, algorithm, folds: int = 5) -> (float, float):\n d = data.sample(frac=1)\n segments = np.array_split(d, folds)\n acc_test = []\n\n acc_train = []\n for i in range(folds):\n temp = segments.copy()\n\n test = temp.pop(i)\n train = pd.concat(temp)\n test_labels = list(test['Labels'])\n train_labels = list(train['Labels'])\n\n model = algorithm(train)\n test_predictions = [round(x, 1) for x in predict_linear_regression(test.drop(['Labels'], axis=1), model)]\n train_predictions = [round(x, 1) for x in predict_linear_regression(train.drop(['Labels'], axis=1), model)]\n\n Confusion_Matrix(test_predictions, test_labels)\n\n acc_test.append(accuracy(test_predictions, test_labels))\n acc_train.append(accuracy(train_predictions, train_labels))\n\n return avg(acc_train), avg(acc_test)","def n_fold_cross_validation(examples, num_folds=5):\n random.shuffle(examples, random.seed(12345))\n batches = [examples[i::num_folds] for i in range(num_folds)]\n n_fold_sets = [\n (\n [example for flat in (batches[:i] + batches[i + 1 :]) for example in flat],\n batch,\n )\n for i, batch in enumerate(batches)\n ]\n\n return np.array(n_fold_sets)","def k_fold_selection(self,training_dataframe, selected_column, ignored_columns):\n \n # getting all the outcomes (i.e. from the selected column)\n outcomes = training_dataframe[selected_column].factorize()[0]\n # remove selected column from dataframe\n training_dataframe.drop(selected_column, axis=1, inplace=True)\n \n # remove all 'ignored columns' from dataframe\n ignored_columns = ast.literal_eval(ignored_columns)\n for column in ignored_columns:\n training_dataframe.drop(column, axis=1, inplace=True)\n \n column_states = {}\n # factorize the columns and store the state names of each feature as a dict\n for column in training_dataframe.columns:\n factorized_column = training_dataframe[column].factorize()\n training_dataframe[column] = factorized_column[0]\n column_states[column] = factorized_column[1].tolist()\n \n # intialize the k-fold cross validation object\n kf = KFold(len(outcomes), n_folds=10, shuffle=True, random_state=14)\n \n for iter_id, item in enumerate(kf):\n # for the first iteration, the classification model needs to be initialized at the end\n if iter_id == 0:\n # training segment\n features_train = np.array([list(training_dataframe.ix[i]) for i in item[0]])\n outcomes_train = np.array([outcomes[i] for i in item[0]])\n \n # evaluation segment\n features_test = np.array([list(training_dataframe.ix[i]) for i in item[1]])\n outcomes_test = np.array([outcomes[i] for i in item[1]])\n \n # create the classifier\n best_clf = BernoulliNB()\n best_clf.fit(features_train, outcomes_train)\n best_accuracy = math.ceil((best_clf.score(features_test,outcomes_test, sample_weight=None)*100)*100)/100\n continue\n \n # training segment\n features_train = np.array([list(training_dataframe.ix[i]) for i in item[0]])\n outcomes_train = np.array([outcomes[i] for i in item[0]])\n \n # evaluation segment\n features_test = np.array([list(training_dataframe.ix[i]) for i in item[1]])\n outcomes_test = np.array([outcomes[i] for i in item[1]])\n \n # create the classifier\n clf = BernoulliNB()\n clf.fit(features_train, outcomes_train)\n accuracy = math.ceil((clf.score(features_test,outcomes_test,sample_weight=None)*100)*100)/100\n \n # hold the best model in best_clf\n if accuracy > best_accuracy:\n accuracy = best_accuracy\n best_clf = clf\n \n return best_accuracy, best_clf, column_states, training_dataframe.columns.tolist()","def cross_valid_key(model,x,key,preds,target,metric,verbose=True): \r\n\r\n score=[]\r\n \r\n keys = x[key].unique().tolist()\r\n \r\n\r\n\r\n for idx, item in enumerate([1,2,3,4,5]):\r\n\r\n xtrain,xtest = split_camp(x,keys,0.2)\r\n \r\n model.fit(xtrain[feat],xtrain[target])\r\n\r\n ypred = model.predict(xtest[feat])\r\n \r\n ytrue= xtest[target].values \r\n \r\n if metric == 'mae':\r\n score.append(mae(ytrue,ypred))\r\n elif metric == 'mse':\r\n score.append(mse(ytrue,ypred))\r\n elif metric == 'rrmse':\r\n score.append(rrmse(ytrue,ypred))\r\n\r\n else:\r\n score.append(rmse(xtest[target].tolist(),ypred))\r\n\r\n if verbose:\r\n print('-'*30)\r\n print(f'\\nFold {idx} out of 5')\r\n print(f'Key {item}')\r\n print(f'{metric}: {score[idx]}')\r\n\r\n \r\n\r\n if verbose:\r\n print(f'\\n Overall Score:')\r\n print(f'{metric}: Mean: {np.mean(score)} Std: {np.std(score)}')\r\n\r\n\r\n return score","def cross_validate(data, k, distance_metric):\n fraction_correct = 0.00\n correctly_classified = 0\n for i, test_data in enumerate(data):\n training_data = []\n for j in range(len(data)):\n if j!=i:\n training_data.append(data[j])\n observed_classification = knn_classify_point(test_data, training_data, k, distance_metric)\n actual_classification = test_data.classification\n if observed_classification == actual_classification:\n correctly_classified += 1\n fraction_correct = float(correctly_classified/len(data))\n return fraction_correct","def crossValidation(data, output_variable_name):\r\n X, xt, y, yt = train_test_split(\r\n data.drop(output_variable_name, axis=1), data[output_variable_name], test_size=0.01, random_state=SEED)\r\n\r\n model = pickle.load(open(\"models/lasso.sav\", 'rb'))\r\n lassoCV = -mean(cross_val_score(model, X, y, cv=5, scoring='neg_root_mean_squared_error'))\r\n\r\n model = pickle.load(open(\"models/ridge.sav\", 'rb'))\r\n ridgeCV = -mean(cross_val_score(model, X, y, cv=5, scoring='neg_root_mean_squared_error'))\r\n\r\n model = pickle.load(open(\"models/decisionTree.sav\", 'rb'))\r\n decTreeCV = -mean(cross_val_score(model, X, y, cv=5, scoring='neg_root_mean_squared_error'))\r\n\r\n param = {\r\n 'max_depth': 15,\r\n 'eta': 0.1,\r\n 'objective': 'reg:squarederror',\r\n 'nthread': 16,\r\n \"subsample\": 0.5,\r\n \"colsample_bytree\": 0.5,\r\n 'eval_metric': 'rmse'\r\n }\r\n num_round = XGB_EPOCH_NR\r\n\r\n dtrain = xgb.DMatrix(X, label=y)\r\n xgbCV = xgb.cv(\r\n param,\r\n dtrain,\r\n num_boost_round=num_round,\r\n seed=SEED,\r\n nfold=5,\r\n metrics={'rmse'}\r\n )[\"test-rmse-mean\"][-1:]\r\n\r\n param = {\r\n \"iterations\": 400,\r\n \"learning_rate\": 0.02,\r\n \"depth\": 12,\r\n \"eval_metric\": 'RMSE',\r\n \"random_seed\": 23,\r\n \"bagging_temperature\": 0.2,\r\n \"od_type\": 'Iter',\r\n \"metric_period\": 75,\r\n \"od_wait\": 100\r\n }\r\n\r\n catBoostCV = cv(data, param, fold_count=5, plot=True)\r\n\r\n return lassoCV, ridgeCV, decTreeCV, xgbCV, catBoostCV","def get_k_fold(examples, labels, k=10):\n example_fold = []\n label_fold = []\n interval = int(len(examples)/k)\n for i in range(k):\n \t#f_examples = [examples[j] for j in range(len(examples)) if j%k == i]\n #f_labels = [labels[j] for j in range(len(labels)) if j%k == i]\n f_examples = [examples[j] for j in range(interval*i,interval*(i+1))]\n f_labels = [labels[j] for j in range(interval*i,interval*(i+1))]\n example_fold.append(f_examples)\n label_fold.append(f_labels)\n return example_fold, label_fold","def stratify_folds(labels, k):\n\n if k < 1:\n raise ValueError('Number of folds, k, must be positive: {}'.format(k))\n\n # Split indices into k folds\n skf_test_model = StratifiedKFold(shuffle=True, n_splits=k)\n\n skf_test = skf_test_model.split(np.zeros(len(labels)), labels)\n skf_test = [skf_set[1] for skf_set in skf_test]\n\n for cv_set in range(k):\n skf_test[cv_set] = np.expand_dims(skf_test[cv_set], axis=1)\n skf_test[cv_set] = np.append(skf_test[cv_set], np.repeat(cv_set, skf_test[cv_set].shape[0]).T[:, np.newaxis],\n axis=1)\n\n # Create one n x 2 array\n # * where n is the number of samples\n # * column 1 is the variant index\n # * column 2 is the set the variant belongs to\n\n fold_array = np.concatenate(skf_test, axis=0)\n\n # Replace indices with label indices\n fold_array[:, 0] = labels.index[fold_array[:, 0]]\n\n # Sort by variant index\n fold_array = fold_array[fold_array[:, 0].argsort(), :]\n\n # Return array\n return fold_array","def cross_validate(self, train_size):\n train, val, test_x, test_y = [], [], [], []\n for country in self.countries:\n tr, v, te_x, te_y = country.split_k_fold(train_size, self.horizon)\n train.append(tr), val.append(v), test_x.append(te_x), test_y.append(te_y)\n return np.stack(train), np.stack(val), np.stack(test_x), np.stack(test_y)","def run_cross_validation_create_models(nfolds=10):\n print(\"nfold value=\",nfolds)\n x_train, y_train, x_train_id = load_images_train()\n print(len(x_train))\n\n # input image dimensions\n batch_size = 16\n nb_epoch = 32\n random_state = 159\n\n seed = 7\n np.random.seed(seed)\n kfold = StratifiedKFold(n_splits=nfolds, shuffle=True, random_state=random_state)\n #kfold = StratifiedShuffleSplit(n_splits=nfolds,test_size=0.1,train_size=0.7,random_state=random_state)\n cvscores = []\n models = []\n\n image_array = np.asarray(x_train, dtype=np.float32)\n # print(image_array.shape)\n\n datagen_test = ImageDataGenerator(\n featurewise_center=True,\n featurewise_std_normalization=True,\n preprocessing_function=pre_processing_image\n )\n\n datagen = ImageDataGenerator(\n rotation_range=20,\n width_shift_range=0.2,\n height_shift_range=0.2,\n shear_range=0.2,\n zoom_range=0.2,\n preprocessing_function=pre_processing_image,\n vertical_flip=True,\n horizontal_flip=True,\n fill_mode='nearest'\n )\n\n start_time = time.time()\n print(\"Datagen.fit started\")\n datagen.fit(image_array, augment=True, rounds=3)\n print('Fit Completed: {} seconds'.format(round(time.time() - start_time, 2)))\n\n img_label = np_utils.to_categorical(y_train, 8)\n\n yfull_train = dict()\n num_fold = 0\n sum_score = 0\n\n for train_index, test_index in kfold.split(x_train, y_train):\n # create model\n model = create_model()\n train_x = image_array[train_index]\n train_y = img_label[train_index]\n validate_x = image_array[test_index]\n validate_y = img_label[test_index]\n\n num_fold += 1\n print('Start KFold number {} from {}'.format(num_fold, nfolds))\n print('Split train: ', len(train_x), len(train_y))\n print('Split valid: ', len(validate_x), len(validate_y))\n\n callbacks = [EarlyStopping(monitor='val_loss', min_delta=0, patience=4, verbose=1, mode='auto')]\n\n model.fit_generator(generator=datagen.flow(train_x, train_y, batch_size=batch_size, shuffle=True),\n steps_per_epoch=len(image_array)/32, epochs=nb_epoch, verbose=1,\n callbacks=callbacks,validation_data=(validate_x,validate_y),\n validation_steps=len(image_array)/32)\n\n predictions_valid = model.predict(validate_x.astype('float32'), batch_size=batch_size, verbose=1)\n\n\n score = log_loss(validate_y, predictions_valid)\n print('Score log_loss: ', score)\n\n\n sum_score += score * len(test_index)\n\n # Store valid predictions\n for i in range(len(test_index)):\n yfull_train[test_index[i]] = predictions_valid[i]\n\n models.append(model)\n\n score = sum_score / len(x_train)\n print(\"Log_loss train independent avg: \", score)\n\n info_string = 'loss_' + str(score) + '_folds_' + str(10) + '_ep_' + str(28)\n return info_string,models","def cross_validation_datasets(self, fold):\n if fold > len(self): fold = len(self) / 2\n stratified = self.stratified_bunches(fold)\n datasets = []\n for index in range(len(stratified)):\n gold = GoldInstances(training_as_gold(stratified[index]))\n rest = flatten(stratified[:index]) + flatten(stratified[index + 1:])\n training = TrainingInstances(rest)\n datasets.append((training, gold))\n return datasets","def nestedValidation(X, y, kernel):\n\n # list of slack variable values to test the SVM with\n C_list = [0.001, 0.01, 0.1, 1.0, 10.0, 100.0, 1000.0]\n # number of iterations to run the bootstraping\n B = 30\n\n # split positive and negative valued samples\n positive_samples = list(np.where(y==1)[0])\n negative_samples = list(np.where(y==-1)[0])\n\n # randomize data for testing\n np.random.shuffle(positive_samples)\n np.random.shuffle(negative_samples)\n\n # split samples into two folds with similar proportion of positive:negative\n samples_in_fold1 = positive_samples[:106] + negative_samples[:178]\n samples_in_fold2 = positive_samples[106:] + negative_samples[178:]\n\n y_pred = np.zeros(len(X), int)\n\n # finding the best slack value and its corresponding error\n best_err = 1.0\n best_C = 0.0\n\n print(\"testing with first fold\")\n for C in C_list:\n err = bootstrapping(B, X[samples_in_fold1], y[samples_in_fold1], C, kernel)\n print(\"C=\", C, \"err=\", err)\n if (err <= best_err):\n best_err = err\n best_C = C\n\n print(\"Best C=\", best_C)\n\n alg = SVC(C=best_C, kernel=kernel)\n alg.fit(X[samples_in_fold1], y[samples_in_fold1])\n y_pred[samples_in_fold2] = alg.predict(X[samples_in_fold2])\n\n best_err = 1.1 # any value greater than 1.0\n best_C = 0.0\n\n print(\"testing with second fold\")\n for C in C_list:\n err = bootstrapping(B, X[samples_in_fold2], y[samples_in_fold2], C, kernel)\n print(\"C=\", C, \"err=\", err)\n if (err <= best_err):\n best_err = err\n best_C = C\n\n print(\"Best C=\", best_C)\n\n alg = SVC(C=best_C, kernel=kernel)\n alg.fit(X[samples_in_fold2], y[samples_in_fold2])\n y_pred[samples_in_fold1] = alg.predict(X[samples_in_fold1])\n\n err = np.mean(y != y_pred)\n\n print(\"Nested Validation Error=\", err)\n return err","def cross_validate(X, Y, folds=5):\n\n log = LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n intercept_scaling=1, max_iter=200, multi_class='ovr', n_jobs=3,\n penalty='l2', random_state=None, solver='liblinear', tol=0.0001,\n verbose=0, warm_start=False)\n \n\n \n\n\n scores_log = [] \n scores_forest = []\n index = np.arange(X.shape[0])\n score_log = 0\n score_forest = 0\n \n for i in range(folds):\n score_log = 0\n score_forest = 0\n \n test_index = np.random.choice(index, int(X.shape[0]*1/folds),replace=False)\n index = np.setdiff1d(np.arange(X.shape[0]),test_index)\n \n test_x = X[test_index]\n test_y = Y[test_index]\n\n log.fit(X[index],Y[index])\n pred_log = log.predict(test_x)\n \n ran.fit(X[index],Y[index])\n pred_ran = ran.predict(test_x)\n \n for i in range(len(test_y)):\n if(pred_log[i] == test_y[i]):\n score_log += 1\n if(pred_ran[i] == test_y[i]):\n score_forest += 1\n scores_log.append(score_log/len(test_y))\n scores_forest.append(score_forest/len(test_y))\n \n\n return (np.mean(scores_log),np.mean(scores_forest))","def kfold_run(self, estimators):\n model = self.model_build(estimators)\n super().kfold_run(model)","def cross_validation(feature_train, help_rank_train, model_name):\n clf = svm.SVC(kernel='linear', C=1).fit(feature_train, help_rank_train)\n clf_model = open(model_name,'wb')\n dump(clf, clf_model, -1)\n return","def cross_validation_accuracy(clf, X, labels, k):\n ###TODO\n\n cv = KFold(n=len(labels),n_folds=k)\n accuracies = []\n\n \n for train_indices, test_indices in cv:\n \n clf.fit(X[train_indices], labels[train_indices])\n predicted = clf.predict(X[test_indices])\n acc = accuracy_score(labels[test_indices], predicted)\n accuracies.append(acc)\n \n #print('accuracies = ',accuracies) \n #avg = np.mean(accuracies,dtype=np.float64)\n return(np.mean(accuracies,dtype=np.float64))","def cross_validate(pipeline, data, cv=4):\n print \"Running cross validation...\"\n (Xcv, ycv) = data\n kfold = KFold(n_splits=cv, shuffle=True, random_state=42)\n results = []\n for train_idx, val_idx in kfold.split(Xtrain):\n pipeline.fit(Xcv[train_idx], ycv[train_idx])\n results.append(accuracy_score(\n ycv[val_idx], pipeline.predict(Xcv[val_idx])\n ))\n print \"{} +/- {}\".format(np.mean(results), np.std(results))","def cross_validation(feature_matrix, labels, k, flag = 0, T = 100):\n (nsamples, nfeatures) = feature_matrix.shape\n nlabels = len(labels)\n subset_size = nsamples / k\n percentages = []\n\n for i in xrange(k):\n cross_feature_matrix = np.concatenate((feature_matrix[:i*subset_size], feature_matrix[(i+1)*subset_size:]))\n cross_labels = np.concatenate((labels[:i*subset_size], labels[(i+1)*subset_size:]))\n test_matrix = feature_matrix[i*subset_size:(i+1)*subset_size]\n test_labels = labels[i*subset_size:(i+1)*subset_size]\n\n if flag == 0:\n theta_vector, theta_0 = averager(cross_feature_matrix, cross_labels)\n elif flag == 1:\n theta_vector, theta_0 = train_perceptron(cross_feature_matrix, cross_labels)\n elif flag == 2:\n theta_vector, theta_0 = train_passive_agressive(cross_feature_matrix, cross_labels, T)\n\n label_output = perceptron_classify(test_matrix, theta_0, theta_vector)\n\n correct = 0\n for i in xrange(0, len(label_output)):\n if(label_output[i] == test_labels[i]):\n correct = correct + 1\n\n percentages.append(100.0 * correct / len(label_output))\n\n return sum(percentages) / len(percentages)","def fold_data(fold, datas):\n training, validation = fold\n folded = {}\n\n # fold Xtrain\n if datas.get('Xtrain') is not None:\n folded['Xtrain'] = datas['Xtrain'][training, :]\n folded['Xtest'] = datas['Xtrain'][validation, :]\n\n # fold Ktrain\n if datas.get('Ktrain') is not None:\n folded['Ktrain'] = datas['Ktrain'][training, :][:, training]\n folded['Ktest'] = datas['Ktrain'][validation, ][:, training]\n # if datas.get('Ktest') is not None:\n # folded['Ktest'] = datas['Ktest'][:, validation]\n # else:\n # folded['Ktest'] = folded['Xtest'].dot(folded['Xtrain'].T)\n\n # fold Ytrain\n if datas.get('Ytrain') is not None:\n folded['Ytrain'] = datas['Ytrain'][training, :]\n folded['Ytest'] = datas['Ytrain'][validation, :]\n\n return folded","def _cross_valid_feature(max_fold, num_movies, num_users, lamda, subplt):\n loss_train_vector = [.0]*31\n loss_cross_vector = [.0]*31\n cost_train_per_fold = [.0]*max_fold\n cost_cross_per_fold = [.0]*max_fold\n for i in range(1, 31, 1):\n for k in range(1, max_fold + 1, 1):\n cost_train_per_fold[k-1], cost_cross_per_fold[k-1] = (\n _cross_valid_fold(k, num_movies, num_users,\n i, lamda))\n loss_train_vector[i] = np.mean(cost_train_per_fold)\n loss_cross_vector[i] = np.mean(cost_cross_per_fold)\n\n # draw the Loss v.s num_feature graph\n subplt.plot(loss_train_vector, \"r\")\n subplt.plot(loss_cross_vector, \"b\")\n v1 = np.array(loss_cross_vector)\n v2 = np.array(loss_train_vector)\n v3 = v1 + v2\n sel_feature = np.argmin(v3[1:]) + 1\n subplt.plot(v3, \"g\", label=\"lambda=\"+str(lamda))\n plt.axis([1, 30, 0, 1.2*max(v3)])\n return sel_feature","def choose_k ( \n X,\n y,\n model_call,\n param_grid,\n scoring_func = accuracy,\n cv = KFoldStratifiedCV ( number_of_folds = 3 ),\n):\n grid_search_cv = GridSearchCV (\n model_callable = model_call,\n param_grid = param_grid,\n scoring_func = scoring_func,\n cv_object = cv,\n )\n \n # Get the last sorted value and take k from that values\n return sorted ( list ( grid_search_cv.get_cv_scores ( X, y ) ), key = lambda x: x [ 1 ] ) [ -1 ][ 0 ][ \"k\" ]\n # End choose_k()","def cross_validation_accuracy(clf, X, labels, k):\n abc = KFold(k, False)\n answer = []\n\n for train_idx, test_idx in abc.split(X):\n Xt, Xs = X[train_idx],X[test_idx]\n tr, ts=labels[train_idx],labels[test_idx]\n clf.fit(Xt,tr)\n final_ans = clf.predict(Xs)\n acc1 = accuracy_score(ts, final_ans)\n answer.append(acc1)\n\n return np.mean(np.array(answer))","def set_cross_validation(x,y):\n\tx_train_1 = x[50:]\n\ty_train_1 = y[50:]\n\tx_test_1 = x[:50]\n\ty_test_1 = y[:50]\n\tx_train_2 = np.concatenate((x[:50], x[100:]),axis=0)\n\ty_train_2 = np.concatenate((y[:50], y[100:]),axis=0)\n\tx_test_2 = x[50:100]\n\ty_test_2 = y[50:100]\n\tx_train_3 = np.concatenate((x[:100], x[150:]),axis=0)\n\ty_train_3 = np.concatenate((y[:100], y[150:]),axis=0)\n\tx_test_3 = x[100:150]\n\ty_test_3 = y[100:150]\n\tx_train_4 = x[:150]\n\ty_train_4 = y[:150]\n\tx_test_4 = x[150:]\n\ty_test_4 = y[150:]\n\n\tx_train = [x_train_1,x_train_2,x_train_3,x_train_4]\n\ty_train = [y_train_1,y_train_2,y_train_3,y_train_4]\n\tx_test = [x_test_1,x_test_2,x_test_3,x_test_4]\n\ty_test = [y_test_1,y_test_2,y_test_3,y_test_4]\n\t# print 'cross val shapes', x_train.shape, y_train.shape, x_test.shape, y_test.shape\n\treturn x_train, y_train, x_test, y_test","def train_and_test_k_fold(\n ds, prd, k=10, comm=config.comm, online=False, classes=None, parallel_test=False,\n cycles_per_barrier=10):\n train_and_test = lambda tr, te: train_and_test_once(\n tr, te, prd, comm=comm, online=online, classes=classes, parallel_test=parallel_test,\n cycles_per_barrier=cycles_per_barrier)\n\n if k <= 0:\n raise ValueError(\"k must be positive\")\n elif k == 1:\n splits = ds.split(10)\n train = concatenate(splits[j] for j in range(9))\n test = splits[9]\n return train_and_test(train, test)\n else:\n r = null_training_result()\n for train, test in get_k_fold_data(ds, k=k):\n r += train_and_test(train, test)\n comm.barrier()\n\n return r","def choose_k ( \n feature_matrix,\n target_array,\n model_call,\n param_grid,\n scoring_func = accuracy,\n cv = KFoldStratifiedCV ( number_of_folds = 3 ),\n):\n grid_search_cv = GridSearchCV (\n model_callable = model_call,\n param_grid = param_grid,\n scoring_func = scoring_func,\n cv_object = cv,\n )\n \n # Get the last sorted value and take k from that values\n return sorted ( list ( grid_search_cv.get_cv_scores ( feature_matrix, target_array ) ), key = lambda x: x [ 1 ] ) [ -1 ][ 0 ][ \"k\" ]\n # End choose_k()","def _get_devset_cv(self, train_x, train_y, dev_x, dev_y, n_folds):\n folds = []\n n_train = len(train_y)\n n_dev = len(dev_y)\n dev_ids = [n_train + i for i in xrange(n_dev)]\n # create stratified K-folds over the training data\n skf = StratifiedKFold(n_splits=NFOLDS, shuffle=True)\n for train_ids, test_ids in skf.split(train_x, train_y):\n folds.append((train_ids,\n np.concatenate((test_ids, dev_ids))))\n train_x += dev_x\n train_y += dev_y\n return folds, train_x, train_y","def cross_validate(all_tetrode_data, target, tetrode_ids, tetrode_units, verbose=True):\n kf = StratifiedKFold(n_splits=10)\n y_true = np.zeros(target.shape)\n y_hat = np.zeros(target.shape)\n i = 0\n\n for train_index, test_index in kf.split(np.zeros(target.shape[0]), target.argmax(axis=-1)):\n X_train, X_test = select_data(all_tetrode_data, train_index), select_data(all_tetrode_data, test_index)\n y_train, y_test = target[train_index, :], target[test_index, :]\n\n model = build_tetrode_model(tetrode_ids, tetrode_units)\n checkpointer = ModelCheckpoint('temp_model.h5',\n verbose=0, save_best_only=True)\n hist = model.fit(X_train, y_train,\n nb_epoch=200, batch_size=20,\n validation_data=(X_test, y_test),\n callbacks=[checkpointer], verbose=0)\n best_model = load_model('temp_model.h5')\n\n n = y_test.shape[0]\n y_true[i:(i + n), :] = y_test\n y_hat[i:(i + n), :] = best_model.predict(X_test)\n i += n\n\n if verbose:\n accuracy = max(hist.history['val_acc'])\n print('Current fold validation accuracy: {acc}'.format(acc=accuracy))\n\n return y_true, y_hat","def train_cv(X_train, Y_train, nfold = 5, early_stopping_rounds = 20):\n # model params\n params = { \"objective\" : \"multiclass\",\n \"num_class\" : 6,\n \"verbosity\" : -1 }\n\n # create dataset for lightgbm\n lgb_train = lgb.Dataset(X_train, Y_train)\n \n # cross validate to find optimal no of iterations\n r = lgb.cv(params, \n lgb_train, \n 10000,\n early_stopping_rounds = early_stopping_rounds,\n nfold = nfold,\n feval = accuracy_error,\n metrics = 'None',\n verbose_eval = True,\n seed = 42)\n\n # Highest score\n r_best = np.max(r['accuracy-mean'])\n\n # best number of estimators\n best_estimators = np.argmax(r['accuracy-mean']) + 1\n print(best_estimators)\n\n print(f'The maxium accuracy on the validation set was {r_best:.5f}')\n print(f'The ideal number of iterations was {best_estimators}.')\n\n # Fit on all of the training data using the ideal number of iterations\n model = lgb.LGBMClassifier(n_estimators=best_estimators, n_jobs = -1,\n **params, random_state = 42) \n model.fit(X_train, Y_train)\n\n return model"],"string":"[\n \"def k_folds_cross_validate(self, k):\\n start_time = time.time()\\n partition_size = int(self.num_samples / k)\\n partitions = [\\n (i * partition_size, (i + 1) * partition_size) for i in range(k)\\n ]\\n average_accuracy = 0.0\\n for start, end in partitions:\\n validation_input_set = self.input[start:end, :] # subset of input of size k (k samples)\\n validation_output_set = self.output[start:end] # subset of output of size k (k outputs)\\n training_input_set = np.delete(self.input, np.s_[start:end], 0) # subset of input excluding validation set\\n training_output_set = np.delete(self.output, np.s_[start:end], 0) # subset of output excluding validation\\n\\n self.fit(training_input_set, training_output_set)\\n accuracy = self.evaluate_acc(validation_input_set, validation_output_set)\\n # print('Accuracy: ', accuracy) # accuracy of each fold\\n average_accuracy += accuracy\\n average_accuracy /= k\\n print('Average accuracy: ', average_accuracy)\\n print('Runtime: ', time.time() - start_time, 'seconds')\",\n \"def k_fold_cross_validation(X, K):\\n\\tfor k in xrange(K):\\n\\t\\ttraining = [i for i, x in enumerate(X) if i % K != k]\\n\\t\\tvalidation = [i for i, x in enumerate(X) if i % K == k]\\n\\t\\tyield training, validation\",\n \"def k_fold_cross_validation(X, K, randomise = False):\\n\\tif randomise: from random import shuffle; X=list(X); shuffle(X)\\n\\tfor k in xrange(K):\\n\\t\\ttraining = [x for i, x in enumerate(X) if i % K != k]\\n\\t\\tvalidation = [x for i, x in enumerate(X) if i % K == k]\\n\\t\\tyield training, validation\",\n \"def cross_validation(self, k=5):\\n test_errors, train_errors = [], []\\n\\n # For leave out cross validation k = n\\n if k == -1:\\n k = len(data)\\n\\n for _ in range(k):\\n shuffled_data = data.copy()\\n\\n # Do not shuffle data for leave one out cross validation\\n if k != -1:\\n # Copy the original data and shuffle it\\n np.random.shuffle(shuffled_data)\\n\\n # Divide it into k folds\\n split = int(((k - 1) / k) * len(data))\\n train_data = shuffled_data[:split]\\n test_data = shuffled_data[split:]\\n\\n # Find train_X, train_Y, test_X, test_Y\\n # KNN requires access to training data to determine error\\n self.train_X = np.asarray(train_data[:, :6])\\n self.train_Y = np.asarray(train_data[:, 7])\\n\\n test_X = np.asarray(test_data[:, :6])\\n test_Y = np.asarray(test_data[:, 7])\\n\\n # Use (k-1) part for training and 1 part for testing\\n self.fit(self.train_X, self.train_Y)\\n test_error = self.compute_error(test_X, test_Y)\\n train_error = self.compute_error(self.train_X, self.train_Y)\\n test_errors.append(test_error)\\n train_errors.append(train_error)\\n\\n # Average the error\\n avg_train_error = np.round(np.average(np.asarray(train_errors), axis=0), 3)\\n avg_test_error = np.round(np.average(np.asarray(test_errors), axis=0), 3)\\n print(\\\"The average error of {} is - Train : {}\\\\tTest : {} Overfit : {}\\\".format(self.method,\\n avg_train_error, avg_test_error,\\n avg_test_error > avg_train_error))\\n return avg_test_error, avg_train_error\",\n \"def cross_validation(self):\\r\\n kfold = KFold(10, shuffle=True, random_state=1)\\r\\n data = self.read_data()\\r\\n # error from each kth iteration\\r\\n errors = []\\r\\n for train, test in kfold.split(data):\\r\\n\\r\\n #Splitting into test and training data\\r\\n X_test, Y_test = data[test][:, 1], data[test][:, 2]\\r\\n X_train, Y_train = data[train][:, 1], data[train][:, 2]\\r\\n\\r\\n #Training on the split data\\r\\n weights, design_matrix = self.train(X_train, Y_train)\\r\\n\\r\\n y_pred = self.make_prediction(X_test, weights)\\r\\n self.plot(y_true=Y_test, y_pred=y_pred, x=X_test)\\r\\n\\r\\n #error matrix\\r\\n errors.append(np.mean(y_pred - Y_test) ** 2)\\r\\n\\r\\n #cross-validation parameter taken as mean of errors obtained from each iteration\\r\\n print(\\\"%0.10f mean with a standard deviation of %0.10f across the k-folds\\\" % (np.mean(errors), np.std(errors)))\",\n \"def k_cross_fold_validation( data, labels, k=5):\\n rf = RandomForestClassifier(n_estimators=25)\\n predictions, indexes = [], []\\n size = data.shape[0]\\n step_size = int(size / 5)\\n for i in range(k):\\n indexes.append(range(i*k, min(i*k + k, size)))\\n xtrain = np.array(data)\\n ytrain = np.array(labels)\\n\\n # picks test slices\\n xtest = xtrain[i*k:i*k + k]\\n ytest = ytrain[i*k:i*k + k]\\n\\n # removes test slices from the training sets\\n xtrain = np.delete(xtrain, np.s_[i*k:i*k + k], axis=0)\\n ytrain = np.delete(ytrain, np.s_[i*k:i*k + k], axis=0)\\n\\n \\n rf = rf.fit(xtrain, ytrain)\\n prediction = rf.predict(xtest)\\n\\n predictions.append(prediction.tolist())\\n \\n return np.array(predictions), np.array(indexes)\",\n \"def cross_validation(whole_train_data, whole_train_labels, k, k_fold):\\n accuracies = []\\n for i in range(k_fold):\\n train_data, train_labels, validation_data, validation_labels = split_train_and_validation(whole_train_data, whole_train_labels, i, k_fold)\\n accuracy = knn(train_data, train_labels, validation_data, validation_labels, k)\\n accuracies.append(accuracy)\\n avg_accuracy = np.mean(accuracies)\\n return avg_accuracy\",\n \"def cross_validate(cv, x, y, k=1):\\n indices = np.arange(len(x))\\n np.random.shuffle(indices)\\n stepsize = int(len(x) / cv)\\n metrics = np.zeros(4)\\n for i in range(cv):\\n logging.info(f\\\"Cross-validation fold {i+1}\\\")\\n\\n # Slice test set out of data\\n test_indices = indices[i*stepsize:i*stepsize+stepsize]\\n x_test = x[test_indices]\\n y_test = y[test_indices]\\n\\n # Everything else is the training set\\n x_train = np.copy(x)\\n x_train = np.delete(x_train, test_indices, axis=0)\\n y_train = np.copy(y)\\n y_train = np.delete(y_train, test_indices, axis=0)\\n\\n metrics += evaluate(knn(x_test, x_train, y_train, k), y_test)\\n metrics /= cv\\n\\n print(metrics)\\n return metrics\",\n \"def cross_validation(self, k_folds, **inputs):\\n self.cv_stats, self.cv_traces = [], []\\n self.k_folds = k_folds\\n inputs = self._clean_inputs(inputs)\\n for i, fold in enumerate(k_folds):\\n train, test = fold\\n input_train, input_test = {}, {}\\n for name, data in inputs.items():\\n if name in self.cv_vars:\\n input_train[name] = data[train]\\n input_test[name] = data[test]\\n else:\\n input_train[name] = data\\n input_test[name] = data\\n trace = self.run(**input_train)\\n stats = self.calculate_statistics(trace, **input_test)\\n self.cv_traces.append(trace)\\n self.cv_stats.append(stats)\\n return self.cv_traces, self.cv_stats\",\n \"def kfold_cross_validation(X, n_splits=5):\\n\\n #Define variables\\n X_train_folds = []\\n X_test_folds = []\\n indexes = list(range(len(X)))\\n index = 0\\n\\n #Create folds\\n for i in range(n_splits):\\n test = []\\n train = []\\n #Determine how many to put in test\\n if((len(X) % n_splits) > i):\\n numTest = len(X) // n_splits +1\\n else:\\n numTest = len(X) // n_splits\\n for j in range(numTest):\\n if(index < len(X)):\\n test.append(index)\\n indexes.pop(indexes.index(index))\\n index = index + 1\\n for index1 in indexes:\\n train.append(index1)\\n X_test_folds.append(test)\\n X_train_folds.append(train)\\n indexes = list(range(len(X)))\\n\\n return X_train_folds, X_test_folds\",\n \"def kFoldCrossVal(self, k):\\n # shuffle\\n df = self.df.sample(frac=1)\\n # chunk into k folds\\n #fold_idxs = [range(i, self.len_, k) for i in xrange(k)] TODO: pointers ?\\n df_arr = [df[i::k] for i in xrange(k)]\\n\\n for i, validate in enumerate(df_arr):\\n train_list = df_arr[:i] + df_arr[i+1:]\\n train = pd.concat(train_list, axis=0)\\n assert len(train) + len(validate) == len(df)\\n yield (train, validate)\",\n \"def fold(self, k):\\n if not (0 < k < 5):\\n raise ValueError('almazan cross-evaluation proposes a k=4 k-cross evaluation, {} out of range'.format(k))\\n test_idcs = [idx for idx, fold in enumerate(self.fold_idcs) if fold == k]\\n train_idcs = list(set(range(len(self))).difference(set(test_idcs)))\\n return self.sub_set(train_idcs), self.sub_set(test_idcs)\",\n \"def kfold_cross_validation(X, n_splits=5):\\r\\n X_train_folds = []\\r\\n X_test_folds = []\\r\\n\\r\\n x_len = len(X)\\r\\n \\r\\n fold_modulus = x_len % n_splits\\r\\n \\r\\n start_idx = 0\\r\\n for fold in range(n_splits): \\r\\n\\r\\n if fold < fold_modulus:\\r\\n fold_size = x_len // n_splits + 1\\r\\n else:\\r\\n fold_size = x_len // n_splits\\r\\n\\r\\n fold_end = (start_idx + fold_size) - 1\\r\\n\\r\\n tmp = []\\r\\n for i in range(start_idx, fold_end + 1):\\r\\n tmp.append(i)\\r\\n X_test_folds.append(tmp)\\r\\n\\r\\n tmp = []\\r\\n for i in range(0, x_len):\\r\\n if i not in X_test_folds[fold]:\\r\\n tmp.append(i)\\r\\n X_train_folds.append(tmp)\\r\\n\\r\\n start_idx = fold_size + start_idx \\r\\n\\r\\n return X_train_folds, X_test_folds\",\n \"def crossValidate(x_training_data, y_training_data, test_size_percentage, k_values):\\n data_length = len(x_training_data)\\n foldSize = int(round(data_length * test_size_percentage)) # size of each temporary test data\\n groups = int(data_length/foldSize + 1) # # of groups\\n\\n best_score = 0\\n best_k = 0\\n\\n for k in k_values: # Test different values of k\\n score = 0\\n for i in range(0, data_length, foldSize): # Switch section of test data\\n \\n x_temp_test = x_training_data[i:i+foldSize] # get temporary data to test\\n known_y_test = y_training_data[i:i+foldSize] # we already know their labels\\n x_temp_training = np.append(x_training_data[0:i], x_training_data[i+foldSize:], axis=0) # the rest is our temporary training data\\n y_temp_training = np.append(y_training_data[0:i], y_training_data[i+foldSize:], axis=0)\\n\\n y_temp_test = knnForAll(x_temp_training, y_temp_training, x_temp_test, k) # labels determined for a current k value\\n\\n for i in range(len(known_y_test)): # Score how well this value of k did based \\n if y_temp_test[i] == known_y_test[i]: # on how well it matches the known labels\\n score += 1\\n\\n print(\\\"k:\\\",k,\\\"-- % correct: \\\",\\\"{:0.2f}\\\".format(score/data_length)) # print accuracy for training data \\n if score > best_score: # Choose the best k value up to this point\\n best_score = score\\n best_k = k\\n\\n return best_k\",\n \"def cross_valid(model,x,folds,metric,verbose=True): \\r\\n\\r\\n score=[]\\r\\n \\r\\n\\r\\n kf = KFold(folds,shuffle=False,random_state=0) \\r\\n\\r\\n\\r\\n i=0\\r\\n for train_index, test_index in kf.split(x):\\r\\n\\r\\n xtrain = x[train_index,:]\\r\\n xtest = x[test_index,:]\\r\\n\\r\\n model.fit(xtrain[:,:-1],xtrain[:,-1])\\r\\n\\r\\n ypred = model.predict(xtest[:,:-1])\\r\\n\\r\\n ytrue= xtest[:,-1] \\r\\n \\r\\n \\r\\n if metric == 'mae':\\r\\n score.append(mae(ytrue,ypred))\\r\\n elif metric == 'mse':\\r\\n score.append(mse(ytrue,ypred))\\r\\n elif metric == 'rrmse':\\r\\n score.append(rrmse(ytrue,ypred))\\r\\n\\r\\n else:\\r\\n score.append(rmse(xtest[:,-1],ypred))\\r\\n\\r\\n if verbose:\\r\\n print('-'*30)\\r\\n print(f'\\\\nFold {i+1} out of {folds}')\\r\\n print(f'{metric}: {score[i]}')\\r\\n\\r\\n i+=1\\r\\n\\r\\n if verbose:\\r\\n print(f'\\\\n Overall Score:')\\r\\n print(f'{metric}: Mean: {np.mean(score)} Std: {np.std(score)}')\\r\\n\\r\\n\\r\\n return score\",\n \"def cross_validation(features, target, n_neighbors=5, n_folds=5):\\n clf = KNeighborsClassifier(n_neighbors=n_neighbors)\\n cv_scores = cross_val_score(clf, features, target, cv=n_folds)\\n # print each cv score (accuracy) and average them\\n print('Cross Validation Scores Mean: %.2f' % (np.mean(cv_scores) * 100))\",\n \"def nestedKFoldValidation(k, X, y, kernel):\\n\\n print(\\\"running k-folds cross validation to find best slack C\\\")\\n\\n # list of slack variable values used to test the SVM with\\n C_list = [0.001, 0.01, 0.1, 1.0, 10.0, 100, 1000]\\n # number of iterations to run the bootstrapping\\n B = 30\\n\\n sample_list = list(range(len(y)))\\n np.random.shuffle(sample_list)\\n\\n # splitting list into k folds\\n foldSize = len(y)//k\\n folds = [sample_list[i*foldSize:(i+1)*foldSize] for i in range(k)]\\n\\n # add remaining items to the last fold\\n folds[-1] += sample_list[foldSize*k:]\\n\\n test_results = {}\\n for test in folds:\\n print('==== next outer fold ====')\\n # python dictionary to keep track of errors\\n error_dict = {}\\n for validation in folds:\\n # do not want identical test and validation folds\\n if validation == test:\\n continue\\n\\n # training data is all folds except for test and validation\\n train = [f for f in folds if f != test and f != validation][0]\\n # find errors across all parameters\\n for c in C_list:\\n alg = SVC(C=c, kernel=kernel)\\n alg.fit(X[train], y[train])\\n err = np.mean(y[validation] != alg.predict(X[validation]))\\n # keep track of all errors\\n if c not in error_dict:\\n error_dict[c] = {}\\n error_dict[c]['err'] = []\\n error_dict[c]['model'] = alg\\n error_dict[c]['err'].append(err)\\n\\n # finding the best parameter from the inner loop\\n bestC = -1\\n bestError = 1.0\\n for c in error_dict:\\n print('c=', c, 'err=', np.mean(error_dict[c]['err']))\\n err = np.mean(error_dict[c]['err'])\\n if err < bestError:\\n bestError = err\\n bestC = c\\n print('best c from inner loop is', bestC)\\n\\n # testing the best model from the inner loop against test data\\n train_err = np.mean(y[test] != alg.predict(X[test]))\\n if bestC not in test_results:\\n test_results[bestC] = []\\n test_results[bestC].append(train_err)\\n\\n for c in test_results:\\n print('c=', c,\\n 'mean error=', np.mean(test_results[c]),\\n 'stddev of errors=', np.std(test_results[c]))\",\n \"def kFoldCrossValidation(self, n_splits ):\\n X = self.X\\n y = self.y\\n\\n k_fold = KFold(n_splits)\\n model = self.model\\n\\n for train, test in k_fold.split(X):\\n model.fit(X[train], y[train])\\n p = model.predict( X[test] )\\n # Add line for scores\\n\\n return model #return scores here?\",\n \"def k_fold_cross_validation(data, K, randomise = False, random_seed=None, structured=None):\\n if randomise:\\n import random\\n if random_seed != None:\\n random.seed(random_seed)\\n random.shuffle(data.data)\\n datatr=data.make_clone()\\n datatst=data.make_clone()\\n\\n for k in xrange(K):\\n datatr.data = []\\n index_tr = []\\n datatst.data = []\\n index_tst = []\\n for i, x in enumerate(data.data) :\\n if i % K != k :\\n datatr.data.append(x)\\n index_tr.append(i)\\n else :\\n datatst.data.append(x)\\n index_tst.append(i)\\n yield datatr, datatst, index_tr, index_tst\",\n \"def generate_k_folds(dataset, k):\\n\\n # TODO: finish this.\\n folds = []\\n dataset = np.concatenate((dataset[0], np.array(dataset[1]).reshape(-1,1)), axis=1)\\n dataset_shape = dataset.shape\\n shape_test_set = int(round(dataset_shape[0]/k,0))\\n split_dataset = np.array_split(dataset,k,axis=0)\\n for i in range(k):\\n test_set = split_dataset[i]\\n c = [k for j,k in enumerate(split_dataset) if j!=i]\\n training_set = np.concatenate(c,axis=0)\\n if test_set.shape[0] != shape_test_set:\\n step = test_set.shape[0] - shape_test_set\\n test_set = test_set[:-step,:]\\n training_set = np.concatenate((training_set, test_set[-step:,:]), axis=0)\\n r_test_set = (test_set[:,:-1], list(test_set[:,-1]))\\n r_train_set = (training_set[:,:-1], list(training_set[:,-1]))\\n folds.append((r_train_set, r_test_set))\\n return folds\",\n \"def cross_validation(y, x, K, model, lambda_, gamma, max_iters, initial_w, num_epochs=1, shuffle=True, seed=1):\\n data_size = len(y) ## Number of data points\\n x = np.array(x)\\n y = np.array(y)\\n\\n count = 0\\n batch_size = int(data_size/K) ## Data size assumed to multiple of K\\n err_val = np.zeros(num_epochs*K)\\n err_train = np.zeros(num_epochs*K)\\n\\n # Set random seed such that model comparison is uniform and consistent\\n np.random.seed(seed)\\n\\n # Number of times K-fold cross validation is repeated\\n for epoch in range(num_epochs):\\n print(\\\"epoch = {}\\\".format(epoch))\\n # Randomize to remove ordering in the input data\\n if shuffle == True:\\n shuffle_ind = np.random.permutation(np.arange(data_size))\\n y_shuffle = y[shuffle_ind]\\n x_shuffle = x[shuffle_ind]\\n else:\\n y_shuffle = y\\n x_shuffle = x\\n\\n # K-fold cross validation\\n for k in range(0,K):\\n print(\\\"k = {}\\\".format(k))\\n\\n # Select validation data in kth fold\\n start_val_ind = k*batch_size\\n end_val_ind = (k+1)*batch_size\\n y_val = y_shuffle[start_val_ind: end_val_ind]\\n x_val = x_shuffle[start_val_ind: end_val_ind]\\n\\n # Select training data in kth fold\\n train_ind = np.setxor1d(range(0,data_size),range(start_val_ind,end_val_ind))\\n y_train = y_shuffle[train_ind]\\n x_train = x_shuffle[train_ind]\\n\\n # Logistic regression and reg_logistic_regression models\\n if ((model=='logistic_regression') or (model=='reg_logistic_regression')):\\n if model=='logistic_regression': ## Train the model\\n w, loss = logistic_regression((1+y_train)/2, x_train, initial_w, max_iters, gamma)\\n elif model=='reg_logistic_regression':\\n w, loss = reg_logistic_regression((1+y_train)/2, x_train, lambda_, initial_w, max_iters, gamma)\\n # Predict on validation and training data\\n y_pred_val = np.ones(len(y_val))\\n y_pred_val[sigmoid(np.dot(x_val,w)) <= 0.5] = -1\\n y_pred_train = np.ones(len(y_train))\\n y_pred_train[sigmoid(np.dot(x_train,w)) <= 0.5] = -1\\n\\n\\n # Least squares models\\n else:\\n if model == 'least_squares': ## Least squares regression using normal equation\\n w, loss = least_squares(y_train, x_train)\\n elif model == 'least_squares_GD': ## Least squares regression using gradient descent\\n w, loss = least_squares_GD(y_train, x_train, initial_w, max_iters, gamma)\\n elif model == 'least_squares_SGD': ## Least squares regression using stochastic gradient descent\\n w, loss = least_squares_SGD(y_train, x_train, initial_w, max_iters, gamma)\\n elif model == 'ridge_regression': ## Ridge regression\\n w, loss = ridge_regression(y_train, x_train, lambda_)\\n else:\\n print(\\\"Unknown model\\\")\\n # Predict on validation and training data\\n y_pred_val = predict_labels(w, x_val) ## Predict on validation data\\n y_pred_train = predict_labels(w, x_train) ## Predict on training data\\n\\n err_val[count] = sum(y_pred_val!=y_val)/len(y_val) ## Accuaracy on Validation data\\n err_train[count] = sum(y_pred_train!=y_train)/len(y_train) ## Accuaracy on training data\\n count+=1\\n\\n ## Average error over all folds of cross validation\\n avg_val_err = np.mean(err_val)\\n avg_train_err = np.mean(err_train)\\n\\n ## Return optimal weight, loss, average validation error, average training error\\n return w, loss, avg_val_err, avg_train_err\",\n \"def crossValidate(k, epochs, hyperparams, data, trainFunc, testFunc, report=None):\\n \\n if not (report == None):\\n tabs = '\\\\t' * report;\\n print tabs, 'Performing %d-fold cross validation...' % k;\\n \\n # create vars to save the best hyperparameters and their performance\\n bestTheta = None;\\n bestRate = float(\\\"-inf\\\");\\n \\n # create queue for worker threads to post results to\\n queue = mp.Queue();\\n \\n # create train/test folds\\n numPerFold = len(data) // k;\\n numLeftOver = len(data) % k;\\n folds = [data[i*numPerFold:i*numPerFold+numPerFold] for i in range(0, k)];\\n if numLeftOver > 0:\\n folds[-1].extend(data[-numLeftOver:]); \\n \\n # create a list of tuples; each tuple defining a unique assignment of hyperparameters \\n thetas = list(itertools.product(*hyperparams));\\n \\n # create worker threads try all combinations of hyperparameters \\n workers = []; \\n for theta in thetas: \\n p = mp.Process(target=cvWorker, args=(epochs, theta, folds, trainFunc, \\\\\\n testFunc, report, queue));\\n workers.append(p)\\n \\n # start worker threads and wait for them to finish\\n for p in workers:\\n p.start();\\n for p in workers:\\n p.join()\\n \\n if not (report == None):\\n print tabs, 'All worker threads have terminated.';\\n \\n # read results out of queue \\n while not queue.empty():\\n [theta, rate] = queue.get();\\n if rate > bestRate:\\n bestTheta = theta\\n bestRate = rate;\\n \\n return bestTheta;\",\n \"def executeKFoldValidation(train_data, train_labels, val_data, val_labels, test_data, test_labels,\\n images_47, labels_47, images_84, labels_84, all_unseen_images, all_unseen_labels):\\n if run_k_fold_validation:\\n print(\\\"In executingKFoldValidation\\\")\\n\\n # this is doing it manually:\\n kfold = StratifiedKFold(n_splits=k_fold_num, shuffle=True)\\n\\n test_scores_list = []\\n unseen_47_scores_list = []\\n unseen_84_scores_list = []\\n all_unseen_scores_list = []\\n\\n test_matrix_list = []\\n matrix_47_list = []\\n matrix_84_list = []\\n all_matrix_list = []\\n kf_counter = 0\\n\\n for train, test in kfold.split(train_data, train_labels):\\n kf_counter += 1\\n print('KFold #:', kf_counter)\\n\\n model = buildClassifier()\\n # fit the model\\n model.fit(train_data[train],\\n train_labels[train],\\n epochs=epochs,\\n validation_data=(val_data, val_labels),\\n batch_size=batch_size\\n )\\n\\n unseen_47_scores = model.evaluate(images_47, labels_47, batch_size=batch_size)\\n unseen_47_scores_list.append(unseen_47_scores[1] * 100)\\n unseen_84_scores = model.evaluate(images_84, labels_84, batch_size=batch_size)\\n unseen_84_scores_list.append(unseen_84_scores[1] * 100)\\n test_scores = model.evaluate(test_data, test_labels, batch_size=batch_size)\\n test_scores_list.append(test_scores[1] * 100)\\n all_unseen_score = model.evaluate(all_unseen_images, all_unseen_labels, batch_size=batch_size)\\n all_unseen_scores_list.append(all_unseen_score[1] * 100)\\n\\n # show confusion matrix\\n test_confusion_matrix, confusion_matrix_47, confusion_matrix_84, all_confusion_matrix = \\\\\\n gettingKFoldConfusionMatrix(test_data, test_labels, images_47, labels_47, images_84, labels_84,\\n all_unseen_images,\\n all_unseen_labels, kf_counter)\\n test_matrix_list.append(test_confusion_matrix)\\n matrix_47_list.append(confusion_matrix_47)\\n matrix_84_list.append(confusion_matrix_84)\\n all_matrix_list.append(all_confusion_matrix)\\n\\n test_scores_mean = np.mean(test_scores_list)\\n test_scores_std = np.std(test_scores_list)\\n unseen_47_mean = np.mean(unseen_47_scores_list)\\n unseen_47_std = np.std(unseen_47_scores_list)\\n unseen_84_mean = np.mean(unseen_84_scores_list)\\n unseen_84_std = np.std(unseen_84_scores_list)\\n all_unseen_mean = np.mean(all_unseen_scores_list)\\n all_unseen_std = np.std(all_unseen_scores_list)\\n\\n print(\\\"Test Scores: \\\" + str(test_scores_list))\\n print(\\\"Test Scores Mean: \\\" + str(test_scores_mean))\\n print(\\\"Test Scores Std: \\\" + str(test_scores_std))\\n print(\\\"Unseen 47 Scores: \\\" + str(unseen_47_scores_list))\\n print(\\\"Unseen 47 Scores Mean: \\\" + str(unseen_47_mean))\\n print(\\\"Unseen 47 Scores Std: \\\" + str(unseen_47_std))\\n print(\\\"Unseen 84 Scores: \\\" + str(unseen_84_scores_list))\\n print(\\\"Unseen 84 Scores Mean: \\\" + str(unseen_84_mean))\\n print(\\\"Unseen 84 Scores Std: \\\" + str(unseen_84_std))\\n print(\\\"All Unseen Scores: \\\" + str(all_unseen_scores_list))\\n print(\\\"All Unseen Scores Mean: \\\" + str(all_unseen_mean))\\n print(\\\"All Unseen Scores Std: \\\" + str(all_unseen_std))\\n print(\\\"Test Confusion Matrices: \\\" + str(test_matrix_list))\\n print(\\\"47 Confusion Matrices: \\\" + str(matrix_47_list))\\n print(\\\"84 Confusion Matrices: \\\" + str(matrix_84_list))\\n print(\\\"All Confusion Matrices: \\\" + str(all_matrix_list))\\n\\n excel_headers.append(\\\"Test Scores Mean\\\")\\n excel_dictionary.append(test_scores_mean)\\n excel_headers.append(\\\"Test Scores Std\\\")\\n excel_dictionary.append(test_scores_std)\\n excel_headers.append(\\\"Unseen 47 Scores Mean\\\")\\n excel_dictionary.append(unseen_47_mean)\\n excel_headers.append(\\\"Unseen 47 Scores Std\\\")\\n excel_dictionary.append(unseen_47_std)\\n excel_headers.append(\\\"Unseen 84 Scores Mean\\\")\\n excel_dictionary.append(unseen_84_mean)\\n excel_headers.append(\\\"Unseen 84 Scores Std\\\")\\n excel_dictionary.append(unseen_84_std)\\n excel_headers.append(\\\"All Unseen Scores Mean\\\")\\n excel_dictionary.append(all_unseen_mean)\\n excel_headers.append(\\\"All Unseen Scores Std\\\")\\n excel_dictionary.append(all_unseen_std)\\n\\n plt.plot(test_scores_list, color='red', label='Testing Scores')\\n plt.plot(unseen_47_scores_list, color='blue', label='Unseen 47 Scores')\\n plt.plot(unseen_84_scores_list, color='black', label='Unseen 84 Scores')\\n plt.plot(all_unseen_scores_list, color='green', label='Unseen Scores')\\n plt.xlabel('Folds')\\n plt.ylabel('Accuracy')\\n plt.legend()\\n\\n plt.show()\",\n \"def cross_validation(y, tx, k_fold, fit_function, score_function, seed=1, **fit_function_kwargs):\\n k_indices = build_k_indices(y, k_fold, seed)\\n score_te = 0\\n\\n for k in range(k_fold):\\n te_indices = k_indices[k]\\n tr_indices = k_indices[~(np.arange(k_indices.shape[0]) == k)].reshape(-1)\\n\\n y_te, x_te = y[te_indices], tx[te_indices]\\n y_tr, x_tr = y[tr_indices], tx[tr_indices]\\n\\n w, fit_loss = fit_function(y_tr, x_tr, **fit_function_kwargs)\\n score_te += score_function(y_te, x_te, w)\\n\\n return score_te/k_fold\",\n \"def cross_validation(ww_data, rw_data, k):\\n # shuffle the data\\n np.random.shuffle(ww_data)\\n np.random.shuffle(rw_data)\\n\\n # calculate cutoff for each partition\\n cutoff = ww_data.shape[0]//k\\n redArr = []\\n whiteArr = []\\n tmpStart = 0\\n tmpEnd = cutoff\\n \\n # create a list of k partitions for red and white data\\n for x in range(k):\\n if x != k-1:\\n redArr.append(rw_data[tmpStart:tmpEnd])\\n whiteArr.append(ww_data[tmpStart:tmpEnd])\\n else:\\n redArr.append(rw_data[tmpStart:])\\n whiteArr.append(ww_data[tmpStart:])\\n tmpStart+=cutoff\\n tmpEnd+=cutoff\\n\\n\\n redTraining = np.array(())\\n whiteTraining = np.array(())\\n accuracy = 0\\n count = 0\\n \\n for x in range(k):\\n # creates Test data set\\n tmpRedTest = redArr[x]\\n tmpWhiteTest = whiteArr[x]\\n \\n # creates list of partitons for training data set\\n if x!=k-1:\\n redTrainingList = redArr[:x] + redArr[x+1:]\\n whiteTrainingList = whiteArr[:x] + whiteArr[x+1:]\\n else:\\n redTrainingList = redArr[:x]\\n whiteTrainingList = whiteArr[:x]\\n\\n # stacks each training list into one nparray\\n redTraining = np.vstack(redTrainingList)\\n whiteTraining = np.vstack(whiteTrainingList)\\n\\n accuracy += experiment(whiteTraining, redTraining, tmpWhiteTest, tmpRedTest)\\n count += 1\\n # calculates accuracy and returns it\\n result = accuracy/count\\n return result\",\n \"def crossValidate(dataset, folds):\\n\\tshuffle(dataset)\\n\\tcv_results = []\\n\\tprecision_recall_acc = []\\n\\tfoldSize = int(len(dataset)/folds)\\n\\tfor i in range(0,len(dataset),foldSize):\\n\\t\\t# preparing data\\n\\t\\tvalD = dataset[i:i+foldSize]\\n\\t\\ttestD = dataset[:i]+dataset[i+foldSize:] #list(set(dataset)-set(dataset[i:i+foldSize]))\\n\\t\\t# Training\\n\\t\\tprint(\\\"*\\\"*60)\\n\\t\\tprint(\\\"Training on data-set size \\\"+str(len(testD))+\\\" of batch \\\"+str(i/(foldSize)))\\n\\t\\tclassi = trainClassifier(testD)\\n\\t\\t# Prediction on validation data \\n\\t\\tprint(\\\"Predicting on heldout data-set size...\\\"+str(len(valD))+\\\" of batch \\\"+str(i/(foldSize)))\\n\\t\\ty_true = list(map(lambda t: t[1], valD))\\n\\t\\ty_pred = predictLabels(valD,classi)\\t\\t\\n\\t\\t# Performance Metrics\\t\\t\\n\\t\\t# average based on macro as it calculate metrics for each label, and find their unweighted mean.\\n\\t\\tprecision_recall = list(precision_recall_fscore_support(y_true, y_pred, average='macro'))\\n\\t\\tacc = accuracy_score(y_true,y_pred)\\n\\t\\tprecision_recall[-1] = acc\\n\\t\\tprint(precision_recall)\\n\\t\\tprecision_recall_acc.append(precision_recall)\\n\\tdf = pd.DataFrame(precision_recall_acc,columns = [\\\"Precision\\\",\\\"Recall\\\",\\\"F1 score\\\",\\\"Accuracy Score\\\"])\\n\\tprint(df)\\n\\tcv_results = df.mean().tolist()\\n\\treturn cv_results\",\n \"def cross_validation(self, X, y, n_folds=5, shuffle=True, evaluation_metric='top30'):\\n # WE DON'T USE THIS\\n # We use basic train-test split to evaluate or models as a first approach\\n # We will then use CV for searching the best parameters via random search\\n pass\",\n \"def cross_validate(model, X, y, folds=5, epochs=5, batch_size=32, callbacks=None, shuffle=False, random_state=None):\\n\\n # Initalize KFold\\n kfolds = KFold(n_splits=folds, random_state=random_state, shuffle=shuffle)\\n all_metrics = []\\n\\n # To build the model\\n if type(model).__name__ == 'SVDpp':\\n model.implicit_feedback(X[:10, :])\\n model(X[:10, :])\\n\\n # Workaround to reset weights after each fold fit\\n weights = model.get_weights()\\n i = 1\\n\\n for train, val in kfolds.split(X, y):\\n\\n # Gather implicit feedback if model is SVD++\\n if type(model).__name__ == 'SVDpp':\\n model.implicit_feedback(X[train])\\n\\n print(f'\\\\nFitting on Fold {i}')\\n # Train and evaluate metrics\\n history = model.fit(\\n X[train], y[train], batch_size=batch_size, epochs=epochs, callbacks=callbacks)\\n print(f'\\\\nEvaluating on Fold {i}')\\n fold_score = history.model.evaluate(X[val], y[val])\\n all_metrics.append(fold_score)\\n\\n # Reset Weights\\n model.set_weights(weights)\\n\\n i += 1\\n\\n all_metrics = np.array(all_metrics)\\n\\n for i, metric in enumerate(model.metrics_names):\\n print(f'Mean {metric.capitalize()} : {np.mean(all_metrics.T[i])}')\\n\\n return all_metrics\",\n \"def _kfold_cross_val(self, training_elms: np.ndarray) -> None:\\n kf = model_selection.KFold(\\n n_splits=config.folds, shuffle=True, random_state=config.seed\\n )\\n self.df[\\\"elm_events\\\"] = training_elms\\n self.df[\\\"fold\\\"] = -1\\n for f_, (_, valid_idx) in enumerate(kf.split(X=training_elms)):\\n self.df.loc[valid_idx, \\\"fold\\\"] = f_\",\n \"def cross_validation(self, x, t, k=5):\\n print(\\\"Cross validation of the SVM Model...\\\")\\n\\n # Initialize best error / hyperparameters\\n best_error = float('inf')\\n best_reg = 0\\n best_deg = 0\\n\\n # Cross-validation 80-20\\n N = len(x)\\n N_train = math.floor(0.8 * N)\\n t = t.reshape((N,))\\n\\n #Initialize the grid search\\n\\n log_min_reg = np.log(0.001)\\n log_max_reg = np.log(1000)\\n reg_list = np.logspace(log_min_reg, log_max_reg, num=7, base=math.e)\\n\\n min_deg = 1\\n max_deg = 4\\n\\n for deg in range(min_deg, max_deg):\\n for reg in reg_list:\\n errors = np.zeros(k)\\n for j in range(k):\\n map_index = list(zip(x, t))\\n random.shuffle(map_index)\\n random_x, random_t = zip(*map_index)\\n\\n train_x = random_x[:N_train]\\n valid_x = random_x[N_train:]\\n train_t = random_t[:N_train]\\n valid_t = random_t[N_train:]\\n\\n self.model = SVC(gamma='auto', kernel='poly', degree=deg, C=reg, cache_size=1000)\\n self.train(train_x, train_t)\\n\\n error_valid = np.array([self.error(x_n, t_n) for t_n, x_n in zip(valid_t, valid_x)])\\n errors[j] = error_valid.mean()\\n\\n mean_error = np.mean(errors)\\n print(mean_error)\\n if mean_error < best_error:\\n best_error = mean_error\\n best_reg = reg\\n best_deg = deg\\n print(\\\"The new best hyper parameters are : \\\", best_reg, best_deg)\\n\\n print(\\\"Best hyper parameters are : \\\", best_reg, best_deg)\\n print(\\\"Validation error : \\\", 100 * best_error, \\\"%\\\")\\n self.model = SVC(gamma='auto', kernel='poly', degree=best_deg, C=best_reg)\\n self.train(x, t)\",\n \"def _cross_val(self, X, y, classifier, nfolds=10):\\n\\n # Make sure dimensions agree\\n assert X.shape[0] == y.shape[0], \\\"Number of observations should equal\\\" \\\\\\n \\\"number of labels.\\\"\\n\\n # Concatenate data in order to shuffle without changing X-y correspondence\\n data = np.c_[X, y]\\n\\n # Shuffle data (swaps rows when 2D - works OK for us)\\n np.random.seed(42)\\n np.random.shuffle(data)\\n\\n # Split data into (almost) equal folds (returns a list of arrays)\\n # and we cast the list into a numpy array in order to do list indexing\\n data = np.array(np.array_split(data, nfolds))\\n\\n # Do the k-fold cross-validation\\n accs = []\\n for k in range(nfolds):\\n # Get current test set\\n X_k_test = data[k][:, :-1]\\n y_k_test = data[k][:, -1]\\n\\n # Get remaining indices and current training set\\n remaining_idx = [i for i, v in enumerate(data) if i != k]\\n X_k_train = np.vstack(data[remaining_idx])[:, :-1]\\n y_k_train = np.vstack(data[remaining_idx])[:, -1]\\n\\n # Fit and predict with classifier\\n classifier.fit(X_k_train, y_k_train)\\n yhat = classifier.predict(X_k_test)\\n\\n # Store error rate\\n accs.append(self._accuracy(y_k_test, yhat))\\n\\n return np.array(accs)\",\n \"def __implement_cross_validation(self, X, y, model):\\n\\n skfolds = StratifiedKFold(n_splits=3, random_state=42)\\n\\n for train_index, test_index in skfolds.split(X, y):\\n clone_clf = clone(model)\\n X_train_folds = X[train_index]\\n y_train_folds = y[train_index]\\n X_test_fold = X[test_index]\\n y_test_fold = y[test_index]\\n\\n clone_clf.fit(X_train_folds, y_train_folds)\\n y_pred = clone_clf.predict(X_test_fold)\\n n_correct = sum(y_pred == y_test_fold)\\n message = \\\"ratio of correct predictions: \\\", n_correct / len(y_pred)\\n self.__logger.info(message)\",\n \"def k_fold_cross_validation(self, K: int=5, rem_day4:bool=True, smote: bool=True, shuffle: bool=False) -> dict:\\n k_folds = {}\\n\\n for k in range(K):\\n k_folds[k] = {\\\"X_train\\\": [], \\\"X_test\\\": [], \\\"y_test\\\": [], \\\"y_train\\\": []}\\n for df in self.dataframes:\\n header = set(df['label'].tolist())\\n # Removing Day 4\\n trails = set()\\n for i in header:\\n trail = eval(i)\\n if trail[0] != 4:\\n trails.add(i)\\n else:\\n if not(rem_day4):\\n trails.add(i)\\n\\n header = trails\\n\\n for trial in header:\\n # geting rows with (day, Trail)-label\\n rows = df.loc[df['label'] == trial].to_numpy()\\n # getting response label\\n response = rows[0][-1]\\n # getting the actual data from the matrix\\n rows = np.delete(rows, np.s_[0,1,-1], axis=1)\\n\\n chunks = np.array_split(rows, K)\\n for chunk in chunks[k]:\\n k_folds[k][\\\"X_test\\\"].append(chunk.astype(np.float))\\n k_folds[k][\\\"y_test\\\"].append(response)\\n\\n train_chunks = np.delete(chunks, k, axis=0)\\n for chunk in train_chunks:\\n for ch in chunk:\\n k_folds[k][\\\"X_train\\\"].append(ch.astype(np.float))\\n k_folds[k][\\\"y_train\\\"].append(response)\\n\\n\\n for k in range(K):\\n\\n self.X_test = np.asarray(k_folds[k][\\\"X_test\\\"])\\n self.y_test = np.asarray(k_folds[k][\\\"y_test\\\"])\\n self.X_train = np.asarray(k_folds[k][\\\"X_train\\\"])\\n self.y_train = np.asarray(k_folds[k][\\\"y_train\\\"])\\n\\n if smote:\\n self.use_SMOTE()\\n\\n if shuffle:\\n self.shuffle_labels()\\n\\n k_folds[k][\\\"X_test\\\"] = self.X_test\\n k_folds[k][\\\"X_train\\\"] = self.X_train\\n k_folds[k][\\\"y_test\\\"] = self.y_test\\n k_folds[k][\\\"y_train\\\"] = self.y_train\\n\\n return k_folds\",\n \"def crossValidate(self, args):\\n\\n ##################################\\n # Read the training data\\n ##################################\\n if not os.path.isdir(args.annotationPath):\\n print('annotation path does not exist: {}' \\\\\\n .format(args.annotationPath))\\n return -1\\n\\n data = self.readData(args.annotationPath)\\n\\n ############################\\n # Execute the K-Fold cross validation\\n ############################\\n\\n x = []\\n y = []\\n l = []\\n for subject, df in data.items():\\n lx = df[['gradient', 'rate']].values.tolist()\\n #lx = df[['rate']].values.tolist()\\n ly = np.array(df[['immersion']].values.tolist()).squeeze(-1)\\n x.extend(lx)\\n y.extend(ly.tolist())\\n l.append(len(lx))\\n\\n x = np.array(x)\\n y = np.array(y)\\n\\n print('Executing cross-validation with k = {}...'.format(args.k))\\n clf = StructuredPerceptron(random_state=2)\\n scores = []\\n folds = SequenceKFold(l, n_folds=args.k)\\n for train_idx, train_len, test_idx, test_len in folds:\\n xTrain = x[train_idx]\\n yTrain = y[train_idx]\\n clf.fit(xTrain, yTrain, train_len)\\n\\n xTest = x[test_idx]\\n yTest = y[test_idx]\\n yPred = clf.predict(xTest, test_len)\\n scores.append(accuracy_score(yTest, yPred))\\n\\n scores = np.array(scores)\\n print(scores)\\n print('Result of the K-Fold CV: {:3f} (+- {:3f})' \\\\\\n .format(scores.mean(), 2 * scores.std()))\\n\\n ############################\\n # Execute the Leave-One-Out cross validation\\n ############################\\n\\n\\n return 0\",\n \"def cross_validation(self, cv, lambdas, lambda_name, seed=1, skip=False, plot=False, **kwargs):\\n np.set_printoptions(precision=4)\\n k_indices = build_k_indices(self.train_y, cv, seed)\\n # define lists to store the loss of training data and test data\\n err_tr = []\\n err_te = []\\n weights = []\\n print(\\\"K-fold ({}) cross validation to examine [{}]\\\".\\n format(cv, lambdas))\\n for lamb in lambdas:\\n print(\\\"For lambda: {}\\\".format(lamb))\\n _mse_tr = []\\n _mse_te = []\\n _weight = []\\n for k in range(cv):\\n print('Cross valid iteration {}'.format(k))\\n weight, loss_tr, loss_te = self._loop_cross_validation(self.train_y, self.train_x,\\n k_indices, k,\\n lamb, lambda_name, **kwargs)\\n _mse_tr += [loss_tr]\\n _mse_te += [loss_te]\\n _weight.append(weight)\\n if skip:\\n break\\n avg_tr = np.average(_mse_tr)\\n avg_te = np.average(_mse_te)\\n err_tr += [avg_tr]\\n err_te += [avg_te]\\n weights.append(_weight)\\n print(\\\"\\\\t train error {}, \\\\t valid error {}\\\".\\n format(avg_tr, avg_te))\\n # Select the best parameter during the cross validations.\\n print('K-fold cross validation result: \\\\n {} \\\\n {}'.\\n format(err_tr, err_te))\\n # Select the best based on least err_te\\n min_err_te = np.argmin(err_te)\\n print('Best err_te result {}, lambda {}'.\\n format(err_te[min_err_te], lambdas[min_err_te]))\\n if plot:\\n from plots import cross_validation_visualization\\n cross_validation_visualization(lambdas, err_tr, err_te, title=lambda_name,\\n error_name=self.loss_function_name)\\n else:\\n save_numpy_array(lambdas, err_tr, err_te, names=['lambda', 'err_tr', 'err_te'], title=self.regularizer.name)\\n\\n return weights[min_err_te], lambdas[min_err_te], (err_tr, err_te)\",\n \"def cross_validation(exp_name):\\n click.echo(\\\"Mode: Cross-validation.\\\")\\n # defaults = get_defaults()\\n\\n # fitted_model_filename = add_extension(fitted_model_filename)\\n\\n # derive final path for fitted model as base output path for fitted models + model filename\\n # fitted_model_path = os.path.join(defaults.OUTPUT.FITTED_MODELS_PATH, fitted_model_filename)\\n # new_options = [\\\"OUTPUT.FITTED_MODEL_PATH\\\", fitted_model_path]\\n\\n # don't reserve dev set at this point since we need to do it in each cv fold\\n boot_data = bootstrap(new_options=None, mode=\\\"cv\\\")\\n\\n defaults = boot_data['defaults']\\n X_train, y_train = boot_data['data']\\n\\n cv = RepeatedStratifiedKFold(n_splits=defaults.EVAL.N_SPLITS,\\n n_repeats=defaults.EVAL.N_REPEATS,\\n random_state=defaults.MISC.SEED)\\n\\n s = time.time()\\n outer_results, outer_preds = cross_validate(X=X_train, y=y_train,\\n cv=cv,\\n conf=defaults)\\n print(\\\"Execution time: %s seconds.\\\" % (time.time() - s))\\n\\n # dump results\\n # fitted_model_best_params_path = os.path.join(defaults.OUTPUT.PARAMS_PATH,\\n # \\\"best_params_{}.pkl\\\".format(fitted_model_filename.split('.')[0]))\\n\\n outer_results_formatted = show_cross_val_results(outer_results, conf=defaults)\\n\\n cv_results_path = os.path.join(defaults.OUTPUT.RESULTS_PATH, \\\"cv_results_{}.csv\\\".format(exp_name))\\n outer_results_formatted.to_csv(cv_results_path)\\n\\n # save predictions\\n outer_preds_path = os.path.join(defaults.OUTPUT.PREDS_PATH, \\\"cv_pooled_preds_{}.pkl\\\".format(exp_name))\\n save_obj(outer_preds, outer_preds_path)\",\n \"def kfold_cross_validate(\\n num_folds: int,\\n config: Union[dict, str],\\n dataset: str = None,\\n data_format: str = None,\\n skip_save_training_description: bool = False,\\n skip_save_training_statistics: bool = False,\\n skip_save_model: bool = False,\\n skip_save_progress: bool = False,\\n skip_save_log: bool = False,\\n skip_save_processed_input: bool = False,\\n skip_save_predictions: bool = False,\\n skip_save_eval_stats: bool = False,\\n skip_collect_predictions: bool = False,\\n skip_collect_overall_stats: bool = False,\\n output_directory: str = \\\"results\\\",\\n random_seed: int = default_random_seed,\\n gpus: Union[str, int, List[int]] = None,\\n gpu_memory_limit: Optional[float] = None,\\n allow_parallel_threads: bool = True,\\n backend: Union[Backend, str] = None,\\n logging_level: int = logging.INFO,\\n **kwargs,\\n) -> Tuple[dict, dict]:\\n # if config is a path, convert to dictionary\\n if isinstance(config, str): # assume path\\n config = load_yaml(config)\\n backend = initialize_backend(backend or config.get(\\\"backend\\\"))\\n\\n # check for k_fold\\n if num_folds is None:\\n raise ValueError(\\\"k_fold parameter must be specified\\\")\\n\\n logger.info(f\\\"starting {num_folds:d}-fold cross validation\\\")\\n\\n # create output_directory if not available\\n if not os.path.isdir(output_directory):\\n os.mkdir(output_directory)\\n\\n # prepare data for k-fold processing\\n # use Ludwig's utility to facilitate creating a dataframe\\n # that is used as the basis for creating folds\\n\\n dataset, _, _, _ = load_dataset_uris(dataset, None, None, None, backend)\\n\\n # determine data format of provided dataset\\n if not data_format or data_format == \\\"auto\\\":\\n data_format = figure_data_format(dataset)\\n\\n data_df = load_dataset(dataset, data_format=data_format, df_lib=backend.df_engine.df_lib)\\n\\n kfold_cv_stats = {}\\n kfold_split_indices = {}\\n\\n for train_indices, test_indices, fold_num in generate_kfold_splits(data_df, num_folds, random_seed):\\n with tempfile.TemporaryDirectory() as temp_dir_name:\\n curr_train_df = data_df.iloc[train_indices]\\n curr_test_df = data_df.iloc[test_indices]\\n\\n kfold_split_indices[\\\"fold_\\\" + str(fold_num)] = {\\n \\\"training_indices\\\": train_indices,\\n \\\"test_indices\\\": test_indices,\\n }\\n\\n # train and validate model on this fold\\n logger.info(f\\\"training on fold {fold_num:d}\\\")\\n\\n model = LudwigModel(\\n config=config,\\n logging_level=logging_level,\\n backend=backend,\\n gpus=gpus,\\n gpu_memory_limit=gpu_memory_limit,\\n allow_parallel_threads=allow_parallel_threads,\\n )\\n (eval_stats, train_stats, preprocessed_data, output_directory) = model.experiment(\\n training_set=curr_train_df,\\n test_set=curr_test_df,\\n experiment_name=\\\"cross_validation\\\",\\n model_name=\\\"fold_\\\" + str(fold_num),\\n skip_save_training_description=skip_save_training_description,\\n skip_save_training_statistics=skip_save_training_statistics,\\n skip_save_model=skip_save_model,\\n skip_save_progress=skip_save_progress,\\n skip_save_log=skip_save_log,\\n skip_save_processed_input=skip_save_processed_input,\\n skip_save_predictions=skip_save_predictions,\\n skip_save_eval_stats=skip_save_eval_stats,\\n skip_collect_predictions=skip_collect_predictions,\\n skip_collect_overall_stats=skip_collect_overall_stats,\\n output_directory=os.path.join(temp_dir_name, \\\"results\\\"),\\n random_seed=random_seed,\\n )\\n\\n # augment the training statistics with scoring metric from\\n # the hold out fold\\n train_stats_dict = dataclasses.asdict(train_stats)\\n train_stats_dict[\\\"fold_eval_stats\\\"] = eval_stats\\n\\n # collect training statistics for this fold\\n kfold_cv_stats[\\\"fold_\\\" + str(fold_num)] = train_stats_dict\\n\\n # consolidate raw fold metrics across all folds\\n raw_kfold_stats = {}\\n for fold_name in kfold_cv_stats:\\n curr_fold_eval_stats = kfold_cv_stats[fold_name][\\\"fold_eval_stats\\\"]\\n for of_name in curr_fold_eval_stats:\\n if of_name not in raw_kfold_stats:\\n raw_kfold_stats[of_name] = {}\\n fold_eval_stats_of = curr_fold_eval_stats[of_name]\\n\\n for metric in fold_eval_stats_of:\\n if metric not in {\\n \\\"predictions\\\",\\n \\\"probabilities\\\",\\n \\\"confusion_matrix\\\",\\n \\\"overall_stats\\\",\\n \\\"per_class_stats\\\",\\n \\\"roc_curve\\\",\\n \\\"precision_recall_curve\\\",\\n }:\\n if metric not in raw_kfold_stats[of_name]:\\n raw_kfold_stats[of_name][metric] = []\\n raw_kfold_stats[of_name][metric].append(fold_eval_stats_of[metric])\\n\\n # calculate overall kfold statistics\\n overall_kfold_stats = {}\\n for of_name in raw_kfold_stats:\\n overall_kfold_stats[of_name] = {}\\n for metric in raw_kfold_stats[of_name]:\\n mean = np.mean(raw_kfold_stats[of_name][metric])\\n std = np.std(raw_kfold_stats[of_name][metric])\\n overall_kfold_stats[of_name][metric + \\\"_mean\\\"] = mean\\n overall_kfold_stats[of_name][metric + \\\"_std\\\"] = std\\n\\n kfold_cv_stats[\\\"overall\\\"] = overall_kfold_stats\\n\\n logger.info(f\\\"completed {num_folds:d}-fold cross validation\\\")\\n\\n return kfold_cv_stats, kfold_split_indices\",\n \"def stratified_kfold_cross_validation(X, y, n_splits=5):\\n\\n #Define variables\\n X_train_folds = []\\n X_test_folds = []\\n\\n #Create dictionary \\n y_dict = myutils.group_by(y)\\n\\n #Split data\\n folds = [[] for _ in range(n_splits)]\\n for category in y_dict.keys():\\n index = y_dict[category]\\n for i in range(len(index)):\\n folds[i % n_splits].append(index[i])\\n\\n #Add data to train and testing sets\\n for i in range(n_splits):\\n train = []\\n for j in range(n_splits):\\n if i != j:\\n for item in folds[j]:\\n train.append(item)\\n test = folds[i]\\n X_train_folds.append(train)\\n X_test_folds.append(test)\\n \\n return X_train_folds, X_test_folds\",\n \"def tenfold_cross_validation(X, y):\\n\\n i = 0\\n x_score = []\\n y_score = []\\n\\n for i in range(1, 11):\\n for train_index, test_index in KFold(10).split(X):\\n x_train, x_test = X[train_index], X[test_index]\\n y_train, y_test = y[train_index], y[test_index]\\n\\n # change the parameters to see how each parameter affects the l1inear classifier\\n linear_classifier = linear_model.SGDClassifier(max_iter=1000, tol=1e-3)\\n\\n # start training the classifier\\n linear_classifier.fit(x_train, y_train)\\n\\n # create and plot the confusion matrix\\n # cross validation done with cross_val_\\n y_train_pred = cross_val_predict(linear_classifier, x_test, y_test, cv=10)\\n\\n print(\\\"\\\\n Statistics and Confusion matrix obtained with pandas_ml: \\\\n\\\")\\n cm = ConfusionMatrix(y_test, y_train_pred)\\n stats = cm.stats()\\n\\n file = open(\\\"linear_classification_9000_cross_validation_\\\" + str(i) + \\\".txt\\\", \\\"w\\\")\\n file.write(str(stats))\\n file.close()\\n\\n # cm.print_stats()\\n # print confusion matrix\\n cm.plot(normalized=True)\\n plt.show()\",\n \"def cross_validation_score(X_data, y_data, model, folds=5):\\n\\n # Shuffle index\\n index = np.random.permutation(len(X_data))\\n\\n fold_size = int(len(X_data) / folds)\\n scores = []\\n for i in range(folds):\\n \\n # Partition Data\\n X_train, X_val = partition_data(X_data[index], folds, i + 1, fold_size)\\n y_train, y_val = partition_data(y_data[index], folds, i + 1, fold_size)\\n\\n # Train Model\\n print(f\\\"Training on Fold: {i + 1}\\\")\\n model.fit(X_train, y_train)\\n\\n # Predict Values on Validation Set\\n val_pred = model.predict(X_val)\\n\\n # Get Accuracy\\n score = accuracy_score(y_val, val_pred)\\n scores.append(score)\\n \\n return sum(scores) / len(scores)\",\n \"def HypeNKFoldCV(x,\\n group_cols,\\n target_col,\\n clf,\\n nfolds,\\n kfolds,\\n alpha,\\n noise_std,\\n scorer):\\n ## all indices\\n all_idx = x.copy().index.values\\n ## will shuffle indices for randomisation\\n np.random.shuffle(all_idx)\\n ## outer splits indices\\n outer_splits = np.array_split(all_idx, nfolds)\\n ## scorer results\\n scores_val = []\\n ## outer cycle\\n for i in range(nfolds):\\n ## keep `i`-th fold for validation\\n val_idx = outer_splits[i]\\n x_val = x.loc[val_idx].copy()\\n ## choose all but `i`-th split\\n inner_idx = np.concatenate(outer_splits[:i] + outer_splits[(i + 1):])\\n ## further randomise training indices\\n np.random.shuffle(inner_idx)\\n ## split others further\\n inner_splits = np.array_split(inner_idx, kfolds)\\n ## training data frame\\n x_train = x.loc[inner_idx].copy()\\n ## iterate over group cols\\n for group_col in group_cols:\\n n_col_name = '_'.join([group_col, target_col])\\n ## encode using division into KFolds\\n x_train.loc[:, n_col_name] = KFoldTargetEncoding(x_train[[group_col, target_col]].copy(),\\n inner_splits,\\n group_col,\\n target_col,\\n n_col_name,\\n alpha,\\n noise_std)\\n ## filling in the same column on val\\n ## using whole `x_train`\\n x_val.loc[:, n_col_name] = targetEncoding(x_train.loc[:, [group_col, target_col]],\\n x_val.loc[:, [group_col]],\\n group_col,\\n target_col,\\n alpha,\\n noise_std)\\n\\n ## will train on x_train\\n ## will validate on x_val\\n if 'fit' in dir(clf):\\n clf.fit(x_train.drop(target_col, axis=1), x_train[target_col])\\n preds_val = clf.predict(x_val.drop(target_col, axis=1))\\n elif 'train' in dir(clf):\\n clf.train(x_train.drop(target_col, axis=1), x_train[target_col])\\n preds_val = clf.test(x_val.drop(target_col, axis=1)).argmax(axis=1)\\n else:\\n raise Exception(\\\"`clf` must contain either (`fit` and `predict`) or\\\"\\n \\\" (`train` and `test`) methods\\\")\\n scores_val.append(scorer(x_val[target_col], preds_val))\\n del x_val, preds_val, x_train\\n return scores_val\",\n \"def stratified_kfold_cross_validation(X, y, n_splits=5):\\r\\n indices = [x for x in range(0, len(X))]\\r\\n labels = []\\r\\n uniq_feat = []\\r\\n\\r\\n for idx,clss in enumerate(y):\\r\\n\\r\\n if clss in uniq_feat:\\r\\n labels[uniq_feat.index(clss)].append(indices[idx])\\r\\n else:\\r\\n labels.append([indices[idx]])\\r\\n uniq_feat.append(clss)\\r\\n \\r\\n index = 0\\r\\n X_test_folds = [[] for _ in range(0, n_splits)]\\r\\n\\r\\n for label in labels:\\r\\n for val in label:\\r\\n fold_idx = index%n_splits\\r\\n X_test_folds[fold_idx].append(val)\\r\\n index += 1\\r\\n \\r\\n X_train_folds = [[] for _ in range(0, n_splits)]\\r\\n\\r\\n for i in range(0, len(X)):\\r\\n for j in range(0, n_splits):\\r\\n if i not in X_test_folds[j]:\\r\\n X_train_folds[j].append(i)\\r\\n \\r\\n return X_train_folds, X_test_folds\",\n \"def cross_validation(self, x, t, k=5):\\n print(\\\"Cross validation of the Decision Tree Classifier...\\\")\\n bestCriteria = ''\\n bestMax_depth= 2\\n bestError = float('inf')\\n\\n N = len(x)\\n N_train = math.floor(0.8 * N)\\n\\n dicCriteria = ['gini', 'entropy']\\n min_depth = 2\\n max_depth = 40\\n\\n for crit in dicCriteria:\\n for d in range(min_depth, max_depth):\\n errors = np.zeros(k)\\n\\n for j in range(k):\\n map_index = list(zip(x, t))\\n random.shuffle(map_index)\\n random_X, random_t = zip(*map_index)\\n\\n train_x = random_X[:N_train]\\n valid_x = random_X[N_train:]\\n train_t = random_t[:N_train]\\n valid_t = random_t[N_train:]\\n\\n self.model = tree.DecisionTreeClassifier(max_depth=d, criterion=crit)\\n self.train(train_x, train_t)\\n error_valid = np.array([self.error(x_n, t_n)\\n for t_n, x_n in zip(valid_t, valid_x)])\\n errors[j] = error_valid.mean()\\n\\n mean_error = np.mean(errors)\\n if mean_error < bestError:\\n bestError = mean_error\\n bestCriteria = crit\\n bestMax_depth = d\\n print(\\\"The new best hyper parameters are : \\\", bestMax_depth, bestCriteria)\\n\\n print(\\\"Best hyper parameters are : \\\", bestMax_depth, bestCriteria)\\n print(\\\"Validation error : \\\", 100 * bestError, \\\"%\\\")\\n self.model = tree.DecisionTreeClassifier(max_depth=bestMax_depth, criterion=bestCriteria)\\n self.train(x, t)\",\n \"def crossValidation(training, k, performance):\\n\\n predictions = []\\n accuracy = []\\n\\n for index in range(1, 6):\\n # print index\\n temp = list(range(1, 6))\\n temp.remove(index)\\n # print 'index: ' + str(index) + ', temp: ' + str(temp)\\n\\n for x in range(len(training.get_group(index))):\\n if x % 100 != 0:\\n continue\\n target = training.get_group(index).values.tolist()[x][-1]\\n # if x % 500 == 0:\\n # print 'index: ' + str(index) + ', x: ' + str(x)\\n neighbors = []\\n distances = []\\n for validationSet in temp:\\n getDistances(training.get_group(validationSet).values.tolist(), training.get_group(index).values.tolist()[x], distances)\\n # Sort the distances list by the distance\\n distances.sort(key = lambda item: item[1])\\n # print distances\\n # Select first k closest elements to return as the neighbors\\n for x in range(k):\\n neighbors.append(distances[x][0])\\n\\n result=getResponse(neighbors)\\n\\n # print distances\\n # print neighbors\\n # print result\\n predictions.append(result)\\n # print 'result: ' + str(result)\\n # print 'target: ' + str(target)\\n # print 'result == target: ' + str(result == target)\\n if result == target:\\n accuracy.append((True, target))\\n else:\\n accuracy.append((False, target))\\n\\n count = 0\\n for item in accuracy:\\n if item[0] == True:\\n count += 1\\n\\n # print 'number of instances: ' + str(len(accuracy)) + ' number correct: ' + str(count)\\n\\n count = 0\\n for item in accuracy:\\n if item[0] == True:\\n count += 1\\n\\n # Add the current k-value and its accuracy for this run to dictionary\\n performance[k] = count / len(accuracy)\\n\\n print performance\\n return performance\",\n \"def __cross_validation(self, classifier, X, y, k, stratify=True):\\n\\t\\tif k == X.shape[0]:\\t\\t# leave-one-out\\n\\t\\t\\tkf = model_selection.KFold(n_splits=k)\\n\\t\\telse:\\n\\t\\t\\tif stratify:\\n\\t\\t\\t\\tkf = model_selection.StratifiedKFold(n_splits=k, shuffle=True, random_state=0)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tkf = model_selection.KFold(n_splits=k, shuffle=True, random_state=0)\\n\\n\\t\\t# training data and predictions for each fold\\n\\t\\ty_train_list = []\\n\\t\\ty_train_pred_list = []\\n\\t\\ty_train_prob_list = []\\n\\t\\ty_val_list = []\\n\\t\\ty_val_pred_list = []\\n\\t\\ty_val_prob_list = []\\n\\n\\t\\tfor train_idx, val_idx in kf.split(X, y):\\n\\t\\t\\tX_train, X_val = X.iloc[train_idx], X.iloc[val_idx]\\n\\t\\t\\ty_train, y_val = y.iloc[train_idx], y.iloc[val_idx]\\n\\t\\t\\ty_train_list.append(y_train)\\n\\t\\t\\ty_val_list.append(y_val)\\n\\n\\t\\t\\t# catch convergence warning\\n\\t\\t\\twith warnings.catch_warnings():\\n\\t\\t\\t\\twarnings.filterwarnings('error', category=exceptions.ConvergenceWarning)\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\tclassifier = classifier.fit(X_train, y_train)\\n\\t\\t\\t\\texcept exceptions.ConvergenceWarning:\\n\\t\\t\\t\\t\\tModel.counter -= 1\\n\\t\\t\\t\\t\\traise\\n\\n\\t\\t\\ty_train_pred_list.append(classifier.predict(X_train))\\n\\t\\t\\ty_val_pred_list.append(classifier.predict(X_val))\\n\\t\\t\\ty_train_prob_list.append(classifier.predict_proba(X_train))\\n\\t\\t\\ty_val_prob_list.append(classifier.predict_proba(X_val))\\n\\n\\t\\tif k == X.shape[0]:\\t\\t# leave-one-out\\n\\t\\t\\ty_val = np.hstack(y_val_list)\\n\\t\\t\\ty_val_pred = np.hstack(y_val_pred_list)\\n\\t\\t\\ty_val_prob = np.vstack(y_val_prob_list)\\n\\n\\t\\t\\treturn ModelMetrics(classifier, y_train_list, y_train_pred_list, y_train_prob_list, 'cv'), \\\\\\n\\t\\t\\t\\tModelMetrics(classifier, y_val, y_val_pred, y_val_prob, 'loo')\\n\\t\\telse:\\n\\t\\t\\treturn ModelMetrics(classifier, y_train_list, y_train_pred_list, y_train_prob_list, 'cv'), \\\\\\n\\t\\t\\t\\tModelMetrics(classifier, y_val_list, y_val_pred_list, y_val_prob_list, 'cv')\",\n \"def cv(data, folds, model):\\n def rmsle(predicted, actual):\\n # Root Mean Squared Logarithmic Error\\n return mean_squared_error(\\n np.log(predicted+1),\\n np.log(actual+1)\\n ) ** 0.5\\n\\n errors = []\\n print \\\" Cross Validation in progress...\\\"\\n kf = cross_validation.KFold(n=len(data.index), n_folds=folds)\\n for i, (train_index, validation_index) in enumerate(kf):\\n print ' F%d.' % i\\n train = data.iloc[train_index]\\n validation = data.iloc[validation_index]\\n\\n model.fit(train)\\n prediction = model.predict(validation)\\n actual = data.iloc[validation_index]['count'].as_matrix()\\n error = rmsle(prediction, actual)\\n errors.append(error)\\n return np.mean(errors)\",\n \"def cross_validate(self, inss, num_folds, folds_name=None, gen_folds=False):\\n kcv = CrossValidation(num_folds, inss, self.train, self.rank_inss)\\n\\n # loads/generates folds\\n if gen_folds:\\n kcv.create_folds(group_by=\\\"session\\\")\\n if folds_name is not None:\\n kcv.save_folds(folds_name)\\n else:\\n kcv.load_folds(folds_name)\\n\\n # Cross validation\\n inss = kcv.run()\\n inss.__class__ = CERInstances\\n for ins in inss.get_all():\\n ins.__class__ = CERInstance\\n return inss\",\n \"def nested_cv(X, y, model, n_splits, n_folds, unique_id):\\n \\n cv = StratifiedKFold(n_splits=n_splits,\\n shuffle=True,\\n random_state=42) # Outer CV\\n \\n i_start = 0\\n i_list = []\\n results_df = None\\n cv_path = unique_id + '_NestedCV.pkl'\\n \\n if os.path.isfile(cv_path) == True: # If CV is incomplete, resume\\n results_df = pd.read_pickle(cv_path)\\n i_start = results_df.Outer_fold.max() + 1\\n print('Resuming cross-validation from fold ' + str(i_start + 1))\\n \\n # Generate indices to split data by StratifiedKFold\\n # Append indices for each fold to list \\n for tr_i, te_i in cv.split(X,y):\\n i_list.append([tr_i, te_i])\\n \\n # For each fold...\\n for i in range(i_start, len(i_list)):\\n results_list = []\\n print('Beginning fold ' + str(i+1) + ' of ' + str(len(i_list)))\\n \\n # Split data into training and test tests\\n X_train = X.loc[X.index.intersection(i_list[i][0])]\\n y_train = y.loc[y.index.intersection(i_list[i][0])]\\n X_test = X.loc[X.index.intersection(i_list[i][1])]\\n y_test = y.loc[y.index.intersection(i_list[i][1])]\\n\\n start = time.time()\\n \\n # Fit the HyperoptEstimator to training data (optimise model)\\n model.fit(X_train,\\n y_train,\\n n_folds=n_folds, # Inner stratified k-fold CV\\n cv_shuffle=True)\\n \\n end = time.time()\\n duration = end - start\\n\\n # Use optimised model to predict labels for test data\\n y_pred = model.predict(X_test)\\n score = f1_score(y_test, y_pred, average='weighted') # Evaluate\\n \\n # Everything below: formats and/or calculates results for output file\\n sorted_labels = np.sort(y_test.unique())\\n unweighted_score = f1_score(y_test, y_pred,\\n average=None,\\n labels=sorted_labels)\\n c_matrix = confusion_matrix(y_test, y_pred,\\n labels=sorted_labels)\\n\\n for trial in range(len(model.trials.trials)):\\n if model.trials.trials[trial].get('result').get('status') == 'ok':\\n trial_loss = model.trials.trials[trial].get('result').get('loss')\\n trial_duration = model.trials.trials[trial].get('result').get('duration')\\n else:\\n trial_loss = np.nan\\n trial_duration = np.nan\\n \\n results_list.append([i,\\n score,\\n unweighted_score,\\n le.inverse_transform(sorted_labels),\\n c_matrix,\\n duration,\\n trial,\\n trial_loss,\\n trial_duration])\\n \\n append_df = pd.DataFrame(results_list,\\n columns=['Outer_fold',\\n 'Outer_score',\\n 'Outer_unweighted_scores',\\n 'Outer_unweighted_score_labels',\\n 'Outer_confusion_matrix',\\n 'Outer_training_duration',\\n 'Trial',\\n 'Trial_loss',\\n 'Trial_duration'])\\n if i == i_start:\\n if results_df is not None:\\n final_df = pd.concat([results_df,\\n append_df],\\n ignore_index=True)\\n else:\\n final_df = append_df\\n final_df.to_pickle(cv_path)\\n \\n else:\\n results_df = pd.read_pickle(cv_path)\\n final_df = pd.concat([results_df,\\n append_df],\\n ignore_index=True)\\n final_df.to_pickle(cv_path)\",\n \"def crossValidationKfold(automodel, \\r\\n X, y,\\r\\n params_automl : dict = {},\\r\\n score_function = accuracy_score,\\r\\n cv : int = 3,\\r\\n shuffle: bool = True,\\r\\n verbose : bool = True,\\r\\n allmetrics: bool = False):\\r\\n if(isinstance(X, pd.DataFrame) or isinstance(y, pd.DataFrame)):\\r\\n X = X.values\\r\\n y = y.values\\r\\n skf = StratifiedKFold(n_splits = cv, \\r\\n shuffle = shuffle, \\r\\n random_state = 42)\\r\\n if(allmetrics):\\r\\n train_scores = {'accuracy' : [], \\r\\n 'roc_auc': [], \\r\\n 'f1' : [], \\r\\n 'recall' : [], \\r\\n 'precision': []}\\r\\n test_scores = {'accuracy' : [], \\r\\n 'roc_auc': [], \\r\\n 'f1' : [], \\r\\n 'recall' : [], \\r\\n 'precision': []}\\r\\n else:\\r\\n train_scores = np.empty((cv, ))\\r\\n test_scores = np.empty((cv, ))\\r\\n for idx, (idx_tr, idx_ts) in enumerate(skf.split(X, y)):\\r\\n X_tr, X_ts = X[idx_tr], X[idx_ts]\\r\\n y_tr, y_ts = y[idx_tr], y[idx_ts] \\r\\n am = automodel(**params_automl)\\r\\n am.fit(X_tr, y_tr)\\r\\n if(not allmetrics):\\r\\n \\r\\n train_scores[idx] = score_function(am.predict(X_tr), y_tr)\\r\\n test_scores[idx] = score_function(am.predict(X_ts), y_ts)\\r\\n if(verbose):\\r\\n print('it: {} train score: {:.3f}, val score: {:.3f}'.format(idx, \\r\\n train_scores[idx],\\r\\n test_scores[idx]))\\r\\n else:\\r\\n train_current = {}\\r\\n test_current = {}\\r\\n for name, metric in all_metrics_classifications.items():\\r\\n train_current[name] = metric(am.predict(X_tr), y_tr)\\r\\n test_current[name] = metric(am.predict(X_ts), y_ts)\\r\\n train_scores[name].append(train_current[name])\\r\\n test_scores[name].append(test_current[name])\\r\\n \\r\\n if(verbose):\\r\\n print('it: {} train scores: {}, val scores: {}'.format(idx, train_current,\\r\\n test_current))\\r\\n\\r\\n if(not allmetrics):\\r\\n return test_scores.mean(), test_scores.std()\\r\\n else:\\r\\n # -- calculate means of all metrics-- #\\r\\n return dict(map(lambda kv: (kv[0], np.asarray(kv[1]).mean()), test_scores.items()))\",\n \"def cross_validation_experiment(train_data, train_labels):\\n accuracies = []\\n for i in range(1, 200):\\n avg = cross_validation(train_data, train_labels, i, 10)\\n accuracies.append(avg)\\n fig = plt.figure()\\n dim = np.arange(1,len(accuracies)+1)\\n plt.plot(dim,accuracies, label='Accuracy')\\n plt.xlabel('k')\\n plt.ylabel('accuracy')\\n plt.grid()\\n plt.legend()\\n plt.tight_layout()\\n fig.savefig('knn_cross_validation.png')\\n best_k = np.argmax(accuracies)+1\\n return best_k\",\n \"def train_kfold(self, blank_model, model_params, dataset, batch_size, drop_last_batch=True):\\n kfold = StratifiedKFold(n_splits=self.cv, shuffle=True)\\n best_val_loss = 999999\\n best_cv = 0\\n best_model = None\\n for i, (train_idx, test_idx) in enumerate(kfold.split(dataset, dataset.targets)):\\n # Initialize model\\n #model = copy.deepcopy(blank_model)\\n model = blank_model(**model_params).to(model_params['device'])\\n print(model.dev)\\n #print(model_params['device'])\\n print('Training fold %d'%(i), flush=True)\\n train_ds = torch.utils.data.Subset(dataset, train_idx)\\n test_ds = torch.utils.data.Subset(dataset, test_idx)\\n train_loader = torch.utils.data.DataLoader(train_ds, batch_size=batch_size, shuffle=True, drop_last=drop_last_batch, num_workers=self.num_work)\\n test_loader = torch.utils.data.DataLoader(test_ds, batch_size=batch_size, shuffle=True, drop_last=drop_last_batch, num_workers=self.num_work)\\n # Train model\\n epoch_hist = model.train_model(train_loader, test_loader=test_loader, n_epochs=self.n_epochs, learning_rate=self.lr, train_patience=self.train_p, test_patience=self.test_p, save_model=False)\\n # Save attributes\\n self.cv_res_dict[i]['history'] = epoch_hist\\n if 'valid_loss' in epoch_hist.keys():\\n self.cv_res_dict[i]['best_valid_loss'] = np.min(epoch_hist['valid_loss'])\\n #if self.return_model:\\n #self.cv_res_dict[i]['model'] = model\\n if best_val_loss > np.min(epoch_hist['valid_loss']):\\n best_val_loss = np.min(epoch_hist['valid_loss'])\\n best_cv = i\\n best_model = model\\n # Save if save all\\n if self.save_all:\\n full_path = self.path_dir+self.model_prefix+'fold_'+str(i)+'.pt'\\n print('Saving model at %s'%(full_path), flush=True)\\n torch.save(model.state_dict(), full_path)\\n\\n # delete model from memory ?\\n del model\\n if model_params['device'] == torch.device('cuda'):\\n torch.cuda.empty_cache()\\n\\n self.best_cv = best_cv\\n print('Best Fold: %d'%(self.best_cv), flush=True)\\n # Save best model to path\\n if self.save_best and not self.save_all:\\n path_best = self.path_dir+self.model_prefix+'best_fold.pt'\\n print('Saving best model at %s'%(path_best), flush=True)\\n torch.save(best_model.state_dict(), path_best)\\n elif self.save_best and self.save_all:\\n print('Best model already saved for fold %d'%(self.best_cv), flush=True)\\n\\n return\",\n \"def __init__(self, splits):\\n\\t\\tself.kfold = KFold(splits)\",\n \"def main():\\n # Read in trainingSet and testSet as a DataFrame\\n trainingOriginal = pd.read_csv(\\n filepath_or_buffer=\\\"~/Desktop/KNN Implementation/adult.train.5fold.csv\\\")\\n testOriginal = pd.read_csv(filepath_or_buffer=\\\"~/Desktop/KNN Implementation/adult.test.csv\\\")\\n\\n # Select only the numeric data\\n training = pd.DataFrame(trainingOriginal.select_dtypes(['number']))\\n training = pd.concat([training.reset_index(drop=True),\\n trainingOriginal['earns'].reset_index(drop=True)], axis=1)\\n\\n # Select only the numeric data\\n test = pd.DataFrame(testOriginal.select_dtypes(['number']))\\n test = pd.concat([test.reset_index(drop=True),\\n testOriginal['earns'].reset_index(drop=True)], axis=1)\\n\\n # Normalize the columns for training and test\\n # print training['age'].min()\\n # print training['age'].max()\\n # print training.head()\\n\\n # Run max-min normalization on numerical columns for testing and training data\\n for i in range(6):\\n training.iloc[:, i] = (training.iloc[:, i]- training.iloc[:, i].min())/(training.iloc[:, i].max() - training.iloc[:, i].min())\\n test.iloc[:, i] = (test.iloc[:, i]- test.iloc[:, i].min())/(test.iloc[:, i].max() - test.iloc[:, i].min())\\n\\n # Convert the 'earns' column to boolean as follows\\n training['earns'] = training['earns'] == '>50K'\\n test['earns'] = test['earns'] == ' >50K'\\n\\n # Group the training set by the fold attribute as given by the dataset\\n trainingForFinal = training\\n training = training.groupby('fold')\\n\\n # Since we want to consider odd k-values from 1 to 39, construct a list with these values\\n kList = []\\n for i in range(40):\\n if i % 2 == 1:\\n kList.append(i)\\n\\n # Empty dictionary to hold performance of each k-values and its accuracy\\n performance = {}\\n\\n # Compute the performance for each k-value\\n for k in kList:\\n performance = crossValidation(training, k, performance)\\n\\n # Sort the performance dictionary by its accuracy (value)\\n performance = sorted(performance.items(), key=operator.itemgetter(1), reverse=True)\\n\\n # Open file to write results\\n file = open('grid.results.txt', 'w')\\n # Write the results to file\\n file.write(\\\"K | Accuracy\\\\n\\\")\\n for item in performance:\\n if item[0] < 10:\\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\\\n')\\n else:\\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\\\n')\\n # Close file\\n file.close()\\n\\n # The best K is the one at the top of the list after the sorting\\n bestK = performance[0][0]\\n\\n print 'Running Test Set with K = ' + str(bestK)\\n\\n applyModel(test,trainingForFinal,bestK)\",\n \"def cross_validation(self, stock_data):\\n\\n self.X_train, self.X_test, self.y_train, self.y_test = cross_validation.train_test_split(stock_data['X'], stock_data['Y'], test_size=0.2, train_size=0.8, random_state=3)\",\n \"def validate_kfold(\\n x: ndarray,\\n y: ndarray,\\n x_sample_dim: int,\\n y_sample_dim: int,\\n n_splits: int,\\n stratify: bool,\\n models: List[Model],\\n generator: RandomGenerator,\\n save_fold_accs: bool,\\n) -> List[KFoldResults]:\\n # don't work with original arrays which may have sample index in strange location\\n length = int(x.shape[x_sample_dim])\\n idx = np.arange(0, length, dtype=int)\\n # convert to labels if we have a one-hot (will fail for dummy coding)\\n # y_split = np.argmax(y, axis=1 - int(np.abs(y_sample_dim))) if y.ndim == 2 else y\\n y_split = np.argmax(y, axis=1 - np.abs(y_sample_dim).astype(int)) if y.ndim == 2 else y\\n\\n # can't trust kfold shuffling in multiprocessing, shuffle ourselves\\n generator.shuffle(idx)\\n y_split = y_split[idx]\\n\\n kfolder = StratifiedKFold if stratify else KFold\\n kfold = kfolder(n_splits=n_splits, shuffle=False)\\n\\n results = []\\n for model, (train_idx, val_idx) in zip(models, kfold.split(idx, y_split)):\\n x_train = array_indexer(x, x_sample_dim, train_idx)\\n y_train = array_indexer(y, y_sample_dim, train_idx)\\n model.fit(x_train, y_train)\\n\\n acc = None\\n y_pred = None\\n if save_fold_accs:\\n x_val = array_indexer(x, x_sample_dim, val_idx)\\n y_val = array_indexer(y, y_sample_dim, val_idx)\\n y_pred = model.predict(x_val)\\n acc = 1 - np.mean(get_y_error(y_pred, y_val, y_sample_dim))\\n results.append(KFoldResults(model, acc, y_pred, val_idx))\\n\\n return results\",\n \"def _do_training_cross_validation(self) -> None:\\n\\n cfg = self.cfg_\\n fit_kwargs = {'classes': list(self.data_.classes)}\\n\\n # Store all of the samples used during cross-validation\\n self.y_training_set_all_ = list(self._generate_samples(self.train_ids_, 'y'))\\n\\n # Initialize learner objects with the optimal set of parameters\\n # learned from the grid search round (one for each\\n # sub-experiment of the cross-validation round)\\n for learner, learner_name in zip(self.learners_, self.learner_names_):\\n self.cv_learners_[learner_name] = \\\\\\n [learner(**self.learner_gs_cv_params_[learner_name])\\n for i in range(len(self.data_.training_set))]\\n\\n # Make a list of empty lists corresponding to each estimator\\n # instance for each learner, which will be used to store the\\n # performance metrics for each cross-validation\\n # leave-one-fold-out sub-experiment\\n self.cv_learner_stats_ = [[] for _ in cfg.learners]\\n\\n # Fit the `SelectPercentile` feature selector (if applicable)\\n if cfg.feature_selection_percentile != 1.0:\\n loginfo('Removing {0}% of the features during training round...'\\n .format(100 - 100*cfg.feature_selection_percentile))\\n feature_selector = \\\\\\n (SelectPercentile(chi2,\\n percentile=100*cfg.feature_selection_percentile)\\n .fit(self._vectorize_and_sparsify_data(self.training_vec_,\\n self.train_ids_),\\n self.y_training_set_all_))\\n\\n # For each fold of the training set, train on all of the other\\n # folds and evaluate on the one left out fold\\n for i, held_out_fold in enumerate(self.data_.training_set):\\n\\n loginfo('Cross-validation sub-experiment #{0} in progress'\\n .format(i + 1))\\n\\n # Use each training fold (except for the held-out set) to\\n # incrementally build up the model\\n training_folds = (self.data_.training_set[:i]\\n + self.data_.training_set[i + 1:])\\n y_train_all = []\\n for j, training_fold in enumerate(training_folds):\\n\\n # Get the training data\\n y_train = list(self._generate_samples(training_fold, 'y'))\\n y_train_all.extend(y_train)\\n X_train = self._vectorize_and_sparsify_data(self.training_vec_,\\n training_fold)\\n if cfg.feature_selection_percentile != 1.0:\\n X_train = feature_selector.transform(X_train)\\n\\n # Iterate over the learners\\n for learner_name in self.learner_names_:\\n\\n # Partially fit each estimator with the new training\\n # data (specifying the `classes` keyword argument if\\n # this is the first go-round and it's a learner that\\n # requires this to be specified initially)\\n (self.cv_learners_[learner_name][i]\\n .partial_fit(X_train,\\n y_train,\\n **fit_kwargs if not j and learner_name\\n in self.requires_classes_kwarg_\\n else {}))\\n\\n # Get mean and standard deviation for actual values\\n y_train_all = np.array(y_train_all)\\n y_train_mean = y_train_all.mean()\\n y_train_std = y_train_all.std()\\n\\n # Get test data\\n y_test = list(self._generate_samples(held_out_fold, 'y'))\\n X_test = self._vectorize_and_sparsify_data(self.training_vec_,\\n held_out_fold)\\n if cfg.feature_selection_percentile != 1.0:\\n X_test = feature_selector.transform(X_test)\\n\\n # Make predictions with the modified estimators\\n for j, learner_name in enumerate(self.learner_names_):\\n\\n # Make predictions with the given estimator,rounding the\\n # predictions\\n y_test_preds = \\\\\\n np.round(self.cv_learners_[learner_name][i].predict(X_test))\\n\\n # Rescale the predicted values based on the\\n # mean/standard deviation of the actual values and\\n # fit the predicted values within the original scale\\n # (i.e., no predicted values should be outside the range\\n # of possible values)\\n y_test_preds_dict = \\\\\\n ex.rescale_preds_and_fit_in_scale(y_test_preds,\\n self.data_.classes,\\n y_train_mean,\\n y_train_std)\\n\\n if cfg.rescale:\\n y_test_preds = y_test_preds_dict['rescaled']\\n else:\\n y_test_preds = y_test_preds_dict['fitted_only']\\n\\n # Evaluate the predictions and add to list of evaluation\\n # reports for each learner\\n (self.cv_learner_stats_[j]\\n .append(ex.evaluate_predictions_from_learning_round(\\n y_test=y_test,\\n y_test_preds=y_test_preds,\\n classes=self.data_.classes,\\n prediction_label=cfg.prediction_label,\\n non_nlp_features=cfg.non_nlp_features,\\n nlp_features=cfg.nlp_features,\\n learner=self.cv_learners_[learner_name][i],\\n learner_name=learner_name,\\n games=cfg.games,\\n test_games=cfg.games,\\n _round=i + 1,\\n iteration_rounds=self.data_.folds,\\n n_train_samples=len(y_train_all),\\n n_test_samples=len(held_out_fold),\\n rescaled=cfg.rescale,\\n transformation_string=self.transformation_string_,\\n bin_ranges=cfg.bin_ranges)))\",\n \"def cv_multiclass_fold(Y,num_fold=10):\\n\\t\\n (K,N) = Y.shape\\n indices = dict()\\n Nk = dict()\\n for k in range(K):\\n # select indices belonging to class k\\n indices[k] = list((Y[k,:]==1).nonzero()[0])\\n rand.shuffle(indices[k])\\n Nk[k] = len(indices[k])/num_fold\\n\\t\\n index_list = []\\n\\n for k in range(K):\\n for i in range(num_fold-1):\\n # split class-k indices into num_fold random sets\\n try:\\n index_list[i].extend(indices[k][Nk[k]*i:Nk[k]*(i+1)])\\n except IndexError:\\n index_list.append([])\\n index_list[i].extend(indices[k][Nk[k]*i:Nk[k]*(i+1)])\\n try:\\n index_list[num_fold-1].extend(indices[k][Nk[k]*(num_fold-1):])\\n except IndexError:\\n index_list.append([])\\n index_list[num_fold-1].extend(indices[k][Nk[k]*(num_fold-1):])\\n\\n return index_list\",\n \"def Kfold_LR(X, y, n, rs=None):\\n scoring_metrics = ['neg_mean_absolute_error',\\n 'neg_mean_squared_error',\\n 'neg_root_mean_squared_error',\\n 'r2']\\n lr = LinearRegression()\\n # kf = KFold(n_splits=n, shuffle=True, random_state=rs)\\n tss2 = TimeSeriesSplit(n_splits=n)\\n result = cross_validate(lr, X, y, cv=tss2, scoring=scoring_metrics,\\n return_train_score=True, return_estimator=True)\\n return pd.DataFrame(result), result['estimator'][-1]\",\n \"def makeFolds(data, k):\\r\\n # randomize columns\\r\\n order = data.columns.tolist()\\r\\n random.shuffle(order)\\r\\n # split into folds (specified by k)\\r\\n folds = []\\r\\n fold = 0\\r\\n dist = len(order) / k\\r\\n while fold < k:\\r\\n start = int(round(fold * dist))\\r\\n end = int(round(start + dist))\\r\\n folds.append(order[start:end])\\r\\n fold = fold + 1\\r\\n return folds\",\n \"def cross_validation(y, x, k_indices, k, initial_w, model_name, max_iters=0, gamma=0, lambda_=0):\\n # get k'th subgroup in test, others in train\\n test_idx = k_indices[k]\\n idx_tr = np.arange(len(k_indices))\\n train_idx = k_indices[idx_tr != k]\\n train_idx = train_idx.flatten()\\n\\n # form data with polynomial degree\\n #x_tr = build_poly(x[train_idx], degree)\\n #x_te = build_poly(x[test_idx], degree)\\n x_tr = x[train_idx]\\n x_te = x[test_idx]\\n y_tr = y[train_idx]\\n y_te = y[test_idx]\\n\\n # applying the model \\n #initial_w = np.zeros(x_tr.shape[1])\\n if(model_name == 'least_squares_GD'):\\n w_star, mse = least_squares_GD(y_tr, x_tr, initial_w, max_iters, gamma)\\n elif(model_name == 'least_squares_SGD'):\\n w_star, mse = least_squares_SGD(y_tr, x_tr, initial_w, max_iters, gamma)\\n elif(model_name == 'least_squares'):\\n w_star, mse = least_squares(y_tr, x_tr)\\n elif(model_name == 'ridge_regression'):\\n w_star, mse = ridge_regression(y_tr, x_tr, lambda_)\\n elif(model_name == 'logistic_regression'):\\n w_star, mse = logistic_regression(y_tr, x_tr, initial_w, max_iters, gamma)\\n elif(model_name == 'reg_logistic_regression'):\\n w_star, mse = reg_logistic_regression(y_tr, x_tr, lambda_, initial_w, max_iters, gamma)\\n \\n\\n # calculate the loss for train and test data\\n if(model_name == 'logistic_regression' or model_name == 'reg_logistic_regression'):\\n #loss_tr = compute_loss_LG(y_tr, x_tr, w_star)\\n y_te_ = (1+y_te)/2\\n loss_te = compute_loss_LG(y_te_, x_te, w_star)\\n #print(loss_te)\\n mod_pred = predict_labels(w_star, x_te, logistic = True)\\n #mod_pred = (1+mod_pred)/2\\n acc = calculate_accuracy(mod_pred, y_te)\\n else:\\n #loss_tr = compute_loss_MSE(y_tr, x_tr, w_star)\\n loss_te = compute_loss_MSE(y_te, x_te, w_star)\\n mod_pred = predict_labels(w_star, x_te)\\n acc = calculate_accuracy(mod_pred, y_te)\\n\\n return acc, loss_te\",\n \"def cv_5_fold(dataFrame):\\n dataframe_collection = {}\\n i = 0\\n j = 0\\n l = 0\\n guessed_right = 0\\n k = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39]\\n\\n k_values = []\\n # array to store the accuracy evaluation for each number of K\\n accuracy_values = {}\\n\\n myDict = {}\\n for j in range(len(k)): # for all values of K neighbour\\n\\n print(k[j])\\n predicted_right = 0\\n total_number = 0\\n five_accuracies = []\\n for i in range(0, 5):\\n #aggregating dataframes by fold - e.g. 1 fold becomes test dataframe; 2,3,4,5 folds become one training dataframe\\n trainingDataFrame = dataFrame.loc[dataFrame[15] != (i / 4.00)]\\n trainingDataFrame = trainingDataFrame.drop([15], axis=1).reset_index(drop=True)\\n testDataFrame = dataFrame.loc[dataFrame[15] == (i / 4.00)]\\n testDataFrame = testDataFrame.drop([15], axis=1).reset_index(drop=True)\\n\\n # output is an array of predicted income values for testDataFrame\\n output = knn(trainingDataFrame, testDataFrame, k[j])\\n\\n # for every fold validation loop calculate the accuracy:\\n for instance in range(len(testDataFrame)):\\n # checking number of right predictions\\n if (output[instance] == testDataFrame[14].iloc[instance]):\\n predicted_right += 1.00\\n total_number += 1.00\\n\\n # calculate accuracy as percentage of number of prediction divided by total\\n accuracy = (predicted_right / total_number) * 100.0\\n # add acccuracies for each of the 5 fold tests to an array\\n five_accuracies.append(accuracy)\\n\\n # PROVIDE FINAL EVALUATION FOR K = J, BY FINDING OUT AVERAGE ACCURACY OF THE FIVE FOLD LOOPS:\\n evaluation = 0.0\\n for accuracy in range(len(five_accuracies)):\\n evaluation += five_accuracies[accuracy]\\n\\n evaluation = evaluation / 5\\n\\n accuracy_values.update({k[j]: evaluation})\\n\\n accuracy_values = collections.OrderedDict(sorted(accuracy_values.items()))\\n\\n # compute which number of neigbors garners greatest accuracy:\\n maxAccuracy = 0\\n best_neighbour = 0\\n # loop through dictionary values:\\n for v in accuracy_values.items():\\n # if the value is greater than the current maximum, make it the maximum\\n if (v[1] > maxAccuracy):\\n maxAccuracy = v[1]\\n best_neighbour = v[0]\\n\\n print(\\\"Max accuracy \\\", maxAccuracy)\\n print(\\\"Best Neighbor: \\\", best_neighbour)\\n\\n # make a text file containing the K-number and associated accuracy:\\n str_x = \\\"k value | accuracy\\\" + \\\"\\\\n\\\"\\n for k, v in accuracy_values.items():\\n str_x += str(k) + \\\" | \\\" + str(v) + \\\"\\\\n\\\"\\n print(str_x)\\n\\n text_file = open(\\\"grid.results.txt\\\", 'w')\\n text_file.write(str_x)\\n text_file.close()\",\n \"def get_folds(X, y, k):\\n # temporarily change the 1/-1 nature of y to 1/0\\n _y = (y + 1) / 2\\n # partition the examples into postive and negative sets\\n positive_indices = np.where(_y)[0]\\n negative_indices = np.where(_y - 1)[0]\\n assert len(positive_indices) + len(negative_indices) == len(y)\\n\\n # shuffle both lists\\n np.random.shuffle(positive_indices)\\n np.random.shuffle(negative_indices)\\n\\n # create k buckets of indices of (approximately) equal size\\n positive_folds_indices = \\\\\\n np.array(np.array_split(positive_indices, k))\\n negative_folds_indices = \\\\\\n np.array(np.array_split(negative_indices, k))\\n\\n train_X, train_y, test_X, test_y = [], [], [], []\\n for i in range(k):\\n train_folds = np.concatenate((np.arange(0, i), np.arange(i+1, k)))\\n pos_train_indices = np.concatenate(positive_folds_indices[train_folds])\\n neg_train_indices = np.concatenate(negative_folds_indices[train_folds])\\n pos_test_indices = positive_folds_indices[i]\\n neg_test_indices = negative_folds_indices[i]\\n\\n train_X.append(\\n np.concatenate((X[pos_train_indices], X[neg_train_indices]))\\n )\\n train_y.append(\\n np.concatenate((y[pos_train_indices], y[neg_train_indices]))\\n )\\n test_X.append(\\n np.concatenate((X[pos_test_indices], X[neg_test_indices]))\\n )\\n test_y.append(\\n np.concatenate((y[pos_test_indices], y[neg_test_indices]))\\n )\\n\\n return zip(train_X, train_y, test_X, test_y)\",\n \"def split_label_for_crossValidation(labels, k_fold = 3):\\n\\ttest_labels = []\\n\\ttest_num = len(labels) / k_fold\\n\\n\\tfor i in range(test_num):\\n\\t\\ttest_labels.append(labels.pop(random.randint(0,len(labels) - 1)))\\n\\n\\tvalid_labels = labels\\n\\n\\treturn (test_labels, valid_labels)\",\n \"def cross_validate(self, X, y):\\n roc_ap = []\\n kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=0)\\n for train_ix, test_ix in kfold.split(X, y):\\n train_X, test_X = X.iloc[train_ix, :], X.iloc[test_ix, :]\\n train_y, test_y = y[train_ix], y[test_ix]\\n self.train(train_X, train_y)\\n roc_ap.append(self.test(test_X, test_y))\\n return roc_ap\",\n \"def __init__(self, splits):\\n\\t\\tself.kfold = StratifiedKFold(splits)\",\n \"def cross_validate(self, curr_dataset, num_folds, max_depth, min_samples_per_node,\\n is_stratified=True, print_tree=False, seed=None, print_samples=False,\\n use_stop_conditions=False, max_p_value_chi_sq=0.1):\\n classifications = [0] * curr_dataset.num_samples\\n num_correct_classifications = 0\\n num_correct_classifications_wo_unkown = 0\\n total_cost = 0.0\\n total_cost_wo_unkown = 0.0\\n classified_with_unkown_value_array = [False] * curr_dataset.num_samples\\n num_unkown = 0\\n unkown_value_attrib_index_array = [0] * curr_dataset.num_samples\\n max_depth_per_fold = []\\n num_nodes_per_fold = []\\n num_valid_nominal_attributes_in_root_per_fold = []\\n num_values_root_attribute_list = []\\n num_trivial_splits = 0\\n time_taken_pruning_per_fold = []\\n num_nodes_pruned_per_fold = []\\n num_correct_trivial_classifications = 0\\n\\n fold_count = 0\\n\\n sample_indices_and_classes = list(enumerate(curr_dataset.sample_class))\\n if seed is not None:\\n random.seed(seed)\\n np.random.seed(seed)\\n random.shuffle(sample_indices_and_classes)\\n shuffled_sample_indices, shuffled_sample_classes = zip(*sample_indices_and_classes)\\n\\n if is_stratified:\\n for (training_randomized_indices,\\n validation_randomized_indices) in StratifiedKFold(n_splits=num_folds).split(\\n shuffled_sample_indices,\\n shuffled_sample_classes):\\n\\n training_samples_indices = [shuffled_sample_indices[index]\\n for index in training_randomized_indices]\\n validation_sample_indices = [shuffled_sample_indices[index]\\n for index in validation_randomized_indices]\\n\\n if print_samples:\\n print('Samples used for validation in this fold:')\\n print(validation_sample_indices)\\n print()\\n\\n ((curr_classifications,\\n curr_num_correct_classifications,\\n curr_num_correct_classifications_wo_unkown,\\n curr_total_cost,\\n curr_total_cost_wo_unkown,\\n curr_classified_with_unkown_value_array,\\n curr_num_unkown,\\n curr_unkown_value_attrib_index_array),\\n curr_max_depth,\\n curr_time_taken_pruning,\\n curr_num_nodes_pruned) = self.train_and_test(curr_dataset,\\n training_samples_indices,\\n validation_sample_indices,\\n max_depth,\\n min_samples_per_node,\\n use_stop_conditions,\\n max_p_value_chi_sq)\\n max_depth_per_fold.append(curr_max_depth)\\n num_nodes_per_fold.append(self.get_root_node().get_num_nodes())\\n num_valid_nominal_attributes_in_root_per_fold.append(\\n sum(self._root_node.valid_nominal_attribute))\\n try:\\n root_node_split_attrib = self.get_root_node().node_split.separation_attrib_index\\n if curr_dataset.valid_nominal_attribute[root_node_split_attrib]:\\n num_values_root_attribute_list.append(sum(\\n num_samples > 0\\n for num_samples in self.get_root_node().contingency_tables[\\n root_node_split_attrib].values_num_samples))\\n except AttributeError:\\n num_trivial_splits += 1\\n for curr_index, validation_sample_index in enumerate(validation_sample_indices):\\n classifications[validation_sample_index] = curr_classifications[curr_index]\\n classified_with_unkown_value_array[validation_sample_index] = (\\n curr_classified_with_unkown_value_array[curr_index])\\n unkown_value_attrib_index_array[validation_sample_index] = (\\n curr_unkown_value_attrib_index_array[curr_index])\\n num_correct_classifications += curr_num_correct_classifications\\n num_correct_classifications_wo_unkown += curr_num_correct_classifications_wo_unkown\\n total_cost += curr_total_cost\\n total_cost_wo_unkown += curr_total_cost_wo_unkown\\n num_unkown += curr_num_unkown\\n num_correct_trivial_classifications += round(\\n len(validation_sample_indices) *\\n (self.get_trivial_accuracy(validation_sample_indices) / 100.0))\\n\\n fold_count += 1\\n time_taken_pruning_per_fold.append(curr_time_taken_pruning)\\n num_nodes_pruned_per_fold.append(curr_num_nodes_pruned)\\n\\n if print_tree:\\n print()\\n print('-' * 50)\\n print('Fold:', fold_count)\\n self.save_tree()\\n else:\\n for (training_samples_indices,\\n validation_sample_indices) in KFold(n_splits=num_folds).split(\\n shuffled_sample_indices):\\n\\n ((curr_classifications,\\n curr_num_correct_classifications,\\n curr_num_correct_classifications_wo_unkown,\\n curr_total_cost,\\n curr_total_cost_wo_unkown,\\n curr_classified_with_unkown_value_array,\\n curr_num_unkown,\\n curr_unkown_value_attrib_index_array),\\n curr_max_depth,\\n curr_time_taken_pruning,\\n curr_num_nodes_pruned) = self.train_and_test(curr_dataset,\\n training_samples_indices,\\n validation_sample_indices,\\n max_depth,\\n min_samples_per_node,\\n use_stop_conditions,\\n max_p_value_chi_sq)\\n max_depth_per_fold.append(curr_max_depth)\\n num_nodes_per_fold.append(self.get_root_node().get_num_nodes())\\n num_valid_nominal_attributes_in_root_per_fold.append(\\n sum(self._root_node.valid_nominal_attribute))\\n try:\\n root_node_split_attrib = self.get_root_node().node_split.separation_attrib_index\\n if curr_dataset.valid_nominal_attribute[root_node_split_attrib]:\\n num_values_root_attribute_list.append(sum(\\n num_samples > 0\\n for num_samples in self.get_root_node().contingency_tables[\\n root_node_split_attrib].values_num_samples))\\n except AttributeError:\\n num_trivial_splits += 1\\n for curr_index, validation_sample_index in enumerate(validation_sample_indices):\\n classifications[validation_sample_index] = curr_classifications[curr_index]\\n classified_with_unkown_value_array[validation_sample_index] = (\\n curr_classified_with_unkown_value_array[curr_index])\\n unkown_value_attrib_index_array[validation_sample_index] = (\\n curr_unkown_value_attrib_index_array[curr_index])\\n num_correct_classifications += curr_num_correct_classifications\\n num_correct_classifications_wo_unkown += curr_num_correct_classifications_wo_unkown\\n total_cost += curr_total_cost\\n total_cost_wo_unkown += curr_total_cost_wo_unkown\\n num_unkown += curr_num_unkown\\n num_correct_trivial_classifications += round(\\n len(validation_sample_indices) *\\n (self.get_trivial_accuracy(validation_sample_indices) / 100.0))\\n\\n fold_count += 1\\n time_taken_pruning_per_fold.append(curr_time_taken_pruning)\\n num_nodes_pruned_per_fold.append(curr_num_nodes_pruned)\\n\\n if print_tree:\\n print()\\n print('-' * 50)\\n print('Fold:', fold_count)\\n self.save_tree()\\n\\n return (classifications,\\n num_correct_classifications,\\n num_correct_classifications_wo_unkown,\\n total_cost,\\n total_cost_wo_unkown,\\n classified_with_unkown_value_array,\\n num_unkown,\\n unkown_value_attrib_index_array,\\n time_taken_pruning_per_fold,\\n num_nodes_pruned_per_fold,\\n max_depth_per_fold,\\n num_nodes_per_fold,\\n num_valid_nominal_attributes_in_root_per_fold,\\n num_values_root_attribute_list,\\n num_trivial_splits,\\n 100.0 * num_correct_trivial_classifications / curr_dataset.num_samples)\",\n \"def kfold_scoring(self, data_frame, target, pipeline):\\n\\n fold_score = []\\n macro = ['recall', 'f1', 'precision']\\n number_of_folds = -1\\n Folds = {}\\n\\n kf = KFold(n_splits=10, random_state=None, shuffle=True)\\n\\n for train_index, test_index in kf.split(data_frame):\\n X_train = data_frame[train_index]\\n X_test = data_frame[test_index]\\n y_train = target[train_index]\\n y_test = target[test_index]\\n number_of_folds = number_of_folds + 1\\n # Append the predicted labels.\\n y_predict = self.fit_predict_model(X_train, y_train, X_test, pipeline)\\n\\n Folds[str(number_of_folds)] = {\\n \\\"predicted\\\": y_predict,\\n \\\"Actual\\\": y_test\\n }\\n\\n if self.problem_type == 'regression':\\n if self.scoring is not None:\\n result = self.regression_scoring_function[self.scoring](y_predict, y_test)\\n else:\\n result = self.regression_scoring_function['r2_score'](y_predict, y_test)\\n else:\\n if self.scoring is not None:\\n if self.scoring not in macro:\\n result = self.classification_scoring_function[self.scoring](\\n y_predict, y_test)\\n else:\\n result = self.classification_scoring_function[self.scoring](\\n y_predict, y_test, average='macro')\\n else:\\n result = self.classification_scoring_function['f1'](\\n y_predict, y_test, average='macro')\\n\\n fold_score.append(result)\\n self.pipeline_dict['folds'] = Folds\\n return np.mean(fold_score)\",\n \"def cross_validation(self, x, t):\\n # Initialize accuracy / hyperparameters\\n best_accuracy = 0.0\\n best_reg = 0.0\\n\\n # Cross-validation 80-20\\n N = x.shape[0]\\n N_train = int(math.floor(0.8 * N))\\n\\n # Initialize the grid search hyperparameters\\n min_reg = 0.001\\n max_reg = 1000\\n log_min_reg = np.log(min_reg)\\n log_max_reg = np.log(max_reg)\\n reg_list = np.logspace(log_min_reg, log_max_reg, num=7, base=math.e)\\n\\n for reg in reg_list:\\n accuracy = np.zeros((self.k_fold))\\n for i in range(self.k_fold):\\n map_index = list(zip(x, t))\\n random.shuffle(map_index)\\n random_x, random_t = zip(*map_index)\\n\\n train_x = random_x[:N_train]\\n valid_x = random_x[N_train:]\\n train_t = random_t[:N_train]\\n valid_t = random_t[N_train:]\\n\\n self.model = sklearn.neural_network.MLPClassifier(self.hidden_layer_sizes,\\n activation=self.activation,\\n alpha=reg, max_iter=1000, \\n random_state=self.random_state)\\n self.train(train_x, train_t)\\n accuracy[i] = self.model.score(valid_x, valid_t)\\n\\n mean_accuracy = np.mean(accuracy)\\n # print(mean_accuracy)\\n if mean_accuracy > best_accuracy:\\n best_accuracy = mean_accuracy\\n best_reg = reg\\n print(\\\"The new best hyperparameters are : \\\", best_reg)\\n\\n print(\\\"Best hyperparameters are : \\\", best_reg)\\n print(\\\"Valid Accuracy :\\\", best_accuracy)\\n self.reg = best_reg\\n self.model = sklearn.neural_network.MLPClassifier(self.hidden_layer_sizes,\\n activation=self.activation,\\n alpha=best_reg, max_iter=1000, \\n random_state=self.random_state)\\n self.train(x, t)\",\n \"def cross_validation(y, x, k_indices, k, lambda_, degree):\\n # ***************************************************\\n # INSERT YOUR CODE HERE\\n # get k'th subgroup in test, others in train: TODO\\n # ***************************************************\\n all_indices = np.arange(y.shape[0])\\n excepted = np.setdiff1d(all_indices,k_indices[k])\\n x_test = x[k_indices[k]]\\n y_test = y[k_indices[k]]\\n x_train = x[excepted]\\n y_train = y[excepted]\\n # ***************************************************\\n # INSERT YOUR CODE HERE\\n # form data with polynomial degree: TODO\\n # ***************************************************\\n x_train_extended = build_poly(x_train, degree)\\n #print(x_train_extended.shape)\\n x_test_extended = build_poly(x_test, degree)\\n #print(x_test_extended.shape)\\n # ***************************************************\\n # INSERT YOUR CODE HERE\\n # ridge regression: TODO\\n # ***************************************************\\n loss_tr,w_tr = ridge_regression(y_train,x_train_extended,lambda_)\\n #print(\\\"One new regression\\\")\\n #print(w_tr)\\n loss_te = compute_loss(y_test,x_test_extended,w_tr)\\n # ***************************************************\\n # INSERT YOUR CODE HERE\\n # calculate the loss for train and test data: TODO\\n # ***************************************************\\n return loss_tr, loss_te\",\n \"def cross_validate_model(self, X_train, y_train):\\n\\n\\t\\t# Build a stratified k-fold cross-validator object\\n\\t\\tskf = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)\\n\\n\\t\\t'''\\n\\t\\tEvaluate the score by cross-validation\\n\\t\\tThis fits the classification model on the training data, according to the cross-validator\\n\\t\\tand reports the scores.\\n\\t\\tAlternative: sklearn.model_selection.cross_validate\\n\\t\\t'''\\n\\t\\tscores = cross_val_score(self.classifier, X_train, y_train, scoring='accuracy', cv=skf)\\n\\n\\t\\tprint(\\\"%.2f seconds: Cross-validation finished\\\" % time.process_time())\\n\\n\\t\\t# Log the cross-validation scores, the mean score and the 95% confidence interval, according to:\\n\\t\\t# http://scikit-learn.org/stable/modules/cross_validation.html#computing-cross-validated-metrics\\n\\t\\t# https://en.wikipedia.org/wiki/Standard_error#Assumptions_and_usage\\n\\t\\t# print(\\\"Scores = %s\\\" % scores)\\n\\t\\t# print(\\\"Accuracy: %0.2f (±%0.2f)\\\" % (scores.mean()*100, scores.std()*2*100))\\n\\t\\t# ↳ https://docs.scipy.org/doc/numpy/reference/generated/numpy.std.html\",\n \"def cross_validation_step_sgd(ratings, k_fold=4, gamma=0.01, num_features=25,\\n lambda_user=0.1, lambda_item=0.7, num_epochs=20, verbose=False):\\n tr_errors = []\\n te_errors = []\\n folds = k_fold_split(ratings, k=k_fold)\\n for fold in range(k_fold):\\n print('Fold {}/{}'.format(fold+1, k_fold))\\n train, test = split_matrix(ratings, folds[fold])\\n train_rmse, test_rmse, _, _ = matrix_factorization_sgd(train, test, gamma=gamma, num_features=num_features,\\n lambda_user=lambda_user, lambda_item=lambda_item,\\n num_epochs=num_epochs, verbose=verbose)\\n tr_errors.append(train_rmse)\\n te_errors.append(test_rmse)\\n return np.mean(tr_errors), np.mean(te_errors)\",\n \"def cross_validation(y, x, k_indices, k, lambda_):\\n\\n # get k'th subgroup in test, others in train\\n te_indice = k_indices[k]\\n x_te = x[te_indice]\\n y_te = y[te_indice]\\n\\n tr_indice = k_indices[~(np.arange(k_indices.shape[0]) == k)]\\n tr_indice = tr_indice.reshape(-1)\\n x_tr = x[tr_indice]\\n y_tr = y[tr_indice]\\n\\n score_table = []\\n\\n # ridge regression\\n #print('Ridge inside cross val started')\\n weights, loss = ridge_regression(y_tr, x_tr, lambda_)\\n\\n y_te_predict = predict_labels(weights, x_te)\\n score = (y_te_predict == y_te).mean()\\n score_table.append(score)\\n\\n # calculate the loss for train and test data\\n e_tr = y_tr - x_tr.dot(weights)\\n loss_tr = np.sqrt(2 * compute_mse(e_tr))\\n\\n e_te = y_te - x_te.dot(weights)\\n loss_te = np.sqrt(2 * compute_mse(e_te))\\n\\n return loss_tr, loss_te, np.array(score_table)\",\n \"def k_fold_linear(data: pd.DataFrame, algorithm, folds: int = 5) -> (float, float):\\n d = data.sample(frac=1)\\n segments = np.array_split(d, folds)\\n acc_test = []\\n\\n acc_train = []\\n for i in range(folds):\\n temp = segments.copy()\\n\\n test = temp.pop(i)\\n train = pd.concat(temp)\\n test_labels = list(test['Labels'])\\n train_labels = list(train['Labels'])\\n\\n model = algorithm(train)\\n test_predictions = [round(x, 1) for x in predict_linear_regression(test.drop(['Labels'], axis=1), model)]\\n train_predictions = [round(x, 1) for x in predict_linear_regression(train.drop(['Labels'], axis=1), model)]\\n\\n Confusion_Matrix(test_predictions, test_labels)\\n\\n acc_test.append(accuracy(test_predictions, test_labels))\\n acc_train.append(accuracy(train_predictions, train_labels))\\n\\n return avg(acc_train), avg(acc_test)\",\n \"def n_fold_cross_validation(examples, num_folds=5):\\n random.shuffle(examples, random.seed(12345))\\n batches = [examples[i::num_folds] for i in range(num_folds)]\\n n_fold_sets = [\\n (\\n [example for flat in (batches[:i] + batches[i + 1 :]) for example in flat],\\n batch,\\n )\\n for i, batch in enumerate(batches)\\n ]\\n\\n return np.array(n_fold_sets)\",\n \"def k_fold_selection(self,training_dataframe, selected_column, ignored_columns):\\n \\n # getting all the outcomes (i.e. from the selected column)\\n outcomes = training_dataframe[selected_column].factorize()[0]\\n # remove selected column from dataframe\\n training_dataframe.drop(selected_column, axis=1, inplace=True)\\n \\n # remove all 'ignored columns' from dataframe\\n ignored_columns = ast.literal_eval(ignored_columns)\\n for column in ignored_columns:\\n training_dataframe.drop(column, axis=1, inplace=True)\\n \\n column_states = {}\\n # factorize the columns and store the state names of each feature as a dict\\n for column in training_dataframe.columns:\\n factorized_column = training_dataframe[column].factorize()\\n training_dataframe[column] = factorized_column[0]\\n column_states[column] = factorized_column[1].tolist()\\n \\n # intialize the k-fold cross validation object\\n kf = KFold(len(outcomes), n_folds=10, shuffle=True, random_state=14)\\n \\n for iter_id, item in enumerate(kf):\\n # for the first iteration, the classification model needs to be initialized at the end\\n if iter_id == 0:\\n # training segment\\n features_train = np.array([list(training_dataframe.ix[i]) for i in item[0]])\\n outcomes_train = np.array([outcomes[i] for i in item[0]])\\n \\n # evaluation segment\\n features_test = np.array([list(training_dataframe.ix[i]) for i in item[1]])\\n outcomes_test = np.array([outcomes[i] for i in item[1]])\\n \\n # create the classifier\\n best_clf = BernoulliNB()\\n best_clf.fit(features_train, outcomes_train)\\n best_accuracy = math.ceil((best_clf.score(features_test,outcomes_test, sample_weight=None)*100)*100)/100\\n continue\\n \\n # training segment\\n features_train = np.array([list(training_dataframe.ix[i]) for i in item[0]])\\n outcomes_train = np.array([outcomes[i] for i in item[0]])\\n \\n # evaluation segment\\n features_test = np.array([list(training_dataframe.ix[i]) for i in item[1]])\\n outcomes_test = np.array([outcomes[i] for i in item[1]])\\n \\n # create the classifier\\n clf = BernoulliNB()\\n clf.fit(features_train, outcomes_train)\\n accuracy = math.ceil((clf.score(features_test,outcomes_test,sample_weight=None)*100)*100)/100\\n \\n # hold the best model in best_clf\\n if accuracy > best_accuracy:\\n accuracy = best_accuracy\\n best_clf = clf\\n \\n return best_accuracy, best_clf, column_states, training_dataframe.columns.tolist()\",\n \"def cross_valid_key(model,x,key,preds,target,metric,verbose=True): \\r\\n\\r\\n score=[]\\r\\n \\r\\n keys = x[key].unique().tolist()\\r\\n \\r\\n\\r\\n\\r\\n for idx, item in enumerate([1,2,3,4,5]):\\r\\n\\r\\n xtrain,xtest = split_camp(x,keys,0.2)\\r\\n \\r\\n model.fit(xtrain[feat],xtrain[target])\\r\\n\\r\\n ypred = model.predict(xtest[feat])\\r\\n \\r\\n ytrue= xtest[target].values \\r\\n \\r\\n if metric == 'mae':\\r\\n score.append(mae(ytrue,ypred))\\r\\n elif metric == 'mse':\\r\\n score.append(mse(ytrue,ypred))\\r\\n elif metric == 'rrmse':\\r\\n score.append(rrmse(ytrue,ypred))\\r\\n\\r\\n else:\\r\\n score.append(rmse(xtest[target].tolist(),ypred))\\r\\n\\r\\n if verbose:\\r\\n print('-'*30)\\r\\n print(f'\\\\nFold {idx} out of 5')\\r\\n print(f'Key {item}')\\r\\n print(f'{metric}: {score[idx]}')\\r\\n\\r\\n \\r\\n\\r\\n if verbose:\\r\\n print(f'\\\\n Overall Score:')\\r\\n print(f'{metric}: Mean: {np.mean(score)} Std: {np.std(score)}')\\r\\n\\r\\n\\r\\n return score\",\n \"def cross_validate(data, k, distance_metric):\\n fraction_correct = 0.00\\n correctly_classified = 0\\n for i, test_data in enumerate(data):\\n training_data = []\\n for j in range(len(data)):\\n if j!=i:\\n training_data.append(data[j])\\n observed_classification = knn_classify_point(test_data, training_data, k, distance_metric)\\n actual_classification = test_data.classification\\n if observed_classification == actual_classification:\\n correctly_classified += 1\\n fraction_correct = float(correctly_classified/len(data))\\n return fraction_correct\",\n \"def crossValidation(data, output_variable_name):\\r\\n X, xt, y, yt = train_test_split(\\r\\n data.drop(output_variable_name, axis=1), data[output_variable_name], test_size=0.01, random_state=SEED)\\r\\n\\r\\n model = pickle.load(open(\\\"models/lasso.sav\\\", 'rb'))\\r\\n lassoCV = -mean(cross_val_score(model, X, y, cv=5, scoring='neg_root_mean_squared_error'))\\r\\n\\r\\n model = pickle.load(open(\\\"models/ridge.sav\\\", 'rb'))\\r\\n ridgeCV = -mean(cross_val_score(model, X, y, cv=5, scoring='neg_root_mean_squared_error'))\\r\\n\\r\\n model = pickle.load(open(\\\"models/decisionTree.sav\\\", 'rb'))\\r\\n decTreeCV = -mean(cross_val_score(model, X, y, cv=5, scoring='neg_root_mean_squared_error'))\\r\\n\\r\\n param = {\\r\\n 'max_depth': 15,\\r\\n 'eta': 0.1,\\r\\n 'objective': 'reg:squarederror',\\r\\n 'nthread': 16,\\r\\n \\\"subsample\\\": 0.5,\\r\\n \\\"colsample_bytree\\\": 0.5,\\r\\n 'eval_metric': 'rmse'\\r\\n }\\r\\n num_round = XGB_EPOCH_NR\\r\\n\\r\\n dtrain = xgb.DMatrix(X, label=y)\\r\\n xgbCV = xgb.cv(\\r\\n param,\\r\\n dtrain,\\r\\n num_boost_round=num_round,\\r\\n seed=SEED,\\r\\n nfold=5,\\r\\n metrics={'rmse'}\\r\\n )[\\\"test-rmse-mean\\\"][-1:]\\r\\n\\r\\n param = {\\r\\n \\\"iterations\\\": 400,\\r\\n \\\"learning_rate\\\": 0.02,\\r\\n \\\"depth\\\": 12,\\r\\n \\\"eval_metric\\\": 'RMSE',\\r\\n \\\"random_seed\\\": 23,\\r\\n \\\"bagging_temperature\\\": 0.2,\\r\\n \\\"od_type\\\": 'Iter',\\r\\n \\\"metric_period\\\": 75,\\r\\n \\\"od_wait\\\": 100\\r\\n }\\r\\n\\r\\n catBoostCV = cv(data, param, fold_count=5, plot=True)\\r\\n\\r\\n return lassoCV, ridgeCV, decTreeCV, xgbCV, catBoostCV\",\n \"def get_k_fold(examples, labels, k=10):\\n example_fold = []\\n label_fold = []\\n interval = int(len(examples)/k)\\n for i in range(k):\\n \\t#f_examples = [examples[j] for j in range(len(examples)) if j%k == i]\\n #f_labels = [labels[j] for j in range(len(labels)) if j%k == i]\\n f_examples = [examples[j] for j in range(interval*i,interval*(i+1))]\\n f_labels = [labels[j] for j in range(interval*i,interval*(i+1))]\\n example_fold.append(f_examples)\\n label_fold.append(f_labels)\\n return example_fold, label_fold\",\n \"def stratify_folds(labels, k):\\n\\n if k < 1:\\n raise ValueError('Number of folds, k, must be positive: {}'.format(k))\\n\\n # Split indices into k folds\\n skf_test_model = StratifiedKFold(shuffle=True, n_splits=k)\\n\\n skf_test = skf_test_model.split(np.zeros(len(labels)), labels)\\n skf_test = [skf_set[1] for skf_set in skf_test]\\n\\n for cv_set in range(k):\\n skf_test[cv_set] = np.expand_dims(skf_test[cv_set], axis=1)\\n skf_test[cv_set] = np.append(skf_test[cv_set], np.repeat(cv_set, skf_test[cv_set].shape[0]).T[:, np.newaxis],\\n axis=1)\\n\\n # Create one n x 2 array\\n # * where n is the number of samples\\n # * column 1 is the variant index\\n # * column 2 is the set the variant belongs to\\n\\n fold_array = np.concatenate(skf_test, axis=0)\\n\\n # Replace indices with label indices\\n fold_array[:, 0] = labels.index[fold_array[:, 0]]\\n\\n # Sort by variant index\\n fold_array = fold_array[fold_array[:, 0].argsort(), :]\\n\\n # Return array\\n return fold_array\",\n \"def cross_validate(self, train_size):\\n train, val, test_x, test_y = [], [], [], []\\n for country in self.countries:\\n tr, v, te_x, te_y = country.split_k_fold(train_size, self.horizon)\\n train.append(tr), val.append(v), test_x.append(te_x), test_y.append(te_y)\\n return np.stack(train), np.stack(val), np.stack(test_x), np.stack(test_y)\",\n \"def run_cross_validation_create_models(nfolds=10):\\n print(\\\"nfold value=\\\",nfolds)\\n x_train, y_train, x_train_id = load_images_train()\\n print(len(x_train))\\n\\n # input image dimensions\\n batch_size = 16\\n nb_epoch = 32\\n random_state = 159\\n\\n seed = 7\\n np.random.seed(seed)\\n kfold = StratifiedKFold(n_splits=nfolds, shuffle=True, random_state=random_state)\\n #kfold = StratifiedShuffleSplit(n_splits=nfolds,test_size=0.1,train_size=0.7,random_state=random_state)\\n cvscores = []\\n models = []\\n\\n image_array = np.asarray(x_train, dtype=np.float32)\\n # print(image_array.shape)\\n\\n datagen_test = ImageDataGenerator(\\n featurewise_center=True,\\n featurewise_std_normalization=True,\\n preprocessing_function=pre_processing_image\\n )\\n\\n datagen = ImageDataGenerator(\\n rotation_range=20,\\n width_shift_range=0.2,\\n height_shift_range=0.2,\\n shear_range=0.2,\\n zoom_range=0.2,\\n preprocessing_function=pre_processing_image,\\n vertical_flip=True,\\n horizontal_flip=True,\\n fill_mode='nearest'\\n )\\n\\n start_time = time.time()\\n print(\\\"Datagen.fit started\\\")\\n datagen.fit(image_array, augment=True, rounds=3)\\n print('Fit Completed: {} seconds'.format(round(time.time() - start_time, 2)))\\n\\n img_label = np_utils.to_categorical(y_train, 8)\\n\\n yfull_train = dict()\\n num_fold = 0\\n sum_score = 0\\n\\n for train_index, test_index in kfold.split(x_train, y_train):\\n # create model\\n model = create_model()\\n train_x = image_array[train_index]\\n train_y = img_label[train_index]\\n validate_x = image_array[test_index]\\n validate_y = img_label[test_index]\\n\\n num_fold += 1\\n print('Start KFold number {} from {}'.format(num_fold, nfolds))\\n print('Split train: ', len(train_x), len(train_y))\\n print('Split valid: ', len(validate_x), len(validate_y))\\n\\n callbacks = [EarlyStopping(monitor='val_loss', min_delta=0, patience=4, verbose=1, mode='auto')]\\n\\n model.fit_generator(generator=datagen.flow(train_x, train_y, batch_size=batch_size, shuffle=True),\\n steps_per_epoch=len(image_array)/32, epochs=nb_epoch, verbose=1,\\n callbacks=callbacks,validation_data=(validate_x,validate_y),\\n validation_steps=len(image_array)/32)\\n\\n predictions_valid = model.predict(validate_x.astype('float32'), batch_size=batch_size, verbose=1)\\n\\n\\n score = log_loss(validate_y, predictions_valid)\\n print('Score log_loss: ', score)\\n\\n\\n sum_score += score * len(test_index)\\n\\n # Store valid predictions\\n for i in range(len(test_index)):\\n yfull_train[test_index[i]] = predictions_valid[i]\\n\\n models.append(model)\\n\\n score = sum_score / len(x_train)\\n print(\\\"Log_loss train independent avg: \\\", score)\\n\\n info_string = 'loss_' + str(score) + '_folds_' + str(10) + '_ep_' + str(28)\\n return info_string,models\",\n \"def cross_validation_datasets(self, fold):\\n if fold > len(self): fold = len(self) / 2\\n stratified = self.stratified_bunches(fold)\\n datasets = []\\n for index in range(len(stratified)):\\n gold = GoldInstances(training_as_gold(stratified[index]))\\n rest = flatten(stratified[:index]) + flatten(stratified[index + 1:])\\n training = TrainingInstances(rest)\\n datasets.append((training, gold))\\n return datasets\",\n \"def nestedValidation(X, y, kernel):\\n\\n # list of slack variable values to test the SVM with\\n C_list = [0.001, 0.01, 0.1, 1.0, 10.0, 100.0, 1000.0]\\n # number of iterations to run the bootstraping\\n B = 30\\n\\n # split positive and negative valued samples\\n positive_samples = list(np.where(y==1)[0])\\n negative_samples = list(np.where(y==-1)[0])\\n\\n # randomize data for testing\\n np.random.shuffle(positive_samples)\\n np.random.shuffle(negative_samples)\\n\\n # split samples into two folds with similar proportion of positive:negative\\n samples_in_fold1 = positive_samples[:106] + negative_samples[:178]\\n samples_in_fold2 = positive_samples[106:] + negative_samples[178:]\\n\\n y_pred = np.zeros(len(X), int)\\n\\n # finding the best slack value and its corresponding error\\n best_err = 1.0\\n best_C = 0.0\\n\\n print(\\\"testing with first fold\\\")\\n for C in C_list:\\n err = bootstrapping(B, X[samples_in_fold1], y[samples_in_fold1], C, kernel)\\n print(\\\"C=\\\", C, \\\"err=\\\", err)\\n if (err <= best_err):\\n best_err = err\\n best_C = C\\n\\n print(\\\"Best C=\\\", best_C)\\n\\n alg = SVC(C=best_C, kernel=kernel)\\n alg.fit(X[samples_in_fold1], y[samples_in_fold1])\\n y_pred[samples_in_fold2] = alg.predict(X[samples_in_fold2])\\n\\n best_err = 1.1 # any value greater than 1.0\\n best_C = 0.0\\n\\n print(\\\"testing with second fold\\\")\\n for C in C_list:\\n err = bootstrapping(B, X[samples_in_fold2], y[samples_in_fold2], C, kernel)\\n print(\\\"C=\\\", C, \\\"err=\\\", err)\\n if (err <= best_err):\\n best_err = err\\n best_C = C\\n\\n print(\\\"Best C=\\\", best_C)\\n\\n alg = SVC(C=best_C, kernel=kernel)\\n alg.fit(X[samples_in_fold2], y[samples_in_fold2])\\n y_pred[samples_in_fold1] = alg.predict(X[samples_in_fold1])\\n\\n err = np.mean(y != y_pred)\\n\\n print(\\\"Nested Validation Error=\\\", err)\\n return err\",\n \"def cross_validate(X, Y, folds=5):\\n\\n log = LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\\n intercept_scaling=1, max_iter=200, multi_class='ovr', n_jobs=3,\\n penalty='l2', random_state=None, solver='liblinear', tol=0.0001,\\n verbose=0, warm_start=False)\\n \\n\\n \\n\\n\\n scores_log = [] \\n scores_forest = []\\n index = np.arange(X.shape[0])\\n score_log = 0\\n score_forest = 0\\n \\n for i in range(folds):\\n score_log = 0\\n score_forest = 0\\n \\n test_index = np.random.choice(index, int(X.shape[0]*1/folds),replace=False)\\n index = np.setdiff1d(np.arange(X.shape[0]),test_index)\\n \\n test_x = X[test_index]\\n test_y = Y[test_index]\\n\\n log.fit(X[index],Y[index])\\n pred_log = log.predict(test_x)\\n \\n ran.fit(X[index],Y[index])\\n pred_ran = ran.predict(test_x)\\n \\n for i in range(len(test_y)):\\n if(pred_log[i] == test_y[i]):\\n score_log += 1\\n if(pred_ran[i] == test_y[i]):\\n score_forest += 1\\n scores_log.append(score_log/len(test_y))\\n scores_forest.append(score_forest/len(test_y))\\n \\n\\n return (np.mean(scores_log),np.mean(scores_forest))\",\n \"def kfold_run(self, estimators):\\n model = self.model_build(estimators)\\n super().kfold_run(model)\",\n \"def cross_validation(feature_train, help_rank_train, model_name):\\n clf = svm.SVC(kernel='linear', C=1).fit(feature_train, help_rank_train)\\n clf_model = open(model_name,'wb')\\n dump(clf, clf_model, -1)\\n return\",\n \"def cross_validation_accuracy(clf, X, labels, k):\\n ###TODO\\n\\n cv = KFold(n=len(labels),n_folds=k)\\n accuracies = []\\n\\n \\n for train_indices, test_indices in cv:\\n \\n clf.fit(X[train_indices], labels[train_indices])\\n predicted = clf.predict(X[test_indices])\\n acc = accuracy_score(labels[test_indices], predicted)\\n accuracies.append(acc)\\n \\n #print('accuracies = ',accuracies) \\n #avg = np.mean(accuracies,dtype=np.float64)\\n return(np.mean(accuracies,dtype=np.float64))\",\n \"def cross_validate(pipeline, data, cv=4):\\n print \\\"Running cross validation...\\\"\\n (Xcv, ycv) = data\\n kfold = KFold(n_splits=cv, shuffle=True, random_state=42)\\n results = []\\n for train_idx, val_idx in kfold.split(Xtrain):\\n pipeline.fit(Xcv[train_idx], ycv[train_idx])\\n results.append(accuracy_score(\\n ycv[val_idx], pipeline.predict(Xcv[val_idx])\\n ))\\n print \\\"{} +/- {}\\\".format(np.mean(results), np.std(results))\",\n \"def cross_validation(feature_matrix, labels, k, flag = 0, T = 100):\\n (nsamples, nfeatures) = feature_matrix.shape\\n nlabels = len(labels)\\n subset_size = nsamples / k\\n percentages = []\\n\\n for i in xrange(k):\\n cross_feature_matrix = np.concatenate((feature_matrix[:i*subset_size], feature_matrix[(i+1)*subset_size:]))\\n cross_labels = np.concatenate((labels[:i*subset_size], labels[(i+1)*subset_size:]))\\n test_matrix = feature_matrix[i*subset_size:(i+1)*subset_size]\\n test_labels = labels[i*subset_size:(i+1)*subset_size]\\n\\n if flag == 0:\\n theta_vector, theta_0 = averager(cross_feature_matrix, cross_labels)\\n elif flag == 1:\\n theta_vector, theta_0 = train_perceptron(cross_feature_matrix, cross_labels)\\n elif flag == 2:\\n theta_vector, theta_0 = train_passive_agressive(cross_feature_matrix, cross_labels, T)\\n\\n label_output = perceptron_classify(test_matrix, theta_0, theta_vector)\\n\\n correct = 0\\n for i in xrange(0, len(label_output)):\\n if(label_output[i] == test_labels[i]):\\n correct = correct + 1\\n\\n percentages.append(100.0 * correct / len(label_output))\\n\\n return sum(percentages) / len(percentages)\",\n \"def fold_data(fold, datas):\\n training, validation = fold\\n folded = {}\\n\\n # fold Xtrain\\n if datas.get('Xtrain') is not None:\\n folded['Xtrain'] = datas['Xtrain'][training, :]\\n folded['Xtest'] = datas['Xtrain'][validation, :]\\n\\n # fold Ktrain\\n if datas.get('Ktrain') is not None:\\n folded['Ktrain'] = datas['Ktrain'][training, :][:, training]\\n folded['Ktest'] = datas['Ktrain'][validation, ][:, training]\\n # if datas.get('Ktest') is not None:\\n # folded['Ktest'] = datas['Ktest'][:, validation]\\n # else:\\n # folded['Ktest'] = folded['Xtest'].dot(folded['Xtrain'].T)\\n\\n # fold Ytrain\\n if datas.get('Ytrain') is not None:\\n folded['Ytrain'] = datas['Ytrain'][training, :]\\n folded['Ytest'] = datas['Ytrain'][validation, :]\\n\\n return folded\",\n \"def _cross_valid_feature(max_fold, num_movies, num_users, lamda, subplt):\\n loss_train_vector = [.0]*31\\n loss_cross_vector = [.0]*31\\n cost_train_per_fold = [.0]*max_fold\\n cost_cross_per_fold = [.0]*max_fold\\n for i in range(1, 31, 1):\\n for k in range(1, max_fold + 1, 1):\\n cost_train_per_fold[k-1], cost_cross_per_fold[k-1] = (\\n _cross_valid_fold(k, num_movies, num_users,\\n i, lamda))\\n loss_train_vector[i] = np.mean(cost_train_per_fold)\\n loss_cross_vector[i] = np.mean(cost_cross_per_fold)\\n\\n # draw the Loss v.s num_feature graph\\n subplt.plot(loss_train_vector, \\\"r\\\")\\n subplt.plot(loss_cross_vector, \\\"b\\\")\\n v1 = np.array(loss_cross_vector)\\n v2 = np.array(loss_train_vector)\\n v3 = v1 + v2\\n sel_feature = np.argmin(v3[1:]) + 1\\n subplt.plot(v3, \\\"g\\\", label=\\\"lambda=\\\"+str(lamda))\\n plt.axis([1, 30, 0, 1.2*max(v3)])\\n return sel_feature\",\n \"def choose_k ( \\n X,\\n y,\\n model_call,\\n param_grid,\\n scoring_func = accuracy,\\n cv = KFoldStratifiedCV ( number_of_folds = 3 ),\\n):\\n grid_search_cv = GridSearchCV (\\n model_callable = model_call,\\n param_grid = param_grid,\\n scoring_func = scoring_func,\\n cv_object = cv,\\n )\\n \\n # Get the last sorted value and take k from that values\\n return sorted ( list ( grid_search_cv.get_cv_scores ( X, y ) ), key = lambda x: x [ 1 ] ) [ -1 ][ 0 ][ \\\"k\\\" ]\\n # End choose_k()\",\n \"def cross_validation_accuracy(clf, X, labels, k):\\n abc = KFold(k, False)\\n answer = []\\n\\n for train_idx, test_idx in abc.split(X):\\n Xt, Xs = X[train_idx],X[test_idx]\\n tr, ts=labels[train_idx],labels[test_idx]\\n clf.fit(Xt,tr)\\n final_ans = clf.predict(Xs)\\n acc1 = accuracy_score(ts, final_ans)\\n answer.append(acc1)\\n\\n return np.mean(np.array(answer))\",\n \"def set_cross_validation(x,y):\\n\\tx_train_1 = x[50:]\\n\\ty_train_1 = y[50:]\\n\\tx_test_1 = x[:50]\\n\\ty_test_1 = y[:50]\\n\\tx_train_2 = np.concatenate((x[:50], x[100:]),axis=0)\\n\\ty_train_2 = np.concatenate((y[:50], y[100:]),axis=0)\\n\\tx_test_2 = x[50:100]\\n\\ty_test_2 = y[50:100]\\n\\tx_train_3 = np.concatenate((x[:100], x[150:]),axis=0)\\n\\ty_train_3 = np.concatenate((y[:100], y[150:]),axis=0)\\n\\tx_test_3 = x[100:150]\\n\\ty_test_3 = y[100:150]\\n\\tx_train_4 = x[:150]\\n\\ty_train_4 = y[:150]\\n\\tx_test_4 = x[150:]\\n\\ty_test_4 = y[150:]\\n\\n\\tx_train = [x_train_1,x_train_2,x_train_3,x_train_4]\\n\\ty_train = [y_train_1,y_train_2,y_train_3,y_train_4]\\n\\tx_test = [x_test_1,x_test_2,x_test_3,x_test_4]\\n\\ty_test = [y_test_1,y_test_2,y_test_3,y_test_4]\\n\\t# print 'cross val shapes', x_train.shape, y_train.shape, x_test.shape, y_test.shape\\n\\treturn x_train, y_train, x_test, y_test\",\n \"def train_and_test_k_fold(\\n ds, prd, k=10, comm=config.comm, online=False, classes=None, parallel_test=False,\\n cycles_per_barrier=10):\\n train_and_test = lambda tr, te: train_and_test_once(\\n tr, te, prd, comm=comm, online=online, classes=classes, parallel_test=parallel_test,\\n cycles_per_barrier=cycles_per_barrier)\\n\\n if k <= 0:\\n raise ValueError(\\\"k must be positive\\\")\\n elif k == 1:\\n splits = ds.split(10)\\n train = concatenate(splits[j] for j in range(9))\\n test = splits[9]\\n return train_and_test(train, test)\\n else:\\n r = null_training_result()\\n for train, test in get_k_fold_data(ds, k=k):\\n r += train_and_test(train, test)\\n comm.barrier()\\n\\n return r\",\n \"def choose_k ( \\n feature_matrix,\\n target_array,\\n model_call,\\n param_grid,\\n scoring_func = accuracy,\\n cv = KFoldStratifiedCV ( number_of_folds = 3 ),\\n):\\n grid_search_cv = GridSearchCV (\\n model_callable = model_call,\\n param_grid = param_grid,\\n scoring_func = scoring_func,\\n cv_object = cv,\\n )\\n \\n # Get the last sorted value and take k from that values\\n return sorted ( list ( grid_search_cv.get_cv_scores ( feature_matrix, target_array ) ), key = lambda x: x [ 1 ] ) [ -1 ][ 0 ][ \\\"k\\\" ]\\n # End choose_k()\",\n \"def _get_devset_cv(self, train_x, train_y, dev_x, dev_y, n_folds):\\n folds = []\\n n_train = len(train_y)\\n n_dev = len(dev_y)\\n dev_ids = [n_train + i for i in xrange(n_dev)]\\n # create stratified K-folds over the training data\\n skf = StratifiedKFold(n_splits=NFOLDS, shuffle=True)\\n for train_ids, test_ids in skf.split(train_x, train_y):\\n folds.append((train_ids,\\n np.concatenate((test_ids, dev_ids))))\\n train_x += dev_x\\n train_y += dev_y\\n return folds, train_x, train_y\",\n \"def cross_validate(all_tetrode_data, target, tetrode_ids, tetrode_units, verbose=True):\\n kf = StratifiedKFold(n_splits=10)\\n y_true = np.zeros(target.shape)\\n y_hat = np.zeros(target.shape)\\n i = 0\\n\\n for train_index, test_index in kf.split(np.zeros(target.shape[0]), target.argmax(axis=-1)):\\n X_train, X_test = select_data(all_tetrode_data, train_index), select_data(all_tetrode_data, test_index)\\n y_train, y_test = target[train_index, :], target[test_index, :]\\n\\n model = build_tetrode_model(tetrode_ids, tetrode_units)\\n checkpointer = ModelCheckpoint('temp_model.h5',\\n verbose=0, save_best_only=True)\\n hist = model.fit(X_train, y_train,\\n nb_epoch=200, batch_size=20,\\n validation_data=(X_test, y_test),\\n callbacks=[checkpointer], verbose=0)\\n best_model = load_model('temp_model.h5')\\n\\n n = y_test.shape[0]\\n y_true[i:(i + n), :] = y_test\\n y_hat[i:(i + n), :] = best_model.predict(X_test)\\n i += n\\n\\n if verbose:\\n accuracy = max(hist.history['val_acc'])\\n print('Current fold validation accuracy: {acc}'.format(acc=accuracy))\\n\\n return y_true, y_hat\",\n \"def train_cv(X_train, Y_train, nfold = 5, early_stopping_rounds = 20):\\n # model params\\n params = { \\\"objective\\\" : \\\"multiclass\\\",\\n \\\"num_class\\\" : 6,\\n \\\"verbosity\\\" : -1 }\\n\\n # create dataset for lightgbm\\n lgb_train = lgb.Dataset(X_train, Y_train)\\n \\n # cross validate to find optimal no of iterations\\n r = lgb.cv(params, \\n lgb_train, \\n 10000,\\n early_stopping_rounds = early_stopping_rounds,\\n nfold = nfold,\\n feval = accuracy_error,\\n metrics = 'None',\\n verbose_eval = True,\\n seed = 42)\\n\\n # Highest score\\n r_best = np.max(r['accuracy-mean'])\\n\\n # best number of estimators\\n best_estimators = np.argmax(r['accuracy-mean']) + 1\\n print(best_estimators)\\n\\n print(f'The maxium accuracy on the validation set was {r_best:.5f}')\\n print(f'The ideal number of iterations was {best_estimators}.')\\n\\n # Fit on all of the training data using the ideal number of iterations\\n model = lgb.LGBMClassifier(n_estimators=best_estimators, n_jobs = -1,\\n **params, random_state = 42) \\n model.fit(X_train, Y_train)\\n\\n return model\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77007174","0.7679591","0.76575476","0.76463956","0.7470647","0.7434266","0.7416312","0.73822284","0.7370632","0.73616713","0.73327446","0.73284346","0.722847","0.7186071","0.71467024","0.7122442","0.70457053","0.6964643","0.6961495","0.6944377","0.69214356","0.6885895","0.6834962","0.6831402","0.683031","0.68242896","0.6814457","0.68019813","0.67791474","0.67709404","0.67501765","0.67373943","0.67334545","0.6729874","0.67278045","0.66968393","0.66899306","0.6672713","0.6671377","0.66663545","0.6656561","0.6654989","0.6636143","0.65926963","0.6578277","0.6569758","0.6548368","0.6512602","0.6503532","0.6499182","0.6449522","0.6435872","0.64254946","0.6407219","0.6386662","0.63842106","0.63194793","0.62940174","0.6280331","0.6276167","0.6274001","0.62617725","0.6247634","0.62458295","0.62285143","0.6227249","0.62102973","0.6208086","0.6193006","0.61873674","0.6184935","0.6173738","0.6169475","0.6169334","0.61504996","0.6146204","0.6135572","0.6120028","0.6117503","0.61110556","0.611091","0.6097301","0.6084769","0.6051688","0.6036438","0.6029118","0.6020981","0.6016158","0.60135776","0.6013367","0.6009401","0.59847695","0.5974658","0.5969564","0.5957593","0.5951031","0.5934232","0.5927389","0.592584","0.5921864"],"string":"[\n \"0.77007174\",\n \"0.7679591\",\n \"0.76575476\",\n \"0.76463956\",\n \"0.7470647\",\n \"0.7434266\",\n \"0.7416312\",\n \"0.73822284\",\n \"0.7370632\",\n \"0.73616713\",\n \"0.73327446\",\n \"0.73284346\",\n \"0.722847\",\n \"0.7186071\",\n \"0.71467024\",\n \"0.7122442\",\n \"0.70457053\",\n \"0.6964643\",\n \"0.6961495\",\n \"0.6944377\",\n \"0.69214356\",\n \"0.6885895\",\n \"0.6834962\",\n \"0.6831402\",\n \"0.683031\",\n \"0.68242896\",\n \"0.6814457\",\n \"0.68019813\",\n \"0.67791474\",\n \"0.67709404\",\n \"0.67501765\",\n \"0.67373943\",\n \"0.67334545\",\n \"0.6729874\",\n \"0.67278045\",\n \"0.66968393\",\n \"0.66899306\",\n \"0.6672713\",\n \"0.6671377\",\n \"0.66663545\",\n \"0.6656561\",\n \"0.6654989\",\n \"0.6636143\",\n \"0.65926963\",\n \"0.6578277\",\n \"0.6569758\",\n \"0.6548368\",\n \"0.6512602\",\n \"0.6503532\",\n \"0.6499182\",\n \"0.6449522\",\n \"0.6435872\",\n \"0.64254946\",\n \"0.6407219\",\n \"0.6386662\",\n \"0.63842106\",\n \"0.63194793\",\n \"0.62940174\",\n \"0.6280331\",\n \"0.6276167\",\n \"0.6274001\",\n \"0.62617725\",\n \"0.6247634\",\n \"0.62458295\",\n \"0.62285143\",\n \"0.6227249\",\n \"0.62102973\",\n \"0.6208086\",\n \"0.6193006\",\n \"0.61873674\",\n \"0.6184935\",\n \"0.6173738\",\n \"0.6169475\",\n \"0.6169334\",\n \"0.61504996\",\n \"0.6146204\",\n \"0.6135572\",\n \"0.6120028\",\n \"0.6117503\",\n \"0.61110556\",\n \"0.611091\",\n \"0.6097301\",\n \"0.6084769\",\n \"0.6051688\",\n \"0.6036438\",\n \"0.6029118\",\n \"0.6020981\",\n \"0.6016158\",\n \"0.60135776\",\n \"0.6013367\",\n \"0.6009401\",\n \"0.59847695\",\n \"0.5974658\",\n \"0.5969564\",\n \"0.5957593\",\n \"0.5951031\",\n \"0.5934232\",\n \"0.5927389\",\n \"0.592584\",\n \"0.5921864\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.63284665"},"document_rank":{"kind":"string","value":"56"}}},{"rowIdx":7289,"cells":{"query":{"kind":"string","value":"Returns train and validation indices respecting the temporal ordering of the data."},"document":{"kind":"string","value":"def time_series_cross_validation(random_state: np.random.RandomState,\n num_splits: int,\n indices: np.ndarray,\n **kwargs: Any\n ) -> List[Tuple[np.ndarray, np.ndarray]]:\n test_size = kwargs['n_prediction_steps']\n n_repeats = kwargs['n_repeats']\n cv = TimeSeriesSplit(n_splits=num_splits, test_size=test_size * n_repeats, gap=0)\n splits = [(\n indices[split[0]],\n indices[split[1][[-1 - n * test_size for n in reversed(range(n_repeats))]]]) for split in cv.split(indices)]\n return splits"},"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_train_index():\n data_size = (NUM_CLASS - 1) * NUM_DATA_PER_CLASS\n return np.array([i for i in range(0, data_size)])","def get_training_index():\n return list(range(0, 305))","def split_data(train, parameters):\n labels = train.labels\n train_indices, val_indices = train_test_split(range(len(labels)),\n stratify=labels,\n random_state=parameters['seed'],\n test_size=parameters['validation_size'])\n return train_indices, val_indices","def get_inputs_train():\n x = tf.constant(extract_pandas_data(x_train))\n y = tf.constant(y_train.values)\n return x, y","def ordered_indices(self):\n return self.base_dataset.ordered_indices()","def build_index_groups(train):\n nz_row, nz_col = train.nonzero()\n nz_train = list(zip(nz_row, nz_col))\n\n grouped_nz_train_byrow = group_by(nz_train, index=0)\n nz_row_colindices = [(g, np.array([v[1] for v in value]))\n for g, value in grouped_nz_train_byrow]\n\n grouped_nz_train_bycol = group_by(nz_train, index=1)\n nz_col_rowindices = [(g, np.array([v[0] for v in value]))\n for g, value in grouped_nz_train_bycol]\n return nz_train, nz_row_colindices, nz_col_rowindices","def __train_test_splits(self):\n # By default, our indices are just 0-n\n split_indices = list(range(len(self.data)))\n # If shuffling, use our shared Random instance to shuffle our indices before slicing\n if self.shuffle:\n np.random.shuffle(split_indices)\n # Regardless of shuffle, take the first self.train_proportion for training, and the last\n # 1 - self.train_proportion records as test\n train_n = int(self.train_proportion * len(self.data))\n training_indices = split_indices[:train_n]\n test_indices = split_indices[train_n:]\n return training_indices, test_indices","def get_indices_input_target(num_obs, input_len, step_size, forecast_horizon, target_len):\n input_len = round(input_len) # just a precaution\n start_position = 0\n stop_position = num_obs - 1\n\n inpseq_first_idx = start_position\n inpseq_last_idx = inpseq_first_idx + input_len\n target_first_idx = inpseq_last_idx + forecast_horizon\n target_last_idx = target_first_idx + target_len\n print(\"target_last_idx = {}\".format(target_last_idx))\n print(\"stop_position = {}\".format(stop_position))\n indices = []\n while target_last_idx <= stop_position:\n indices.append((inpseq_first_idx, inpseq_last_idx, target_first_idx, target_last_idx))\n inpseq_first_idx += step_size\n inpseq_last_idx += step_size\n target_first_idx += inpseq_last_idx + forecast_horizon\n target_last_idx += target_first_idx + target_len\n return indices","def _get_indexes(self, participants):\n tr_idx = int(np.floor(self.tr_size*len(participants)))\n j = self.val_size + self.tr_size\n val_idx = int(np.floor(j*len(participants)))\n return tr_idx, val_idx","def get_train_val_indices(dataset, train_ratio, val_ratio):\n features = get_feature_labels_files(dataset)[0]\n indices = get_random_idx(features, 42).tolist()\n train_indices = indices[:int(train_ratio * len(indices))]\n val_indices = indices[int(train_ratio * len(indices)): int(train_ratio * len(indices)) + int(val_ratio * len(indices)) + 1]\n test_indices = indices[int(train_ratio * len(indices)) + int(val_ratio * len(indices)) + 1::]\n return [train_indices, val_indices, test_indices]","def get_indexes(self, dataset: BaseDataset) -> int:\n\n index = [np.random.randint(0, len(dataset)) for _ in range(1)]\n\n return index","def get_indexes(self, dataset):\n\n indexs = [random.randint(0, len(dataset)) for _ in range(3)]\n return indexs","def train_valid_index_split_two_stage(all_index, train_size_1 = None, train_size_2 = None, valid_split = 0.3):\n\tall_index = np.arange(all_index) if isinstance(all_index, int) else np.array(all_index)\n\n\ttrain_size_2 = len(all_index) if train_size_2 is None else train_size_2\n\ttrain_index_2_ = np.random.choice(all_index, train_size_2, replace = False)\n\ttrain_index_2, valid_index_2 = np.split(train_index_2_, [int(train_size_2*(1-valid_split))])\n\n\tall_index = np.setdiff1d(all_index, train_index_2)\n\ttrain_index_1_ = np.random.choice(all_index, train_size_1-train_size_2, replace = False)\n\ttrain_index_1, valid_index_1 = np.split(train_index_1_, [int((train_size_1-train_size_2)*(1-valid_split))])\n\ttrain_index_1 = np.hstack([train_index_1, train_index_2])\n\tvalid_index_1 = np.hstack([valid_index_1, valid_index_2])\n\treturn train_index_1, valid_index_1, train_index_2, valid_index_2","def getFeaturesIndices(self, tag, history, in_data=True):\n indices = []\n if in_data:\n self.__checkFeatureIndex__(self.__f100__((history.getWord(), tag)), indices)\n self.__checkFeatureIndex__(self.__f103__((history.getT_2(), history.getT_1(), tag)), indices)\n self.__checkFeatureIndex__(self.__f104__((history.getT_1(), tag)), indices)\n return indices","def perform_data_split(X, y, training_idxs, test_idxs, val_idxs):\n X_train = X[training_idxs]\n X_test = X[test_idxs]\n #X_val = X[val_idxs]\n\n y_train = y[training_idxs]\n y_test = y[test_idxs]\n #y_val = y[val_idxs]\n\n return X_train, X_test, y_train, y_test,","def make_training_set(ind_list, training_data): \n \n exp = training_data[ind_list[0]] \n X_train = exp[0]\n u_train = exp[1] \n\n for i in ind_list[1:]: \n exp = training_data[i]\n X_train = np.append(X_train, exp[0], axis=0)\n u_train = np.append(u_train, exp[1], axis=0)\n\n return X_train, u_train","def get_valid_indices():\n return [i for i, val in enumerate(all_topics) if val[1] == \"1\"]","def check_input_indices(self):\n for i, curr_input in enumerate(self.inputs.order_by(\"dataset_idx\"), start=1):\n if i != curr_input.dataset_idx:\n raise ValidationError(\"Inputs are not consecutively numbered starting from 1\")","def get_indexes(self, dataset: BaseDataset) -> int:\n\n indexes = [random.randint(0, len(dataset)) for _ in range(3)]\n return indexes","def get_prediction_indices(self):\r\n if self.full_df['Dates'][0] > self.full_df['Dates'][len(self.full_df) - 1]:\r\n self.full_df = self.full_df[::-1]\r\n self.full_df.reset_index(inplace=True)\r\n self.full_df.drop('index', axis=1, inplace=True)\r\n date_condition = ((self.full_df['Dates'] <= self.pred_end) &\r\n (self.full_df['Dates'] >= self.pred_start))\r\n self.pred_indices = list(self.full_df[date_condition].index)","def prepare_train_validation(self) -> Tuple:\n Xt, Xv, Yt, Yv = self.dataset.train_test_split_representations()\n\n Xt = self.dataset.prepare_input_samples(Xt)\n Yt = self.dataset.prepare_output_samples(Yt)\n traindataset = tf.data.Dataset.from_tensor_slices((Xt, Yt))\n traindataset = traindataset.batch(\n self.batch_size,\n num_parallel_calls=tf.data.experimental.AUTOTUNE\n )\n\n Xv = self.dataset.prepare_input_samples(Xv)\n Yv = self.dataset.prepare_output_samples(Yv)\n validdataset = tf.data.Dataset.from_tensor_slices((Xv, Yv))\n validdataset = validdataset.batch(\n self.batch_size,\n num_parallel_calls=tf.data.experimental.AUTOTUNE\n )\n\n return traindataset, validdataset","def split_validation_training_index(allind, splitsize, do_offset, offset_steps):\n i = offset_steps\n lval = splitsize\n if not do_offset:\n i_val = allind[:lval]\n i_train = allind[lval:]\n else:\n i_val = allind[i * lval:(i + 1) * lval]\n i_train = np.concatenate([allind[0:i * lval], allind[(i + 1) * lval:]], axis=0)\n if len(i_val) <= 0:\n print(\"Warning: #Validation data is 0, take 1 training sample instead\")\n i_val = i_train[:1]\n\n return i_train, i_val","def split_data_into_training_and_validation(self, data):\n training_dataset = self.get_data_from_indices(data, np.arange(self.num_training_samples))\n validation_dataset = self.get_data_from_indices(data, np.arange(self.num_training_samples,\n self.p.trainer.num_samples))\n return training_dataset, validation_dataset","def train_test_dataset(self, train_rate=0.8):\n point_date = int(len(self.y) * train_rate)\n y_to_train = self.y[:point_date]\n y_to_val = self.y[point_date:]\n predict_date = len(self.y) - len(y_to_train) # the number of data points for the test set\n date_val = self.y.index[point_date]\n return y_to_train, y_to_val, predict_date, date_val","def get_inputs_test():\n x = tf.constant(extract_pandas_data(x_test))\n y = tf.constant(y_test.values)\n return x, y","def train_test_split(data, validate_size=0.3):\r\n\r\n split = len(data) * (1 - validate_size)\r\n split = int(split)\r\n train = data[:split]\r\n validate = data[split:]\r\n\r\n return train, validate","def indices(self, fit):\r\n lam = self.lam_reeval if self.lam_reeval else 2 + len(fit) / 20\r\n reev = int(lam) + ((lam % 1) > np.random.rand())\r\n return np.argsort(array(fit, copy=False)[:2 * (reev + 1)])[:reev]","def make_idx_data(revs, word_idx_map, maxlen=60, is_split = True):\r\n X_train, X_trial, X_test,y_train, y_trial,y_test, lex_train, lex_trial = [], [], [], [], [], [], [], []\r\n for rev in revs:\r\n sent = get_idx_from_sent(rev['text'], word_idx_map)\r\n y = rev['y']\r\n if is_split:\r\n if rev['split'] == 1:\r\n X_train.append(sent)\r\n y_train.append(y)\r\n\r\n elif rev['split'] == -1:\r\n X_trial.append(sent)\r\n y_trial.append(y)\r\n else:\r\n X_test.append(sent)\r\n y_test.append(-1)\r\n\r\n if is_split:\r\n X_train = sequence.pad_sequences(np.array(X_train), maxlen=maxlen)\r\n X_trial = sequence.pad_sequences(np.array(X_trial), maxlen=maxlen)\r\n # X_valid = sequence.pad_sequences(np.array(X_valid), maxlen=maxlen)\r\n y_train = np_utils.to_categorical(np.array(y_train))\r\n y_trial = np_utils.to_categorical(np.array(y_trial))\r\n # y_valid = np.array(y_valid)\r\n\r\n lex_train = train_lexicon.values\r\n lex_trial = trial_lexicon.values\r\n lex_train = np.array(lex_train)\r\n lex_trial = np.array(lex_trial)\r\n return [X_train, X_trial, y_train, y_trial, lex_train, lex_trial]\r\n else:\r\n X_test = sequence.pad_sequences(np.array(X_test), maxlen=117)\r\n lex_test = test_lexicon.values\r\n lex_test = np.array(lex_test)\r\n return [X_test, lex_test]","def tc_index(*args):\n index = []\n x = check_tc_data(args[0])\n i = 0\n for line in args[0].Data.TCData.tc_data:\n i += 1\n if line != x[i - 1]:\n index.append(0)\n elif line == x[i - 1]:\n index.append(i)\n return index","def test_parse_split_index_ordering():\n index = [5, 37, 38, 56, 111] # test has max index 9999\n split = \"test\"\n kwargs = dict(epochs=1, batch_size=1, dataset_dir=DATASET_DIR, shuffle_files=False)\n ds = datasets.mnist(split=split, **kwargs)\n fixed_order = []\n for i, (x, y) in enumerate(ds):\n if i in index:\n fixed_order.append(x)\n if i >= max(index):\n break\n\n sliced_split = f\"{split}[{index}]\"\n ds = datasets.mnist(split=sliced_split, **kwargs)\n output_x = [x for (x, y) in ds]\n assert len(fixed_order) == len(output_x)\n for x_i, x_j in zip(fixed_order, output_x):\n assert (x_i == x_j).all()","def get_train_test_data(All_Data, Tr_Ind, Tst_Ind):\r\n\r\n\ttr_data = np.concatenate([data_m[ind] for data_m, ind in zip(All_Data, Tr_Ind)], axis=0)\r\n\ttst_data = np.concatenate([data_m[ind] for data_m, ind in zip(All_Data, Tst_Ind)], axis=0)\r\n\r\n\treturn tr_data, tst_data","def _train(self):\n self.train_acc.reset_states()\n self.val_acc.reset_states()\n self.train_loss.reset_states()\n self.val_loss.reset_states()\n\n self.train_ds.shuffle(buffer_size=1000)\n for idx, (x,y) in enumerate(self.train_ds):\n self.tf_train_step(x, y)\n\n for x,y in self.val_ds:\n self.tf_val_step(x, y)\n\n # It is important to return tf.Tensors as numpy objects.\n return {\n \"epoch\": self.iteration,\n \"loss_train\": self.train_loss.result().numpy(),\n \"loss_val\": self.val_loss.result().numpy(),\n \"acc_train\": self.train_acc.result().numpy(),\n \"acc_val\": self.val_acc.result().numpy(),\n }","def train(self):\r\n for class_ in set(self.train_classes):\r\n data = map(lambda (ind, datum): datum, filter(lambda (ind, datum): self.train_classes[ind] == class_, enumerate(self.train_data)))\r\n self.distribution.index_data(data, class_)","def split_train_and_test(num_examples, test_percentage):\n all_samples_idx = np.arange(num_examples)\n np.random.shuffle(all_samples_idx)\n test_examples = int(np.ceil(num_examples * test_percentage))\n # Train and validation indexes\n train_val_idx = all_samples_idx[0:len(all_samples_idx) - test_examples]\n test_idx = all_samples_idx[len(all_samples_idx) - test_examples:len(all_samples_idx)]\n\n return [train_val_idx, test_idx]","def getTrainTimes(t1,testTimes):\n trn=t1.copy(deep=True)\n for i,j in testTimes.iteritems():\n df0=trn[(i<=trn.index)&(trn.index<=j)].index # train starts within test\n df1=trn[(i<=trn)&(trn<=j)].index # train ends within test\n df2=trn[(trn.index<=i)&(j<=trn)].index # train envelops test\n trn=trn.drop(df0.union(df1).union(df2))\n return trn","def data_split(X, y):\n folds = KFold(n_splits=SPLITS, shuffle=True, random_state=RANDOM_STATE)\n train_indices, validation_indices = list(folds.split(X))[-1][0], list(folds.split(X))[-1][1]\n\n X_train = X.iloc[train_indices]\n X_validation = X.iloc[validation_indices]\n\n y_train = y.iloc[train_indices]\n y_validation = y.iloc[validation_indices]\n\n return X_train, X_validation, y_train, y_validation","def get_training_data():\n \n X = pd.read_csv('../data/train_values.csv').set_index('sequence_id')\n y = pd.read_csv('../data/train_labels.csv').set_index('sequence_id')\n return X, y","def get_cv_indices(df, col, time_slices):\n return [\n ## get train and holdout indices for slice\n tuple(get_row_indices(df, col, slc[x]) for x in range(2))\n\n ## get indices for each slice\n for slc in time_slices\n ]","def getFeaturesIndices(self, tag, history, in_data=True):\n indices = super().getFeaturesIndices(tag, history, in_data)\n word = history.getWord()\n position = history.getIndex()\n for suffix in self.data.getSuffixesForWord(word):\n self.__checkFeatureIndex__(self.__f101__((suffix, tag)), indices)\n for prefix in self.data.getPrefixesForWord(word):\n self.__checkFeatureIndex__(self.__f102__((prefix, tag)), indices)\n self.__checkFeatureIndex__(self.__f105__(tag), indices)\n self.__checkFeatureIndex__(self.__fNum__(word), indices)\n self.__checkFeatureIndex__(self.__fCap__(word, position), indices)\n return indices","def loo(self):\n loo = list()\n for i in range(self.data.shape[0]):\n train_index = [i for i in range(self.data.shape[0])]\n train_index.pop(i)\n test_index = i\n loo.append([train_index,test_index])\n\n return (loo)","def get_inputs_test_S():\n x = tf.constant(extract_pandas_data(x_test_S))\n y = tf.constant(y_test_S.values)\n return x, y","def get_data_idx(self)->list:\n return self.__data_idx","def _get_valid_indices(\n self,\n _signals: np.ndarray,\n _labels: np.ndarray,\n window_start_indices: np.ndarray = None,\n elm_start_indices: np.ndarray = None,\n elm_stop_indices: np.ndarray = None,\n valid_t0: np.ndarray = None,\n labels: np.ndarray = None,\n signals: np.ndarray = None,\n ) -> Tuple[\n np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray\n ]:\n # allowed indices; time data points which can be used for creating the data chunks\n _valid_t0 = np.ones(_labels.shape, dtype=np.int32)\n _valid_t0[\n -(config.signal_window_size + config.label_look_ahead) + 1 :\n ] = 0\n\n # indices for active elm events in each elm event\n active_elm_events = np.nonzero(_labels >= 0.5)[0]\n\n if signals is None:\n # initialize arrays\n window_start_indices = np.array([0])\n elm_start_indices = active_elm_events[0]\n elm_stop_indices = active_elm_events[-1]\n valid_t0 = _valid_t0\n signals = _signals\n labels = _labels\n else:\n # concat on axis 0 (time dimension)\n last_index = len(labels) - 1\n window_start_indices = np.append(\n window_start_indices, last_index + 1\n )\n elm_start_indices = np.append(\n elm_start_indices, active_elm_events[0] + last_index + 1\n )\n elm_stop_indices = np.append(\n elm_stop_indices, active_elm_events[-1] + last_index + 1\n )\n valid_t0 = np.concatenate([valid_t0, _valid_t0])\n signals = np.concatenate([signals, _signals], axis=0)\n labels = np.concatenate([labels, _labels], axis=0)\n\n return (\n signals,\n labels,\n valid_t0,\n window_start_indices,\n elm_start_indices,\n elm_stop_indices,\n )","def indices_of_split(self, split_name='train'):\n return self.indices_of('split', split_name)","def indexes(self):\r\n\r\n\r\n if not self.usesequence:\r\n\r\n if len(self.get_all_indexes()) != len(self.sortedindexes) \\\r\n or self.indexchanged or not self.sortedindexes:\r\n self.indexchanged = False\r\n self.sortedindexes = sorted(self.get_all_indexes(),\r\n key=lambda x_temp: Index(x_temp))\r\n return self.sortedindexes\r\n return self.sortedindexes\r\n else:\r\n if self.indexchanged:\r\n self.sortedindexes = self.default_dict['indexlist'].strings()\r\n return self.sortedindexes\r\n else:\r\n return self.sortedindexes","def reserve_validation_for_testing(self):\n info(\"Reserving validation data for testing.\")\n if self.test_idx is not None and self.test_idx.size > 0:\n warning(f\"Reserving validation for testing but {len(self.test_idx)} test index exists!\")\n warning(f\"Deleting existing test indexes\")\n self.test_idx = []\n self.test_via_validation = True\n for i in range(len(self.trainval_idx)):\n # fetch and replace the validation index\n val_idx = self.trainval_idx[i][1]\n self.trainval_idx[i] = (self.trainval_idx[i][0], np.arange(0, dtype=np.int32))\n # add it as the test index\n self.test_idx.append(val_idx)","def indices(self, _user=None):\n return [p.index for p in self.get_active_smallvariant_cases()]","def split_train_validation_and_test(num_examples, val_percentage, test_percentage):\n all_samples_idx = np.arange(num_examples)\n np.random.shuffle(all_samples_idx)\n test_examples = int(np.ceil(num_examples * test_percentage))\n val_examples = int(np.ceil(num_examples * val_percentage))\n # Train and validation indexes\n train_idx = all_samples_idx[0:len(all_samples_idx) - test_examples - val_examples]\n val_idx = all_samples_idx[len(all_samples_idx) - test_examples - val_examples:len(all_samples_idx) - test_examples]\n test_idx = all_samples_idx[len(all_samples_idx) - test_examples:]\n train_idx.sort()\n val_idx.sort()\n test_idx.sort()\n\n return [train_idx, val_idx, test_idx]","def get_data(t_idx):\n train_data = []\n train_label = []\n valid_data = []\n valid_label = []\n test_data = []\n test_label = []\n \n lines = []\n #f = open('/home/liwenzhe/myworkspace/is13/dataset/closingAdjLog.csv', 'rb')\n f = open('dataset/closingAdjLog.csv')\n reader = csv.reader(f)\n for row in reader:\n lines.append(row)\n lines.pop(0)\n \n n = len(lines)\n # use the first 80% for the training data, the next 10% for the validation data\n # and the last 10% for the test data. \n # TODO : create folds instead. \n for i in xrange(n-1, -1, -1):\n curr_line = lines[i]\n if i > n * 0.2:\n # add into training data\n if t_idx == 0:\n train_data.append(curr_line[t_idx+1:])\n else:\n train_data.append(curr_line[:t_idx-1] + curr_line[t_idx:])\n train_label.append(curr_line[t_idx]) \n elif i > n * 0.1:\n # add into validation data\n if t_idx == 0:\n valid_data.append(curr_line[t_idx+1:])\n else: \n valid_data.append(curr_line[:t_idx-1] + curr_line[t_idx:])\n valid_label.append(curr_line[t_idx]) \n else:\n # add into test data\n if t_idx == 0:\n test_data.append(curr_line[t_idx+1:])\n else:\n test_data.append(curr_line[:t_idx-1] + curr_line[t_idx:])\n test_label.append(curr_line[t_idx]) \n \n return [train_data, train_label, valid_data, valid_label, test_data, test_label]","def get_indexes(self, dataset):\n\n for i in range(self.max_iters):\n index = random.randint(0, len(dataset))\n gt_bboxes_i = dataset.get_ann_info(index)['bboxes']\n if len(gt_bboxes_i) != 0:\n break\n\n return index","def train_data(self):\n\n return self.__train_data, self.__train_labels","def _get_instance_indices(self, classes, num_detections, batch_index,\n class_id):\n classes = classes[batch_index:batch_index+1, ...]\n _, max_detections = shape_utils.combined_static_and_dynamic_shape(\n classes)\n # Get the detection indices corresponding to the target class.\n # Call tf.math.equal with matched tensor shape to make it tf.lite\n # compatible.\n valid_detections_with_kpt_class = tf.math.logical_and(\n tf.range(max_detections) < num_detections[batch_index],\n tf.math.equal(classes[0], tf.fill(classes[0].shape, class_id)))\n instance_inds = tf.where(valid_detections_with_kpt_class)[:, 0]\n # Cast the indices tensor to int32 for tf.lite compatibility.\n return tf.cast(instance_inds, tf.int32)","def getValidationData(data, labels):\n validationData = []\n for dataTensor in data:\n validationData.append(dataTensor[int(len(dataTensor) * (1 - configuration['nn']['validationSplit'])):])\n validationLabel = labels[int(len(labels) * (1 - configuration['nn']['validationSplit'])):]\n return validationData, validationLabel","def getValidationData(data, labels):\n validationData = []\n for dataTensor in data:\n validationData.append(dataTensor[int(len(dataTensor) * (1 - configuration['nn']['validationSplit'])):])\n validationLabel = labels[int(len(labels) * (1 - configuration['nn']['validationSplit'])):]\n return validationData, validationLabel","def get_data_params(self):\n\n minx, maxx = self.get_minx_maxx(normalized=True)\n\n # get the column indexes of categorical features after one-hot-encoding\n self.encoded_categorical_feature_indexes = self.get_encoded_categorical_feature_indexes()\n\n return minx, maxx, self.encoded_categorical_feature_indexes","def sorted_inputs(self):\n return self.inputs.order_by(\"dataset_idx\")","def get_training_and_testing_sets(data, Y):\r\n data = pd.concat([data, Y], axis=1)\r\n x,y=data.shape\r\n train_X_sub1=data[0:x//6]\r\n dev_X_sub1 = data[x//6:x//6 + x//12]\r\n test_X_sub1 = data[x//6 + x//12:x//3]\r\n\r\n train_X_sub2 = data[x//3:x//3+x//6]\r\n dev_X_sub2 = data[x//6 + x//3:x//3 + x//6 + x//12]\r\n test_X_sub2 = data[x//3 + x//6 + x//12:2*x//3]\r\n\r\n train_X_sub3 = data[2*x//3:(2*x//3) +x//6]\r\n dev_X_sub3 = data[x//6 + 2*x//3: (2*x//3) + x//6 + x//12]\r\n test_X_sub3 = data[2*x//3 + x//6 + x//12:x]\r\n\r\n train_X=train_X_sub1.append(train_X_sub2,ignore_index = True)\r\n train_X =train_X.append(train_X_sub3,ignore_index = True)\r\n dev_X= dev_X_sub1.append(dev_X_sub2,ignore_index = True)\r\n dev_X = dev_X.append(dev_X_sub3,ignore_index = True)\r\n test_X = test_X_sub1.append(test_X_sub2,ignore_index = True)\r\n test_X = test_X.append(test_X_sub3,ignore_index = True)\r\n\r\n\r\n train_X = util.shuffle(train_X)\r\n train_X = train_X.reset_index(drop=True)\r\n\r\n dev_X = util.shuffle(dev_X)\r\n dev_X = dev_X.reset_index(drop=True)\r\n\r\n test_X = util.shuffle(test_X)\r\n test_X = test_X.reset_index(drop=True)\r\n\r\n train_X_final=train_X\r\n dev_X_final = dev_X\r\n test_X_final = test_X\r\n x, y = train_X_final.shape\r\n train_X = train_X_final.iloc[:, 0:y - 1]\r\n train_Y = train_X_final.iloc[:, y - 1]\r\n\r\n x, y = test_X_final.shape\r\n test_X = test_X_final.iloc[:, 0:y - 1]\r\n test_Y = test_X_final.iloc[:, y - 1]\r\n\r\n x, y = dev_X_final.shape\r\n dev_X = dev_X_final.iloc[:, 0:y - 1]\r\n dev_Y = dev_X_final.iloc[:, y - 1]\r\n\r\n return train_X, train_Y, dev_X,dev_Y,test_X, test_Y","def test_get_indices_several_existing_items(self):\r\n control_ids = ['PC.354', 'PC.355', 'PC.356', 'PC.481', 'PC.593']\r\n exp_control_indices = [0, 1, 2, 3, 4]\r\n\r\n fast_ids = ['PC.607', 'PC.634', 'PC.635', 'PC.636']\r\n exp_fast_indices = [5, 6, 7, 8]\r\n\r\n obs_control = _get_indices(self.dist_matrix_header, control_ids)\r\n self.assertEqual(obs_control, exp_control_indices)\r\n\r\n obs_fast = _get_indices(self.dist_matrix_header, fast_ids)\r\n self.assertEqual(obs_fast, exp_fast_indices)","def train_test_official(self):\n return self.sub_set(self.idcs_train), self.sub_set(self.idcs_test)","def get_insert_indices(my_timestamps, existing_timestamps):\n existing_timestep = existing_timestamps[1] - existing_timestamps[0]\n my_timestep = my_timestamps[1] - my_timestamps[0]\n\n # make sure the time delta is ok\n if existing_timestep != my_timestep:\n raise Exception(\"Existing dataset has different timestep (mine=%d, existing=%d)\"\n % (my_timestep, existing_timestep))\n\n my_offset = (my_timestamps[0] - existing_timestamps[0]) // existing_timestep\n my_end = my_offset + len(my_timestamps)\n\n return my_offset, my_end","def run_idxs(self):\n return list(range(len(self._h5[RUNS])))","def get_valid_indices(labels):\n idxs = (labels != invalid_labels[0])\n for l in invalid_labels[1:]:\n idxs = idxs & (labels != l)\n return idxs","def train_test_indices(n, train_ratio=0.7):\n train_split_index = int(train_ratio * n)\n shuffled_indices = np.random.permutation(n)\n train_indices = shuffled_indices[:train_split_index]\n test_indices = shuffled_indices[train_split_index:]\n return train_indices, test_indices","def get_query(self, model, train_data, labelled_idx, unlabelled_idx):\n self.num_steps += 1\n # if this is the first step, then just return the seed set\n if self.num_steps == 1:\n return labelled_idx, unlabelled_idx\n\n if self.num_subsample is not None:\n num_subsample = min(self.num_subsample, len(unlabelled_idx))\n subsample_idx = random.sample(unlabelled_idx, k=num_subsample)\n else:\n subsample_idx = unlabelled_idx\n\n pool = Subset(train_data, subsample_idx)\n labelled = Subset(train_data, labelled_idx)\n # get ranking of datapoints\n idx_to_add = self.score(model, pool, labelled)\n\n # choose top scoring datapoints to label\n new_labelled_idx = labelled_idx + [subsample_idx[i] for i in idx_to_add]\n new_unlabelled_idx = [j for j in range(len(train_data)) if j not in new_labelled_idx]\n\n return new_labelled_idx, new_unlabelled_idx","def dt_train_test(dt, xTrain, yTrain, xTest, yTest):\n # train the model\n dt.train(xTrain, yTrain['label'])\n # predict the training dataset\n yHatTrain = dt.predict(xTrain)\n trainAcc = accuracy_score(yTrain['label'], yHatTrain)\n # predict the test dataset\n yHatTest = dt.predict(xTest)\n testAcc = accuracy_score(yTest['label'], yHatTest)\n return trainAcc, testAcc","def batch_indices(self):\n b = self.batch_size\n return [np.arange(i*b, i*b+b) for i in range(self.num_batches)]","def make_idx_data(revs, word_idx_map, maxlen=60):\n X_train, X_test, X_dev, y_train, y_dev,= [], [], [], [], []\n for rev in revs:\n sent = get_idx_from_sent(rev['text'], word_idx_map)\n y = rev['y']\n if rev['split'] == 1:\n X_train.append(sent)\n y_train.append(y)\n elif rev['split'] == 0:\n X_dev.append(sent)\n y_dev.append(y)\n elif rev['split'] == -1:\n X_test.append(sent)\n\n X_train = sequence.pad_sequences(np.array(X_train), maxlen=maxlen)\n X_dev = sequence.pad_sequences(np.array(X_dev), maxlen=maxlen)\n X_test = sequence.pad_sequences(np.array(X_test), maxlen=maxlen)\n y_train = np_utils.to_categorical(np.array(y_train))\n y_dev = np_utils.to_categorical(np.array(y_dev))\n\n return [X_train, X_test, X_dev, y_train, y_dev,]","def load_data():\n print(\"PARSING TRAIN\")\n ys_train, x_train, ids_train = load_pickle_data(\"ys_train\"), load_pickle_data(\"x_train\"), load_pickle_data(\n \"ids_train\")\n if ys_train is None or x_train is None or ids_train is None:\n ys_train, x_train, ids_train = load_csv_data(\"{}/train.csv\".format(DATA_DIR))\n dump_pickle_data(ys_train, \"ys_train\")\n dump_pickle_data(x_train, \"x_train\")\n dump_pickle_data(ids_train, \"ids_train\")\n\n print(\"PARSING TEST\")\n x_test, ids_test = load_pickle_data(\"x_test\"), load_pickle_data(\"ids_test\")\n if x_test is None or ids_test is None:\n _, x_test, ids_test = load_csv_data(\"{}/test.csv\".format(DATA_DIR))\n dump_pickle_data(x_test, \"x_test\")\n dump_pickle_data(ids_test, \"ids_test\")\n\n return ys_train, x_train, ids_train, x_test, ids_test","def train_test_official(self):\n return self.sub_set(self.train_idcs), self.sub_set(self.test_idcs)","def get_train_input(self, prev, i):\n pass","def train_valid_index_split(all_index, train_size = None, valid_split = 0.3):\n\tall_index = np.arange(all_index) if isinstance(all_index, int) else np.array(all_index)\n\ttrain_size = len(all_index) if train_size is None else train_size\n\ttrain_index_ = np.random.choice(all_index, train_size, replace = False)\n\ttrain_index, valid_index = np.split(train_index_, [int(train_size*(1-valid_split))])\n\treturn train_index, valid_index","def ordered_indices(self):\r\n '''we need random order'''\r\n if self.shuffle:\r\n indices = np.random.permutation(len(self))\r\n else:\r\n indices = np.arange(len(self))\r\n '''\r\n if self.tgt_sizes is not None:\r\n indices = indices[np.argsort(self.tgt_sizes[indices], kind='mergesort')]\r\n return indices[np.argsort(self.src_sizes[indices], kind='mergesort')]\r\n '''\r\n return indices","def index_in_epoch(self):\n return self._index_in_epoch","def train_batch_idx(self) -> int:\n return self._train_batch_idx","def index(self):\n return self._epochs_completed * self._size + self._index_in_epoch","def get_dataset_index(\n dataset: xr.Dataset, time_dataset_index: xr.Dataset\n) -> xr.Dataset:\n dataset_index = xr.Dataset()\n n_steps = len(next(iter(time_dataset_index.values())))\n for dim, var in dataset.items():\n if set(var.dims).intersection(time_dataset_index.keys()):\n time_dim = var.dims[0]\n assert time_dim in time_dataset_index, (\n f\"'{time_dim}' does not seems to be a time \"\n f\"dimensions in {time_dataset_index.keys()}. \"\n \"For the moment, only time dimension as first dim is supported.\"\n )\n dataset_index[dim] = time_dataset_index[time_dim]\n else:\n if not onp.shape(var):\n dataset_index[dim] = xr.DataArray(onp.arange(n_steps), dims=(\"step\",))\n else:\n values_atleast_1d = onp.atleast_1d(var.values)\n # grid = onp.indices(values_atleast_1d.shape)\n flat_idx = onp.arange(len(values_atleast_1d.ravel()))\n dataset_index[dim] = xr.DataArray(\n onp.outer(onp.arange(n_steps), flat_idx),\n dims=(\"step\", dim + \"_flat_idx\"),\n )\n return dataset_index","def inidices(self):\n return [Index(name, index) for name, index in self._data['indices'].iteritems()]","def train(self, data, labels, validationData, validationLabels): # data x training, y_training\n # ## TODO: Your code here\n count = util.Counter()\n\n #print 'Labels of the data is:', labels #printing all the labels from which the frequency has to be found\n\n for x in labels: # for loop\n count[x] += 1\n\n #print count\n val = count.argMax()\n self.guess = val\n #print val","def shuffle_train(self):\r\n if self.data_container.task == 'Classify':\r\n id_train_list=[]\r\n for i in self.idx_train_list:\r\n id_train_list.append(self._random_state.choice(i,self.train_parms[0]))\r\n for j in self._random_state.choice(self.unique_value, self.train_parms[1]):\r\n id_train_list.append(self._random_state.choice(self.idx_train_list[j],1))\r\n self.idx['train'] = np.concatenate(id_train_list, axis=0)\r\n \r\n self.idx['train'] = self._random_state.permutation(self.idx['train'])","def get_valid_indices(self):\n valid_indices = []\n for idx in range(len(os.listdir(self.fdir))):\n with open(os.path.join(self.fdir, f\"{idx}.json\"), \"r\") as f:\n data = json.load(f)\n if data[\"article\"] and data[\"abstract\"]:\n valid_indices.append(idx)\n return valid_indices","def Train_data():\n print (\"loading train data ...\")\n time_start = time.time()\n data_root = '/media/keziwen/86AA9651AA963E1D'\n with h5py.File(join(data_root, './data/train_real2.h5')) as f:\n data_real = f['train_real'][:]\n num, nt, ny, nx = data_real.shape\n data_real = np.transpose(data_real, (0, 1, 3, 2))\n with h5py.File(join(data_root, './data/train_imag2.h5')) as f:\n data_imag = f['train_imag'][:]\n num, nt, ny, nx = data_imag.shape\n data_imag = np.transpose(data_imag, (0, 1, 3, 2))\n data = data_real+1j*data_imag\n num_train = 15000\n num_validate = 2000\n train_data = data[0:num_train]\n validate_data = data[num_train:num_train+num_validate]\n\n train_data = np.random.permutation(train_data)\n\n time_end = time.time()\n print ('dataset has been created using {}s'.format(time_end-time_start))\n return train_data, validate_data","def test_train_spl(data, testsize):\n test = data.tail(testsize)\n train = data.head(data.shape[0] - testsize)\n return test, train","def _get_indx(self, t):\n t = np.array(t)\n a = (t[:, np.newaxis] <= self._data['stop']) & (t[:, np.newaxis] >=\n self._data['start'])\n return np.array([np.where(row)[0][0] for row in a])","def get_query(self, model, train_data, labelled_idx, unlabelled_idx):\n self.num_steps += 1\n # if this is the first step, then just return the seed set\n if self.num_steps == 1:\n return labelled_idx, unlabelled_idx\n\n if self.num_subsample is not None:\n num_subsample = min(self.num_subsample, len(unlabelled_idx))\n subsample_idx = random.sample(unlabelled_idx, k=num_subsample)\n else:\n subsample_idx = unlabelled_idx\n # initialise dataloader. Loads data in order of unlabelled idx\n pool = Subset(train_data, subsample_idx)\n\n # get scores on unlabelled datapoints\n scores = self.score(model, pool)\n\n # choose top scoring datapoints to label\n num_query = min(self.num_query, len(subsample_idx))\n idx_to_add = np.argsort(scores)[-num_query:]\n new_labelled_idx = labelled_idx + [subsample_idx[i] for i in idx_to_add]\n new_unlabelled_idx = [j for j in range(len(train_data)) if j not in new_labelled_idx]\n return new_labelled_idx, new_unlabelled_idx","def train(self, training_data):\n pass","def train_test_split(coordinates, data, weights=None, **kwargs):\n args = check_fit_input(coordinates, data, weights, unpack=False)\n ndata = args[1][0].size\n indices = np.arange(ndata)\n split = next(ShuffleSplit(n_splits=1, **kwargs).split(indices))\n train, test = (tuple(select(i, index) for i in args) for index in split)\n return train, test","def __get_x_y_from_training_validation(\n logger, training, validation, predictors, target):\n if training is not None:\n training_X, training_Y = __get_x_y_from_data(logger, training, predictors, target)\n if validation is not None:\n validation_X, validation_Y = __get_x_y_from_data(logger, validation, predictors, target)\n return training_X, training_Y, validation_X, validation_Y","def train(self, training_data, training_labels, validation_data, validation_labels):\n abstract","def get_query(self, model, train_data, labelled_idx, unlabelled_idx):\n # if this is the first step, then just return the seed set\n self.num_steps += 1\n if self.num_steps == 1:\n return labelled_idx, unlabelled_idx\n\n if self.num_subsample is not None:\n num_subsample = min(self.num_subsample, len(unlabelled_idx))\n subsample_idx = random.sample(unlabelled_idx, k=num_subsample)\n else:\n subsample_idx = unlabelled_idx\n # initialise dataloader. Loads data in order of unlabelled idx\n pool = Subset(train_data, subsample_idx)\n # get scores on unlabelled datapoints\n scores = self.score(model, pool)\n\n # choose top scoring datapoints to label\n num_query = min(self.num_query, len(subsample_idx))\n idx_to_add = np.argsort(scores)[-num_query:]\n new_labelled_idx = labelled_idx + [subsample_idx[i] for i in idx_to_add]\n new_unlabelled_idx = [j for j in range(len(train_data)) if j not in new_labelled_idx]\n return new_labelled_idx, new_unlabelled_idx","def train_valid_split(X, y):\n random_indexes = np.random.permutation(len(y))\n train_inds = random_indexes[:(0.75*len(y))]\n valid_inds = random_indexes[(0.75*len(y)):]\n return X[train_inds], y[train_inds], X[valid_inds], y[valid_inds]","def pt_index(*args):\n index = []\n x = check_pt_data(args[0])\n i = 0\n for line in args[0].Data.PTData.pt_data:\n i += 1\n if line != x[i - 1]:\n index.append(0)\n elif line == x[i - 1]:\n index.append(i)\n return index","def timeseries_train_test_split(X, y, test_size):\n\n # get the index after which test set starts\n test_index = int(len(X)*(1-test_size))\n\n X_train = X.iloc[:test_index]\n y_train = y.iloc[:test_index]\n X_test = X.iloc[test_index:]\n y_test = y.iloc[test_index:]\n\n return X_train, X_test, y_train, y_test","def ordered_indices(self):\r\n return np.arange(len(self), dtype=np.int64)","def get_idxvals(self):\n input_rows = list()\n input_cols = list()\n for key in self.index:\n input_rows.append(key[0])\n input_cols.append(key[1])\n\n return list(OrderedSet(input_rows)), list(OrderedSet(input_cols))","def find_index_in_cell(train, test, x_min, y_min, step):\n data_coor = train['x'].values\n data_in_x = np.logical_and(data_coor > x_min, data_coor < (x_min + step))\n data_coor = train['y'].values\n data_in_y = np.logical_and(data_coor > y_min, data_coor < (y_min + step))\n data_cell = np.logical_and(data_in_x, data_in_y)\n train_cell = train.iloc[data_cell]\n\n data_coor = test['x'].values\n data_in_x = np.logical_and(data_coor > x_min, data_coor < (x_min + step))\n data_coor = test['y'].values\n data_in_y = np.logical_and(data_coor > y_min, data_coor < (y_min + step))\n data_cell = np.logical_and(data_in_x, data_in_y)\n test_cell = test.iloc[data_cell]\n\n train_label_col = 'place_id'\n train_labels = train_cell[train_label_col]\n del train_cell[train_label_col]\n\n return train_cell, test_cell, train_labels","def _iter_indices(self, frame, y):\n n_samples = frame.shape[0]\n n_train, n_test = _validate_shuffle_split(n_samples,\n self.test_size, self.train_size)\n\n # need to validate y...\n y = _val_y(y)\n target = np.asarray(frame[y].as_data_frame(use_pandas=True)[y].tolist())\n\n classes, y_indices = np.unique(target, return_inverse=True)\n n_classes = classes.shape[0]\n\n class_counts = bincount(y_indices)\n if np.min(class_counts) < 2:\n raise ValueError('The least populated class in y has only 1 '\n 'member, which is too few. The minimum number of labels '\n 'for any class cannot be less than 2.')\n\n if n_train < n_classes:\n raise ValueError('The train_size=%d should be greater than or '\n 'equal to the number of classes=%d' % (n_train, n_classes))\n\n if n_test < n_classes:\n raise ValueError('The test_size=%d should be greater than or '\n 'equal to the number of classes=%d' % (n_test, n_classes))\n\n rng = check_random_state(self.random_state)\n p_i = class_counts / float(n_samples)\n n_i = np.round(n_train * p_i).astype(int)\n t_i = np.minimum(class_counts - n_i, np.round(n_test * p_i).astype(int))\n\n for _ in range(self.n_splits):\n train = []\n test = []\n\n for i, class_i in enumerate(classes):\n permutation = rng.permutation(class_counts[i])\n perm_indices_class_i = np.where((target == class_i))[0][permutation]\n\n train.extend(perm_indices_class_i[:n_i[i]])\n test.extend(perm_indices_class_i[n_i[i]:n_i[i] + t_i[i]])\n\n # Might end up here with less samples in train and test than we asked\n # for, due to rounding errors.\n if len(train) + len(test) < n_train + n_test:\n missing_indices = np.where(bincount(train + test, minlength=len(target)) == 0)[0]\n missing_indices = rng.permutation(missing_indices)\n n_missing_train = n_train - len(train)\n n_missing_test = n_test - len(test)\n\n if n_missing_train > 0:\n train.extend(missing_indices[:n_missing_train])\n if n_missing_test > 0:\n test.extend(missing_indices[-n_missing_test:])\n\n train = rng.permutation(train)\n test = rng.permutation(test)\n\n yield train, test","def get_relevant_indices(dataset, classes, target_classes):\n indices = []\n for i in range(len(dataset)):\n # Check if the label is in the target classes\n label_index = dataset[i][1] # ex: 3\n label_class = classes[label_index] # ex: 'cat'\n if label_class in target_classes:\n indices.append(i)\n return indices","def FindIdxValues(X):\n data = X.select_dtypes(include=[\"float64\"])\n idx = np.argwhere(~np.isnan(data.values))\n idx[:, 1] += 4 # add ID variable columns\n StoE = pd.read_csv(\"msresist/data/MS/CPTAC/IDtoExperiment.csv\")\n assert all(StoE.iloc[:, 0] == data.columns), \"Sample labels don't match.\"\n StoE = StoE.iloc[:, 1].values\n tmt = [[StoE[idx[ii][1] - 4]] for ii in range(idx.shape[0])]\n return np.append(idx, tmt, axis=1)","def get_query(self, model, train_data, labelled_idx, unlabelled_idx):\n self.num_steps += 1\n # if this is the first step, then just return the seed set\n if self.num_steps == 1:\n return labelled_idx, unlabelled_idx\n\n if self.num_subsample is not None:\n num_subsample = min(self.num_subsample, len(unlabelled_idx))\n subsample_idx = random.sample(unlabelled_idx, k=num_subsample)\n else:\n subsample_idx = unlabelled_idx\n # initialise dataloader. Loads data in order of unlabelled idx\n pool = Subset(train_data, subsample_idx)\n\n # get scores on unlabelled datapoints\n scores = self.score(model, pool)\n # TODO get some metrics on the scores/plot?\n\n # choose top scoring datapoints to label\n num_query = min(self.num_query, len(subsample_idx))\n idx_to_add = np.argsort(scores)[-num_query:]\n new_labelled_idx = labelled_idx + [subsample_idx[i] for i in idx_to_add]\n new_unlabelled_idx = [j for j in range(len(train_data)) if j not in new_labelled_idx]\n return new_labelled_idx, new_unlabelled_idx","def get_dataloaders_with_index(path=\"../../data\", batch_size=64, num_labeled=250,\n lbl_idxs=None, unlbl_idxs=None, valid_idxs=None, which_dataset='cifar10', validation=True):\n\n # Define transform to normalize data\n normalize = transforms.Normalize(\n mean=[0.4914, 0.4822, 0.4465],\n std=[0.2023, 0.1994, 0.2010],\n )\n transform = transforms.Compose([\n transforms.ToTensor(),\n normalize,\n ])\n\n if which_dataset == 'cifar10':\n train_set = CustomCIFAR10(root=path, train=True, transform=transform)\n test_set = CustomCIFAR10(root=path, train=False, transform=transform)\n elif which_dataset == 'svhn':\n train_set = datasets.SVHN(root=path, split='train', download=True, transform=transform)\n test_set = datasets.SVHN(root=path, split='test', download=True, transform=transform)\n else:\n raise Exception('Not supported yet')\n\n\n # Split indexes between labeled, unlabeled and validation\n if which_dataset == 'cifar10':\n training_labels = train_set.targets\n elif which_dataset == 'svhn':\n training_labels = train_set.labels\n else :\n training_labels = train_set.targets\n\n if validation:\n train_labeled_idxs, train_unlabeled_idxs, val_idxs = labeled_unlabeled_val_split(training_labels, int(num_labeled / 10))\n else:\n train_labeled_idxs, train_unlabeled_idxs = labeled_unlabeled_split(training_labels, int(num_labeled / 10))\n val_idxs = []\n\n # If indexes are provided, use them\n if lbl_idxs is not None:\n train_labeled_idxs = lbl_idxs\n train_unlabeled_idxs = unlbl_idxs\n val_idxs = valid_idxs\n\n # Define samplers using indexes\n train_labeled_sampler = SubsetRandomSampler(train_labeled_idxs)\n train_unlabeled_sampler = SubsetRandomSampler(train_unlabeled_idxs)\n val_sampler = SubsetRandomSampler(val_idxs)\n\n # Create data loaders\n train_labeled_loader = DataLoader(train_set, batch_size=batch_size, sampler=train_labeled_sampler, num_workers=0)\n train_unlabeled_loader = DataLoader(train_set, batch_size=batch_size, sampler=train_unlabeled_sampler, num_workers=0)\n val_loader = DataLoader(train_set, batch_size=batch_size, sampler=val_sampler, num_workers=0)\n test_loader = DataLoader(test_set, batch_size=batch_size, shuffle=False, num_workers=0)\n\n if not validation:\n val_loader = test_loader\n\n return train_labeled_loader, train_unlabeled_loader, val_loader, test_loader, train_labeled_idxs, train_unlabeled_idxs, val_idxs","def DataSplit(self, data):\n train_X,test_X,train_y,test_y=train_test_split(data[0],data[1], random_state=2)\n valid_X,valid_y=train_test_split(data[0],data[1],random_state=2,test_size=0.15)[1],train_test_split(data[0],data[1],random_state=2,test_size=0.15)[3]\n return (train_X,test_X,valid_X,train_y,test_y,valid_y)"],"string":"[\n \"def get_train_index():\\n data_size = (NUM_CLASS - 1) * NUM_DATA_PER_CLASS\\n return np.array([i for i in range(0, data_size)])\",\n \"def get_training_index():\\n return list(range(0, 305))\",\n \"def split_data(train, parameters):\\n labels = train.labels\\n train_indices, val_indices = train_test_split(range(len(labels)),\\n stratify=labels,\\n random_state=parameters['seed'],\\n test_size=parameters['validation_size'])\\n return train_indices, val_indices\",\n \"def get_inputs_train():\\n x = tf.constant(extract_pandas_data(x_train))\\n y = tf.constant(y_train.values)\\n return x, y\",\n \"def ordered_indices(self):\\n return self.base_dataset.ordered_indices()\",\n \"def build_index_groups(train):\\n nz_row, nz_col = train.nonzero()\\n nz_train = list(zip(nz_row, nz_col))\\n\\n grouped_nz_train_byrow = group_by(nz_train, index=0)\\n nz_row_colindices = [(g, np.array([v[1] for v in value]))\\n for g, value in grouped_nz_train_byrow]\\n\\n grouped_nz_train_bycol = group_by(nz_train, index=1)\\n nz_col_rowindices = [(g, np.array([v[0] for v in value]))\\n for g, value in grouped_nz_train_bycol]\\n return nz_train, nz_row_colindices, nz_col_rowindices\",\n \"def __train_test_splits(self):\\n # By default, our indices are just 0-n\\n split_indices = list(range(len(self.data)))\\n # If shuffling, use our shared Random instance to shuffle our indices before slicing\\n if self.shuffle:\\n np.random.shuffle(split_indices)\\n # Regardless of shuffle, take the first self.train_proportion for training, and the last\\n # 1 - self.train_proportion records as test\\n train_n = int(self.train_proportion * len(self.data))\\n training_indices = split_indices[:train_n]\\n test_indices = split_indices[train_n:]\\n return training_indices, test_indices\",\n \"def get_indices_input_target(num_obs, input_len, step_size, forecast_horizon, target_len):\\n input_len = round(input_len) # just a precaution\\n start_position = 0\\n stop_position = num_obs - 1\\n\\n inpseq_first_idx = start_position\\n inpseq_last_idx = inpseq_first_idx + input_len\\n target_first_idx = inpseq_last_idx + forecast_horizon\\n target_last_idx = target_first_idx + target_len\\n print(\\\"target_last_idx = {}\\\".format(target_last_idx))\\n print(\\\"stop_position = {}\\\".format(stop_position))\\n indices = []\\n while target_last_idx <= stop_position:\\n indices.append((inpseq_first_idx, inpseq_last_idx, target_first_idx, target_last_idx))\\n inpseq_first_idx += step_size\\n inpseq_last_idx += step_size\\n target_first_idx += inpseq_last_idx + forecast_horizon\\n target_last_idx += target_first_idx + target_len\\n return indices\",\n \"def _get_indexes(self, participants):\\n tr_idx = int(np.floor(self.tr_size*len(participants)))\\n j = self.val_size + self.tr_size\\n val_idx = int(np.floor(j*len(participants)))\\n return tr_idx, val_idx\",\n \"def get_train_val_indices(dataset, train_ratio, val_ratio):\\n features = get_feature_labels_files(dataset)[0]\\n indices = get_random_idx(features, 42).tolist()\\n train_indices = indices[:int(train_ratio * len(indices))]\\n val_indices = indices[int(train_ratio * len(indices)): int(train_ratio * len(indices)) + int(val_ratio * len(indices)) + 1]\\n test_indices = indices[int(train_ratio * len(indices)) + int(val_ratio * len(indices)) + 1::]\\n return [train_indices, val_indices, test_indices]\",\n \"def get_indexes(self, dataset: BaseDataset) -> int:\\n\\n index = [np.random.randint(0, len(dataset)) for _ in range(1)]\\n\\n return index\",\n \"def get_indexes(self, dataset):\\n\\n indexs = [random.randint(0, len(dataset)) for _ in range(3)]\\n return indexs\",\n \"def train_valid_index_split_two_stage(all_index, train_size_1 = None, train_size_2 = None, valid_split = 0.3):\\n\\tall_index = np.arange(all_index) if isinstance(all_index, int) else np.array(all_index)\\n\\n\\ttrain_size_2 = len(all_index) if train_size_2 is None else train_size_2\\n\\ttrain_index_2_ = np.random.choice(all_index, train_size_2, replace = False)\\n\\ttrain_index_2, valid_index_2 = np.split(train_index_2_, [int(train_size_2*(1-valid_split))])\\n\\n\\tall_index = np.setdiff1d(all_index, train_index_2)\\n\\ttrain_index_1_ = np.random.choice(all_index, train_size_1-train_size_2, replace = False)\\n\\ttrain_index_1, valid_index_1 = np.split(train_index_1_, [int((train_size_1-train_size_2)*(1-valid_split))])\\n\\ttrain_index_1 = np.hstack([train_index_1, train_index_2])\\n\\tvalid_index_1 = np.hstack([valid_index_1, valid_index_2])\\n\\treturn train_index_1, valid_index_1, train_index_2, valid_index_2\",\n \"def getFeaturesIndices(self, tag, history, in_data=True):\\n indices = []\\n if in_data:\\n self.__checkFeatureIndex__(self.__f100__((history.getWord(), tag)), indices)\\n self.__checkFeatureIndex__(self.__f103__((history.getT_2(), history.getT_1(), tag)), indices)\\n self.__checkFeatureIndex__(self.__f104__((history.getT_1(), tag)), indices)\\n return indices\",\n \"def perform_data_split(X, y, training_idxs, test_idxs, val_idxs):\\n X_train = X[training_idxs]\\n X_test = X[test_idxs]\\n #X_val = X[val_idxs]\\n\\n y_train = y[training_idxs]\\n y_test = y[test_idxs]\\n #y_val = y[val_idxs]\\n\\n return X_train, X_test, y_train, y_test,\",\n \"def make_training_set(ind_list, training_data): \\n \\n exp = training_data[ind_list[0]] \\n X_train = exp[0]\\n u_train = exp[1] \\n\\n for i in ind_list[1:]: \\n exp = training_data[i]\\n X_train = np.append(X_train, exp[0], axis=0)\\n u_train = np.append(u_train, exp[1], axis=0)\\n\\n return X_train, u_train\",\n \"def get_valid_indices():\\n return [i for i, val in enumerate(all_topics) if val[1] == \\\"1\\\"]\",\n \"def check_input_indices(self):\\n for i, curr_input in enumerate(self.inputs.order_by(\\\"dataset_idx\\\"), start=1):\\n if i != curr_input.dataset_idx:\\n raise ValidationError(\\\"Inputs are not consecutively numbered starting from 1\\\")\",\n \"def get_indexes(self, dataset: BaseDataset) -> int:\\n\\n indexes = [random.randint(0, len(dataset)) for _ in range(3)]\\n return indexes\",\n \"def get_prediction_indices(self):\\r\\n if self.full_df['Dates'][0] > self.full_df['Dates'][len(self.full_df) - 1]:\\r\\n self.full_df = self.full_df[::-1]\\r\\n self.full_df.reset_index(inplace=True)\\r\\n self.full_df.drop('index', axis=1, inplace=True)\\r\\n date_condition = ((self.full_df['Dates'] <= self.pred_end) &\\r\\n (self.full_df['Dates'] >= self.pred_start))\\r\\n self.pred_indices = list(self.full_df[date_condition].index)\",\n \"def prepare_train_validation(self) -> Tuple:\\n Xt, Xv, Yt, Yv = self.dataset.train_test_split_representations()\\n\\n Xt = self.dataset.prepare_input_samples(Xt)\\n Yt = self.dataset.prepare_output_samples(Yt)\\n traindataset = tf.data.Dataset.from_tensor_slices((Xt, Yt))\\n traindataset = traindataset.batch(\\n self.batch_size,\\n num_parallel_calls=tf.data.experimental.AUTOTUNE\\n )\\n\\n Xv = self.dataset.prepare_input_samples(Xv)\\n Yv = self.dataset.prepare_output_samples(Yv)\\n validdataset = tf.data.Dataset.from_tensor_slices((Xv, Yv))\\n validdataset = validdataset.batch(\\n self.batch_size,\\n num_parallel_calls=tf.data.experimental.AUTOTUNE\\n )\\n\\n return traindataset, validdataset\",\n \"def split_validation_training_index(allind, splitsize, do_offset, offset_steps):\\n i = offset_steps\\n lval = splitsize\\n if not do_offset:\\n i_val = allind[:lval]\\n i_train = allind[lval:]\\n else:\\n i_val = allind[i * lval:(i + 1) * lval]\\n i_train = np.concatenate([allind[0:i * lval], allind[(i + 1) * lval:]], axis=0)\\n if len(i_val) <= 0:\\n print(\\\"Warning: #Validation data is 0, take 1 training sample instead\\\")\\n i_val = i_train[:1]\\n\\n return i_train, i_val\",\n \"def split_data_into_training_and_validation(self, data):\\n training_dataset = self.get_data_from_indices(data, np.arange(self.num_training_samples))\\n validation_dataset = self.get_data_from_indices(data, np.arange(self.num_training_samples,\\n self.p.trainer.num_samples))\\n return training_dataset, validation_dataset\",\n \"def train_test_dataset(self, train_rate=0.8):\\n point_date = int(len(self.y) * train_rate)\\n y_to_train = self.y[:point_date]\\n y_to_val = self.y[point_date:]\\n predict_date = len(self.y) - len(y_to_train) # the number of data points for the test set\\n date_val = self.y.index[point_date]\\n return y_to_train, y_to_val, predict_date, date_val\",\n \"def get_inputs_test():\\n x = tf.constant(extract_pandas_data(x_test))\\n y = tf.constant(y_test.values)\\n return x, y\",\n \"def train_test_split(data, validate_size=0.3):\\r\\n\\r\\n split = len(data) * (1 - validate_size)\\r\\n split = int(split)\\r\\n train = data[:split]\\r\\n validate = data[split:]\\r\\n\\r\\n return train, validate\",\n \"def indices(self, fit):\\r\\n lam = self.lam_reeval if self.lam_reeval else 2 + len(fit) / 20\\r\\n reev = int(lam) + ((lam % 1) > np.random.rand())\\r\\n return np.argsort(array(fit, copy=False)[:2 * (reev + 1)])[:reev]\",\n \"def make_idx_data(revs, word_idx_map, maxlen=60, is_split = True):\\r\\n X_train, X_trial, X_test,y_train, y_trial,y_test, lex_train, lex_trial = [], [], [], [], [], [], [], []\\r\\n for rev in revs:\\r\\n sent = get_idx_from_sent(rev['text'], word_idx_map)\\r\\n y = rev['y']\\r\\n if is_split:\\r\\n if rev['split'] == 1:\\r\\n X_train.append(sent)\\r\\n y_train.append(y)\\r\\n\\r\\n elif rev['split'] == -1:\\r\\n X_trial.append(sent)\\r\\n y_trial.append(y)\\r\\n else:\\r\\n X_test.append(sent)\\r\\n y_test.append(-1)\\r\\n\\r\\n if is_split:\\r\\n X_train = sequence.pad_sequences(np.array(X_train), maxlen=maxlen)\\r\\n X_trial = sequence.pad_sequences(np.array(X_trial), maxlen=maxlen)\\r\\n # X_valid = sequence.pad_sequences(np.array(X_valid), maxlen=maxlen)\\r\\n y_train = np_utils.to_categorical(np.array(y_train))\\r\\n y_trial = np_utils.to_categorical(np.array(y_trial))\\r\\n # y_valid = np.array(y_valid)\\r\\n\\r\\n lex_train = train_lexicon.values\\r\\n lex_trial = trial_lexicon.values\\r\\n lex_train = np.array(lex_train)\\r\\n lex_trial = np.array(lex_trial)\\r\\n return [X_train, X_trial, y_train, y_trial, lex_train, lex_trial]\\r\\n else:\\r\\n X_test = sequence.pad_sequences(np.array(X_test), maxlen=117)\\r\\n lex_test = test_lexicon.values\\r\\n lex_test = np.array(lex_test)\\r\\n return [X_test, lex_test]\",\n \"def tc_index(*args):\\n index = []\\n x = check_tc_data(args[0])\\n i = 0\\n for line in args[0].Data.TCData.tc_data:\\n i += 1\\n if line != x[i - 1]:\\n index.append(0)\\n elif line == x[i - 1]:\\n index.append(i)\\n return index\",\n \"def test_parse_split_index_ordering():\\n index = [5, 37, 38, 56, 111] # test has max index 9999\\n split = \\\"test\\\"\\n kwargs = dict(epochs=1, batch_size=1, dataset_dir=DATASET_DIR, shuffle_files=False)\\n ds = datasets.mnist(split=split, **kwargs)\\n fixed_order = []\\n for i, (x, y) in enumerate(ds):\\n if i in index:\\n fixed_order.append(x)\\n if i >= max(index):\\n break\\n\\n sliced_split = f\\\"{split}[{index}]\\\"\\n ds = datasets.mnist(split=sliced_split, **kwargs)\\n output_x = [x for (x, y) in ds]\\n assert len(fixed_order) == len(output_x)\\n for x_i, x_j in zip(fixed_order, output_x):\\n assert (x_i == x_j).all()\",\n \"def get_train_test_data(All_Data, Tr_Ind, Tst_Ind):\\r\\n\\r\\n\\ttr_data = np.concatenate([data_m[ind] for data_m, ind in zip(All_Data, Tr_Ind)], axis=0)\\r\\n\\ttst_data = np.concatenate([data_m[ind] for data_m, ind in zip(All_Data, Tst_Ind)], axis=0)\\r\\n\\r\\n\\treturn tr_data, tst_data\",\n \"def _train(self):\\n self.train_acc.reset_states()\\n self.val_acc.reset_states()\\n self.train_loss.reset_states()\\n self.val_loss.reset_states()\\n\\n self.train_ds.shuffle(buffer_size=1000)\\n for idx, (x,y) in enumerate(self.train_ds):\\n self.tf_train_step(x, y)\\n\\n for x,y in self.val_ds:\\n self.tf_val_step(x, y)\\n\\n # It is important to return tf.Tensors as numpy objects.\\n return {\\n \\\"epoch\\\": self.iteration,\\n \\\"loss_train\\\": self.train_loss.result().numpy(),\\n \\\"loss_val\\\": self.val_loss.result().numpy(),\\n \\\"acc_train\\\": self.train_acc.result().numpy(),\\n \\\"acc_val\\\": self.val_acc.result().numpy(),\\n }\",\n \"def train(self):\\r\\n for class_ in set(self.train_classes):\\r\\n data = map(lambda (ind, datum): datum, filter(lambda (ind, datum): self.train_classes[ind] == class_, enumerate(self.train_data)))\\r\\n self.distribution.index_data(data, class_)\",\n \"def split_train_and_test(num_examples, test_percentage):\\n all_samples_idx = np.arange(num_examples)\\n np.random.shuffle(all_samples_idx)\\n test_examples = int(np.ceil(num_examples * test_percentage))\\n # Train and validation indexes\\n train_val_idx = all_samples_idx[0:len(all_samples_idx) - test_examples]\\n test_idx = all_samples_idx[len(all_samples_idx) - test_examples:len(all_samples_idx)]\\n\\n return [train_val_idx, test_idx]\",\n \"def getTrainTimes(t1,testTimes):\\n trn=t1.copy(deep=True)\\n for i,j in testTimes.iteritems():\\n df0=trn[(i<=trn.index)&(trn.index<=j)].index # train starts within test\\n df1=trn[(i<=trn)&(trn<=j)].index # train ends within test\\n df2=trn[(trn.index<=i)&(j<=trn)].index # train envelops test\\n trn=trn.drop(df0.union(df1).union(df2))\\n return trn\",\n \"def data_split(X, y):\\n folds = KFold(n_splits=SPLITS, shuffle=True, random_state=RANDOM_STATE)\\n train_indices, validation_indices = list(folds.split(X))[-1][0], list(folds.split(X))[-1][1]\\n\\n X_train = X.iloc[train_indices]\\n X_validation = X.iloc[validation_indices]\\n\\n y_train = y.iloc[train_indices]\\n y_validation = y.iloc[validation_indices]\\n\\n return X_train, X_validation, y_train, y_validation\",\n \"def get_training_data():\\n \\n X = pd.read_csv('../data/train_values.csv').set_index('sequence_id')\\n y = pd.read_csv('../data/train_labels.csv').set_index('sequence_id')\\n return X, y\",\n \"def get_cv_indices(df, col, time_slices):\\n return [\\n ## get train and holdout indices for slice\\n tuple(get_row_indices(df, col, slc[x]) for x in range(2))\\n\\n ## get indices for each slice\\n for slc in time_slices\\n ]\",\n \"def getFeaturesIndices(self, tag, history, in_data=True):\\n indices = super().getFeaturesIndices(tag, history, in_data)\\n word = history.getWord()\\n position = history.getIndex()\\n for suffix in self.data.getSuffixesForWord(word):\\n self.__checkFeatureIndex__(self.__f101__((suffix, tag)), indices)\\n for prefix in self.data.getPrefixesForWord(word):\\n self.__checkFeatureIndex__(self.__f102__((prefix, tag)), indices)\\n self.__checkFeatureIndex__(self.__f105__(tag), indices)\\n self.__checkFeatureIndex__(self.__fNum__(word), indices)\\n self.__checkFeatureIndex__(self.__fCap__(word, position), indices)\\n return indices\",\n \"def loo(self):\\n loo = list()\\n for i in range(self.data.shape[0]):\\n train_index = [i for i in range(self.data.shape[0])]\\n train_index.pop(i)\\n test_index = i\\n loo.append([train_index,test_index])\\n\\n return (loo)\",\n \"def get_inputs_test_S():\\n x = tf.constant(extract_pandas_data(x_test_S))\\n y = tf.constant(y_test_S.values)\\n return x, y\",\n \"def get_data_idx(self)->list:\\n return self.__data_idx\",\n \"def _get_valid_indices(\\n self,\\n _signals: np.ndarray,\\n _labels: np.ndarray,\\n window_start_indices: np.ndarray = None,\\n elm_start_indices: np.ndarray = None,\\n elm_stop_indices: np.ndarray = None,\\n valid_t0: np.ndarray = None,\\n labels: np.ndarray = None,\\n signals: np.ndarray = None,\\n ) -> Tuple[\\n np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray\\n ]:\\n # allowed indices; time data points which can be used for creating the data chunks\\n _valid_t0 = np.ones(_labels.shape, dtype=np.int32)\\n _valid_t0[\\n -(config.signal_window_size + config.label_look_ahead) + 1 :\\n ] = 0\\n\\n # indices for active elm events in each elm event\\n active_elm_events = np.nonzero(_labels >= 0.5)[0]\\n\\n if signals is None:\\n # initialize arrays\\n window_start_indices = np.array([0])\\n elm_start_indices = active_elm_events[0]\\n elm_stop_indices = active_elm_events[-1]\\n valid_t0 = _valid_t0\\n signals = _signals\\n labels = _labels\\n else:\\n # concat on axis 0 (time dimension)\\n last_index = len(labels) - 1\\n window_start_indices = np.append(\\n window_start_indices, last_index + 1\\n )\\n elm_start_indices = np.append(\\n elm_start_indices, active_elm_events[0] + last_index + 1\\n )\\n elm_stop_indices = np.append(\\n elm_stop_indices, active_elm_events[-1] + last_index + 1\\n )\\n valid_t0 = np.concatenate([valid_t0, _valid_t0])\\n signals = np.concatenate([signals, _signals], axis=0)\\n labels = np.concatenate([labels, _labels], axis=0)\\n\\n return (\\n signals,\\n labels,\\n valid_t0,\\n window_start_indices,\\n elm_start_indices,\\n elm_stop_indices,\\n )\",\n \"def indices_of_split(self, split_name='train'):\\n return self.indices_of('split', split_name)\",\n \"def indexes(self):\\r\\n\\r\\n\\r\\n if not self.usesequence:\\r\\n\\r\\n if len(self.get_all_indexes()) != len(self.sortedindexes) \\\\\\r\\n or self.indexchanged or not self.sortedindexes:\\r\\n self.indexchanged = False\\r\\n self.sortedindexes = sorted(self.get_all_indexes(),\\r\\n key=lambda x_temp: Index(x_temp))\\r\\n return self.sortedindexes\\r\\n return self.sortedindexes\\r\\n else:\\r\\n if self.indexchanged:\\r\\n self.sortedindexes = self.default_dict['indexlist'].strings()\\r\\n return self.sortedindexes\\r\\n else:\\r\\n return self.sortedindexes\",\n \"def reserve_validation_for_testing(self):\\n info(\\\"Reserving validation data for testing.\\\")\\n if self.test_idx is not None and self.test_idx.size > 0:\\n warning(f\\\"Reserving validation for testing but {len(self.test_idx)} test index exists!\\\")\\n warning(f\\\"Deleting existing test indexes\\\")\\n self.test_idx = []\\n self.test_via_validation = True\\n for i in range(len(self.trainval_idx)):\\n # fetch and replace the validation index\\n val_idx = self.trainval_idx[i][1]\\n self.trainval_idx[i] = (self.trainval_idx[i][0], np.arange(0, dtype=np.int32))\\n # add it as the test index\\n self.test_idx.append(val_idx)\",\n \"def indices(self, _user=None):\\n return [p.index for p in self.get_active_smallvariant_cases()]\",\n \"def split_train_validation_and_test(num_examples, val_percentage, test_percentage):\\n all_samples_idx = np.arange(num_examples)\\n np.random.shuffle(all_samples_idx)\\n test_examples = int(np.ceil(num_examples * test_percentage))\\n val_examples = int(np.ceil(num_examples * val_percentage))\\n # Train and validation indexes\\n train_idx = all_samples_idx[0:len(all_samples_idx) - test_examples - val_examples]\\n val_idx = all_samples_idx[len(all_samples_idx) - test_examples - val_examples:len(all_samples_idx) - test_examples]\\n test_idx = all_samples_idx[len(all_samples_idx) - test_examples:]\\n train_idx.sort()\\n val_idx.sort()\\n test_idx.sort()\\n\\n return [train_idx, val_idx, test_idx]\",\n \"def get_data(t_idx):\\n train_data = []\\n train_label = []\\n valid_data = []\\n valid_label = []\\n test_data = []\\n test_label = []\\n \\n lines = []\\n #f = open('/home/liwenzhe/myworkspace/is13/dataset/closingAdjLog.csv', 'rb')\\n f = open('dataset/closingAdjLog.csv')\\n reader = csv.reader(f)\\n for row in reader:\\n lines.append(row)\\n lines.pop(0)\\n \\n n = len(lines)\\n # use the first 80% for the training data, the next 10% for the validation data\\n # and the last 10% for the test data. \\n # TODO : create folds instead. \\n for i in xrange(n-1, -1, -1):\\n curr_line = lines[i]\\n if i > n * 0.2:\\n # add into training data\\n if t_idx == 0:\\n train_data.append(curr_line[t_idx+1:])\\n else:\\n train_data.append(curr_line[:t_idx-1] + curr_line[t_idx:])\\n train_label.append(curr_line[t_idx]) \\n elif i > n * 0.1:\\n # add into validation data\\n if t_idx == 0:\\n valid_data.append(curr_line[t_idx+1:])\\n else: \\n valid_data.append(curr_line[:t_idx-1] + curr_line[t_idx:])\\n valid_label.append(curr_line[t_idx]) \\n else:\\n # add into test data\\n if t_idx == 0:\\n test_data.append(curr_line[t_idx+1:])\\n else:\\n test_data.append(curr_line[:t_idx-1] + curr_line[t_idx:])\\n test_label.append(curr_line[t_idx]) \\n \\n return [train_data, train_label, valid_data, valid_label, test_data, test_label]\",\n \"def get_indexes(self, dataset):\\n\\n for i in range(self.max_iters):\\n index = random.randint(0, len(dataset))\\n gt_bboxes_i = dataset.get_ann_info(index)['bboxes']\\n if len(gt_bboxes_i) != 0:\\n break\\n\\n return index\",\n \"def train_data(self):\\n\\n return self.__train_data, self.__train_labels\",\n \"def _get_instance_indices(self, classes, num_detections, batch_index,\\n class_id):\\n classes = classes[batch_index:batch_index+1, ...]\\n _, max_detections = shape_utils.combined_static_and_dynamic_shape(\\n classes)\\n # Get the detection indices corresponding to the target class.\\n # Call tf.math.equal with matched tensor shape to make it tf.lite\\n # compatible.\\n valid_detections_with_kpt_class = tf.math.logical_and(\\n tf.range(max_detections) < num_detections[batch_index],\\n tf.math.equal(classes[0], tf.fill(classes[0].shape, class_id)))\\n instance_inds = tf.where(valid_detections_with_kpt_class)[:, 0]\\n # Cast the indices tensor to int32 for tf.lite compatibility.\\n return tf.cast(instance_inds, tf.int32)\",\n \"def getValidationData(data, labels):\\n validationData = []\\n for dataTensor in data:\\n validationData.append(dataTensor[int(len(dataTensor) * (1 - configuration['nn']['validationSplit'])):])\\n validationLabel = labels[int(len(labels) * (1 - configuration['nn']['validationSplit'])):]\\n return validationData, validationLabel\",\n \"def getValidationData(data, labels):\\n validationData = []\\n for dataTensor in data:\\n validationData.append(dataTensor[int(len(dataTensor) * (1 - configuration['nn']['validationSplit'])):])\\n validationLabel = labels[int(len(labels) * (1 - configuration['nn']['validationSplit'])):]\\n return validationData, validationLabel\",\n \"def get_data_params(self):\\n\\n minx, maxx = self.get_minx_maxx(normalized=True)\\n\\n # get the column indexes of categorical features after one-hot-encoding\\n self.encoded_categorical_feature_indexes = self.get_encoded_categorical_feature_indexes()\\n\\n return minx, maxx, self.encoded_categorical_feature_indexes\",\n \"def sorted_inputs(self):\\n return self.inputs.order_by(\\\"dataset_idx\\\")\",\n \"def get_training_and_testing_sets(data, Y):\\r\\n data = pd.concat([data, Y], axis=1)\\r\\n x,y=data.shape\\r\\n train_X_sub1=data[0:x//6]\\r\\n dev_X_sub1 = data[x//6:x//6 + x//12]\\r\\n test_X_sub1 = data[x//6 + x//12:x//3]\\r\\n\\r\\n train_X_sub2 = data[x//3:x//3+x//6]\\r\\n dev_X_sub2 = data[x//6 + x//3:x//3 + x//6 + x//12]\\r\\n test_X_sub2 = data[x//3 + x//6 + x//12:2*x//3]\\r\\n\\r\\n train_X_sub3 = data[2*x//3:(2*x//3) +x//6]\\r\\n dev_X_sub3 = data[x//6 + 2*x//3: (2*x//3) + x//6 + x//12]\\r\\n test_X_sub3 = data[2*x//3 + x//6 + x//12:x]\\r\\n\\r\\n train_X=train_X_sub1.append(train_X_sub2,ignore_index = True)\\r\\n train_X =train_X.append(train_X_sub3,ignore_index = True)\\r\\n dev_X= dev_X_sub1.append(dev_X_sub2,ignore_index = True)\\r\\n dev_X = dev_X.append(dev_X_sub3,ignore_index = True)\\r\\n test_X = test_X_sub1.append(test_X_sub2,ignore_index = True)\\r\\n test_X = test_X.append(test_X_sub3,ignore_index = True)\\r\\n\\r\\n\\r\\n train_X = util.shuffle(train_X)\\r\\n train_X = train_X.reset_index(drop=True)\\r\\n\\r\\n dev_X = util.shuffle(dev_X)\\r\\n dev_X = dev_X.reset_index(drop=True)\\r\\n\\r\\n test_X = util.shuffle(test_X)\\r\\n test_X = test_X.reset_index(drop=True)\\r\\n\\r\\n train_X_final=train_X\\r\\n dev_X_final = dev_X\\r\\n test_X_final = test_X\\r\\n x, y = train_X_final.shape\\r\\n train_X = train_X_final.iloc[:, 0:y - 1]\\r\\n train_Y = train_X_final.iloc[:, y - 1]\\r\\n\\r\\n x, y = test_X_final.shape\\r\\n test_X = test_X_final.iloc[:, 0:y - 1]\\r\\n test_Y = test_X_final.iloc[:, y - 1]\\r\\n\\r\\n x, y = dev_X_final.shape\\r\\n dev_X = dev_X_final.iloc[:, 0:y - 1]\\r\\n dev_Y = dev_X_final.iloc[:, y - 1]\\r\\n\\r\\n return train_X, train_Y, dev_X,dev_Y,test_X, test_Y\",\n \"def test_get_indices_several_existing_items(self):\\r\\n control_ids = ['PC.354', 'PC.355', 'PC.356', 'PC.481', 'PC.593']\\r\\n exp_control_indices = [0, 1, 2, 3, 4]\\r\\n\\r\\n fast_ids = ['PC.607', 'PC.634', 'PC.635', 'PC.636']\\r\\n exp_fast_indices = [5, 6, 7, 8]\\r\\n\\r\\n obs_control = _get_indices(self.dist_matrix_header, control_ids)\\r\\n self.assertEqual(obs_control, exp_control_indices)\\r\\n\\r\\n obs_fast = _get_indices(self.dist_matrix_header, fast_ids)\\r\\n self.assertEqual(obs_fast, exp_fast_indices)\",\n \"def train_test_official(self):\\n return self.sub_set(self.idcs_train), self.sub_set(self.idcs_test)\",\n \"def get_insert_indices(my_timestamps, existing_timestamps):\\n existing_timestep = existing_timestamps[1] - existing_timestamps[0]\\n my_timestep = my_timestamps[1] - my_timestamps[0]\\n\\n # make sure the time delta is ok\\n if existing_timestep != my_timestep:\\n raise Exception(\\\"Existing dataset has different timestep (mine=%d, existing=%d)\\\"\\n % (my_timestep, existing_timestep))\\n\\n my_offset = (my_timestamps[0] - existing_timestamps[0]) // existing_timestep\\n my_end = my_offset + len(my_timestamps)\\n\\n return my_offset, my_end\",\n \"def run_idxs(self):\\n return list(range(len(self._h5[RUNS])))\",\n \"def get_valid_indices(labels):\\n idxs = (labels != invalid_labels[0])\\n for l in invalid_labels[1:]:\\n idxs = idxs & (labels != l)\\n return idxs\",\n \"def train_test_indices(n, train_ratio=0.7):\\n train_split_index = int(train_ratio * n)\\n shuffled_indices = np.random.permutation(n)\\n train_indices = shuffled_indices[:train_split_index]\\n test_indices = shuffled_indices[train_split_index:]\\n return train_indices, test_indices\",\n \"def get_query(self, model, train_data, labelled_idx, unlabelled_idx):\\n self.num_steps += 1\\n # if this is the first step, then just return the seed set\\n if self.num_steps == 1:\\n return labelled_idx, unlabelled_idx\\n\\n if self.num_subsample is not None:\\n num_subsample = min(self.num_subsample, len(unlabelled_idx))\\n subsample_idx = random.sample(unlabelled_idx, k=num_subsample)\\n else:\\n subsample_idx = unlabelled_idx\\n\\n pool = Subset(train_data, subsample_idx)\\n labelled = Subset(train_data, labelled_idx)\\n # get ranking of datapoints\\n idx_to_add = self.score(model, pool, labelled)\\n\\n # choose top scoring datapoints to label\\n new_labelled_idx = labelled_idx + [subsample_idx[i] for i in idx_to_add]\\n new_unlabelled_idx = [j for j in range(len(train_data)) if j not in new_labelled_idx]\\n\\n return new_labelled_idx, new_unlabelled_idx\",\n \"def dt_train_test(dt, xTrain, yTrain, xTest, yTest):\\n # train the model\\n dt.train(xTrain, yTrain['label'])\\n # predict the training dataset\\n yHatTrain = dt.predict(xTrain)\\n trainAcc = accuracy_score(yTrain['label'], yHatTrain)\\n # predict the test dataset\\n yHatTest = dt.predict(xTest)\\n testAcc = accuracy_score(yTest['label'], yHatTest)\\n return trainAcc, testAcc\",\n \"def batch_indices(self):\\n b = self.batch_size\\n return [np.arange(i*b, i*b+b) for i in range(self.num_batches)]\",\n \"def make_idx_data(revs, word_idx_map, maxlen=60):\\n X_train, X_test, X_dev, y_train, y_dev,= [], [], [], [], []\\n for rev in revs:\\n sent = get_idx_from_sent(rev['text'], word_idx_map)\\n y = rev['y']\\n if rev['split'] == 1:\\n X_train.append(sent)\\n y_train.append(y)\\n elif rev['split'] == 0:\\n X_dev.append(sent)\\n y_dev.append(y)\\n elif rev['split'] == -1:\\n X_test.append(sent)\\n\\n X_train = sequence.pad_sequences(np.array(X_train), maxlen=maxlen)\\n X_dev = sequence.pad_sequences(np.array(X_dev), maxlen=maxlen)\\n X_test = sequence.pad_sequences(np.array(X_test), maxlen=maxlen)\\n y_train = np_utils.to_categorical(np.array(y_train))\\n y_dev = np_utils.to_categorical(np.array(y_dev))\\n\\n return [X_train, X_test, X_dev, y_train, y_dev,]\",\n \"def load_data():\\n print(\\\"PARSING TRAIN\\\")\\n ys_train, x_train, ids_train = load_pickle_data(\\\"ys_train\\\"), load_pickle_data(\\\"x_train\\\"), load_pickle_data(\\n \\\"ids_train\\\")\\n if ys_train is None or x_train is None or ids_train is None:\\n ys_train, x_train, ids_train = load_csv_data(\\\"{}/train.csv\\\".format(DATA_DIR))\\n dump_pickle_data(ys_train, \\\"ys_train\\\")\\n dump_pickle_data(x_train, \\\"x_train\\\")\\n dump_pickle_data(ids_train, \\\"ids_train\\\")\\n\\n print(\\\"PARSING TEST\\\")\\n x_test, ids_test = load_pickle_data(\\\"x_test\\\"), load_pickle_data(\\\"ids_test\\\")\\n if x_test is None or ids_test is None:\\n _, x_test, ids_test = load_csv_data(\\\"{}/test.csv\\\".format(DATA_DIR))\\n dump_pickle_data(x_test, \\\"x_test\\\")\\n dump_pickle_data(ids_test, \\\"ids_test\\\")\\n\\n return ys_train, x_train, ids_train, x_test, ids_test\",\n \"def train_test_official(self):\\n return self.sub_set(self.train_idcs), self.sub_set(self.test_idcs)\",\n \"def get_train_input(self, prev, i):\\n pass\",\n \"def train_valid_index_split(all_index, train_size = None, valid_split = 0.3):\\n\\tall_index = np.arange(all_index) if isinstance(all_index, int) else np.array(all_index)\\n\\ttrain_size = len(all_index) if train_size is None else train_size\\n\\ttrain_index_ = np.random.choice(all_index, train_size, replace = False)\\n\\ttrain_index, valid_index = np.split(train_index_, [int(train_size*(1-valid_split))])\\n\\treturn train_index, valid_index\",\n \"def ordered_indices(self):\\r\\n '''we need random order'''\\r\\n if self.shuffle:\\r\\n indices = np.random.permutation(len(self))\\r\\n else:\\r\\n indices = np.arange(len(self))\\r\\n '''\\r\\n if self.tgt_sizes is not None:\\r\\n indices = indices[np.argsort(self.tgt_sizes[indices], kind='mergesort')]\\r\\n return indices[np.argsort(self.src_sizes[indices], kind='mergesort')]\\r\\n '''\\r\\n return indices\",\n \"def index_in_epoch(self):\\n return self._index_in_epoch\",\n \"def train_batch_idx(self) -> int:\\n return self._train_batch_idx\",\n \"def index(self):\\n return self._epochs_completed * self._size + self._index_in_epoch\",\n \"def get_dataset_index(\\n dataset: xr.Dataset, time_dataset_index: xr.Dataset\\n) -> xr.Dataset:\\n dataset_index = xr.Dataset()\\n n_steps = len(next(iter(time_dataset_index.values())))\\n for dim, var in dataset.items():\\n if set(var.dims).intersection(time_dataset_index.keys()):\\n time_dim = var.dims[0]\\n assert time_dim in time_dataset_index, (\\n f\\\"'{time_dim}' does not seems to be a time \\\"\\n f\\\"dimensions in {time_dataset_index.keys()}. \\\"\\n \\\"For the moment, only time dimension as first dim is supported.\\\"\\n )\\n dataset_index[dim] = time_dataset_index[time_dim]\\n else:\\n if not onp.shape(var):\\n dataset_index[dim] = xr.DataArray(onp.arange(n_steps), dims=(\\\"step\\\",))\\n else:\\n values_atleast_1d = onp.atleast_1d(var.values)\\n # grid = onp.indices(values_atleast_1d.shape)\\n flat_idx = onp.arange(len(values_atleast_1d.ravel()))\\n dataset_index[dim] = xr.DataArray(\\n onp.outer(onp.arange(n_steps), flat_idx),\\n dims=(\\\"step\\\", dim + \\\"_flat_idx\\\"),\\n )\\n return dataset_index\",\n \"def inidices(self):\\n return [Index(name, index) for name, index in self._data['indices'].iteritems()]\",\n \"def train(self, data, labels, validationData, validationLabels): # data x training, y_training\\n # ## TODO: Your code here\\n count = util.Counter()\\n\\n #print 'Labels of the data is:', labels #printing all the labels from which the frequency has to be found\\n\\n for x in labels: # for loop\\n count[x] += 1\\n\\n #print count\\n val = count.argMax()\\n self.guess = val\\n #print val\",\n \"def shuffle_train(self):\\r\\n if self.data_container.task == 'Classify':\\r\\n id_train_list=[]\\r\\n for i in self.idx_train_list:\\r\\n id_train_list.append(self._random_state.choice(i,self.train_parms[0]))\\r\\n for j in self._random_state.choice(self.unique_value, self.train_parms[1]):\\r\\n id_train_list.append(self._random_state.choice(self.idx_train_list[j],1))\\r\\n self.idx['train'] = np.concatenate(id_train_list, axis=0)\\r\\n \\r\\n self.idx['train'] = self._random_state.permutation(self.idx['train'])\",\n \"def get_valid_indices(self):\\n valid_indices = []\\n for idx in range(len(os.listdir(self.fdir))):\\n with open(os.path.join(self.fdir, f\\\"{idx}.json\\\"), \\\"r\\\") as f:\\n data = json.load(f)\\n if data[\\\"article\\\"] and data[\\\"abstract\\\"]:\\n valid_indices.append(idx)\\n return valid_indices\",\n \"def Train_data():\\n print (\\\"loading train data ...\\\")\\n time_start = time.time()\\n data_root = '/media/keziwen/86AA9651AA963E1D'\\n with h5py.File(join(data_root, './data/train_real2.h5')) as f:\\n data_real = f['train_real'][:]\\n num, nt, ny, nx = data_real.shape\\n data_real = np.transpose(data_real, (0, 1, 3, 2))\\n with h5py.File(join(data_root, './data/train_imag2.h5')) as f:\\n data_imag = f['train_imag'][:]\\n num, nt, ny, nx = data_imag.shape\\n data_imag = np.transpose(data_imag, (0, 1, 3, 2))\\n data = data_real+1j*data_imag\\n num_train = 15000\\n num_validate = 2000\\n train_data = data[0:num_train]\\n validate_data = data[num_train:num_train+num_validate]\\n\\n train_data = np.random.permutation(train_data)\\n\\n time_end = time.time()\\n print ('dataset has been created using {}s'.format(time_end-time_start))\\n return train_data, validate_data\",\n \"def test_train_spl(data, testsize):\\n test = data.tail(testsize)\\n train = data.head(data.shape[0] - testsize)\\n return test, train\",\n \"def _get_indx(self, t):\\n t = np.array(t)\\n a = (t[:, np.newaxis] <= self._data['stop']) & (t[:, np.newaxis] >=\\n self._data['start'])\\n return np.array([np.where(row)[0][0] for row in a])\",\n \"def get_query(self, model, train_data, labelled_idx, unlabelled_idx):\\n self.num_steps += 1\\n # if this is the first step, then just return the seed set\\n if self.num_steps == 1:\\n return labelled_idx, unlabelled_idx\\n\\n if self.num_subsample is not None:\\n num_subsample = min(self.num_subsample, len(unlabelled_idx))\\n subsample_idx = random.sample(unlabelled_idx, k=num_subsample)\\n else:\\n subsample_idx = unlabelled_idx\\n # initialise dataloader. Loads data in order of unlabelled idx\\n pool = Subset(train_data, subsample_idx)\\n\\n # get scores on unlabelled datapoints\\n scores = self.score(model, pool)\\n\\n # choose top scoring datapoints to label\\n num_query = min(self.num_query, len(subsample_idx))\\n idx_to_add = np.argsort(scores)[-num_query:]\\n new_labelled_idx = labelled_idx + [subsample_idx[i] for i in idx_to_add]\\n new_unlabelled_idx = [j for j in range(len(train_data)) if j not in new_labelled_idx]\\n return new_labelled_idx, new_unlabelled_idx\",\n \"def train(self, training_data):\\n pass\",\n \"def train_test_split(coordinates, data, weights=None, **kwargs):\\n args = check_fit_input(coordinates, data, weights, unpack=False)\\n ndata = args[1][0].size\\n indices = np.arange(ndata)\\n split = next(ShuffleSplit(n_splits=1, **kwargs).split(indices))\\n train, test = (tuple(select(i, index) for i in args) for index in split)\\n return train, test\",\n \"def __get_x_y_from_training_validation(\\n logger, training, validation, predictors, target):\\n if training is not None:\\n training_X, training_Y = __get_x_y_from_data(logger, training, predictors, target)\\n if validation is not None:\\n validation_X, validation_Y = __get_x_y_from_data(logger, validation, predictors, target)\\n return training_X, training_Y, validation_X, validation_Y\",\n \"def train(self, training_data, training_labels, validation_data, validation_labels):\\n abstract\",\n \"def get_query(self, model, train_data, labelled_idx, unlabelled_idx):\\n # if this is the first step, then just return the seed set\\n self.num_steps += 1\\n if self.num_steps == 1:\\n return labelled_idx, unlabelled_idx\\n\\n if self.num_subsample is not None:\\n num_subsample = min(self.num_subsample, len(unlabelled_idx))\\n subsample_idx = random.sample(unlabelled_idx, k=num_subsample)\\n else:\\n subsample_idx = unlabelled_idx\\n # initialise dataloader. Loads data in order of unlabelled idx\\n pool = Subset(train_data, subsample_idx)\\n # get scores on unlabelled datapoints\\n scores = self.score(model, pool)\\n\\n # choose top scoring datapoints to label\\n num_query = min(self.num_query, len(subsample_idx))\\n idx_to_add = np.argsort(scores)[-num_query:]\\n new_labelled_idx = labelled_idx + [subsample_idx[i] for i in idx_to_add]\\n new_unlabelled_idx = [j for j in range(len(train_data)) if j not in new_labelled_idx]\\n return new_labelled_idx, new_unlabelled_idx\",\n \"def train_valid_split(X, y):\\n random_indexes = np.random.permutation(len(y))\\n train_inds = random_indexes[:(0.75*len(y))]\\n valid_inds = random_indexes[(0.75*len(y)):]\\n return X[train_inds], y[train_inds], X[valid_inds], y[valid_inds]\",\n \"def pt_index(*args):\\n index = []\\n x = check_pt_data(args[0])\\n i = 0\\n for line in args[0].Data.PTData.pt_data:\\n i += 1\\n if line != x[i - 1]:\\n index.append(0)\\n elif line == x[i - 1]:\\n index.append(i)\\n return index\",\n \"def timeseries_train_test_split(X, y, test_size):\\n\\n # get the index after which test set starts\\n test_index = int(len(X)*(1-test_size))\\n\\n X_train = X.iloc[:test_index]\\n y_train = y.iloc[:test_index]\\n X_test = X.iloc[test_index:]\\n y_test = y.iloc[test_index:]\\n\\n return X_train, X_test, y_train, y_test\",\n \"def ordered_indices(self):\\r\\n return np.arange(len(self), dtype=np.int64)\",\n \"def get_idxvals(self):\\n input_rows = list()\\n input_cols = list()\\n for key in self.index:\\n input_rows.append(key[0])\\n input_cols.append(key[1])\\n\\n return list(OrderedSet(input_rows)), list(OrderedSet(input_cols))\",\n \"def find_index_in_cell(train, test, x_min, y_min, step):\\n data_coor = train['x'].values\\n data_in_x = np.logical_and(data_coor > x_min, data_coor < (x_min + step))\\n data_coor = train['y'].values\\n data_in_y = np.logical_and(data_coor > y_min, data_coor < (y_min + step))\\n data_cell = np.logical_and(data_in_x, data_in_y)\\n train_cell = train.iloc[data_cell]\\n\\n data_coor = test['x'].values\\n data_in_x = np.logical_and(data_coor > x_min, data_coor < (x_min + step))\\n data_coor = test['y'].values\\n data_in_y = np.logical_and(data_coor > y_min, data_coor < (y_min + step))\\n data_cell = np.logical_and(data_in_x, data_in_y)\\n test_cell = test.iloc[data_cell]\\n\\n train_label_col = 'place_id'\\n train_labels = train_cell[train_label_col]\\n del train_cell[train_label_col]\\n\\n return train_cell, test_cell, train_labels\",\n \"def _iter_indices(self, frame, y):\\n n_samples = frame.shape[0]\\n n_train, n_test = _validate_shuffle_split(n_samples,\\n self.test_size, self.train_size)\\n\\n # need to validate y...\\n y = _val_y(y)\\n target = np.asarray(frame[y].as_data_frame(use_pandas=True)[y].tolist())\\n\\n classes, y_indices = np.unique(target, return_inverse=True)\\n n_classes = classes.shape[0]\\n\\n class_counts = bincount(y_indices)\\n if np.min(class_counts) < 2:\\n raise ValueError('The least populated class in y has only 1 '\\n 'member, which is too few. The minimum number of labels '\\n 'for any class cannot be less than 2.')\\n\\n if n_train < n_classes:\\n raise ValueError('The train_size=%d should be greater than or '\\n 'equal to the number of classes=%d' % (n_train, n_classes))\\n\\n if n_test < n_classes:\\n raise ValueError('The test_size=%d should be greater than or '\\n 'equal to the number of classes=%d' % (n_test, n_classes))\\n\\n rng = check_random_state(self.random_state)\\n p_i = class_counts / float(n_samples)\\n n_i = np.round(n_train * p_i).astype(int)\\n t_i = np.minimum(class_counts - n_i, np.round(n_test * p_i).astype(int))\\n\\n for _ in range(self.n_splits):\\n train = []\\n test = []\\n\\n for i, class_i in enumerate(classes):\\n permutation = rng.permutation(class_counts[i])\\n perm_indices_class_i = np.where((target == class_i))[0][permutation]\\n\\n train.extend(perm_indices_class_i[:n_i[i]])\\n test.extend(perm_indices_class_i[n_i[i]:n_i[i] + t_i[i]])\\n\\n # Might end up here with less samples in train and test than we asked\\n # for, due to rounding errors.\\n if len(train) + len(test) < n_train + n_test:\\n missing_indices = np.where(bincount(train + test, minlength=len(target)) == 0)[0]\\n missing_indices = rng.permutation(missing_indices)\\n n_missing_train = n_train - len(train)\\n n_missing_test = n_test - len(test)\\n\\n if n_missing_train > 0:\\n train.extend(missing_indices[:n_missing_train])\\n if n_missing_test > 0:\\n test.extend(missing_indices[-n_missing_test:])\\n\\n train = rng.permutation(train)\\n test = rng.permutation(test)\\n\\n yield train, test\",\n \"def get_relevant_indices(dataset, classes, target_classes):\\n indices = []\\n for i in range(len(dataset)):\\n # Check if the label is in the target classes\\n label_index = dataset[i][1] # ex: 3\\n label_class = classes[label_index] # ex: 'cat'\\n if label_class in target_classes:\\n indices.append(i)\\n return indices\",\n \"def FindIdxValues(X):\\n data = X.select_dtypes(include=[\\\"float64\\\"])\\n idx = np.argwhere(~np.isnan(data.values))\\n idx[:, 1] += 4 # add ID variable columns\\n StoE = pd.read_csv(\\\"msresist/data/MS/CPTAC/IDtoExperiment.csv\\\")\\n assert all(StoE.iloc[:, 0] == data.columns), \\\"Sample labels don't match.\\\"\\n StoE = StoE.iloc[:, 1].values\\n tmt = [[StoE[idx[ii][1] - 4]] for ii in range(idx.shape[0])]\\n return np.append(idx, tmt, axis=1)\",\n \"def get_query(self, model, train_data, labelled_idx, unlabelled_idx):\\n self.num_steps += 1\\n # if this is the first step, then just return the seed set\\n if self.num_steps == 1:\\n return labelled_idx, unlabelled_idx\\n\\n if self.num_subsample is not None:\\n num_subsample = min(self.num_subsample, len(unlabelled_idx))\\n subsample_idx = random.sample(unlabelled_idx, k=num_subsample)\\n else:\\n subsample_idx = unlabelled_idx\\n # initialise dataloader. Loads data in order of unlabelled idx\\n pool = Subset(train_data, subsample_idx)\\n\\n # get scores on unlabelled datapoints\\n scores = self.score(model, pool)\\n # TODO get some metrics on the scores/plot?\\n\\n # choose top scoring datapoints to label\\n num_query = min(self.num_query, len(subsample_idx))\\n idx_to_add = np.argsort(scores)[-num_query:]\\n new_labelled_idx = labelled_idx + [subsample_idx[i] for i in idx_to_add]\\n new_unlabelled_idx = [j for j in range(len(train_data)) if j not in new_labelled_idx]\\n return new_labelled_idx, new_unlabelled_idx\",\n \"def get_dataloaders_with_index(path=\\\"../../data\\\", batch_size=64, num_labeled=250,\\n lbl_idxs=None, unlbl_idxs=None, valid_idxs=None, which_dataset='cifar10', validation=True):\\n\\n # Define transform to normalize data\\n normalize = transforms.Normalize(\\n mean=[0.4914, 0.4822, 0.4465],\\n std=[0.2023, 0.1994, 0.2010],\\n )\\n transform = transforms.Compose([\\n transforms.ToTensor(),\\n normalize,\\n ])\\n\\n if which_dataset == 'cifar10':\\n train_set = CustomCIFAR10(root=path, train=True, transform=transform)\\n test_set = CustomCIFAR10(root=path, train=False, transform=transform)\\n elif which_dataset == 'svhn':\\n train_set = datasets.SVHN(root=path, split='train', download=True, transform=transform)\\n test_set = datasets.SVHN(root=path, split='test', download=True, transform=transform)\\n else:\\n raise Exception('Not supported yet')\\n\\n\\n # Split indexes between labeled, unlabeled and validation\\n if which_dataset == 'cifar10':\\n training_labels = train_set.targets\\n elif which_dataset == 'svhn':\\n training_labels = train_set.labels\\n else :\\n training_labels = train_set.targets\\n\\n if validation:\\n train_labeled_idxs, train_unlabeled_idxs, val_idxs = labeled_unlabeled_val_split(training_labels, int(num_labeled / 10))\\n else:\\n train_labeled_idxs, train_unlabeled_idxs = labeled_unlabeled_split(training_labels, int(num_labeled / 10))\\n val_idxs = []\\n\\n # If indexes are provided, use them\\n if lbl_idxs is not None:\\n train_labeled_idxs = lbl_idxs\\n train_unlabeled_idxs = unlbl_idxs\\n val_idxs = valid_idxs\\n\\n # Define samplers using indexes\\n train_labeled_sampler = SubsetRandomSampler(train_labeled_idxs)\\n train_unlabeled_sampler = SubsetRandomSampler(train_unlabeled_idxs)\\n val_sampler = SubsetRandomSampler(val_idxs)\\n\\n # Create data loaders\\n train_labeled_loader = DataLoader(train_set, batch_size=batch_size, sampler=train_labeled_sampler, num_workers=0)\\n train_unlabeled_loader = DataLoader(train_set, batch_size=batch_size, sampler=train_unlabeled_sampler, num_workers=0)\\n val_loader = DataLoader(train_set, batch_size=batch_size, sampler=val_sampler, num_workers=0)\\n test_loader = DataLoader(test_set, batch_size=batch_size, shuffle=False, num_workers=0)\\n\\n if not validation:\\n val_loader = test_loader\\n\\n return train_labeled_loader, train_unlabeled_loader, val_loader, test_loader, train_labeled_idxs, train_unlabeled_idxs, val_idxs\",\n \"def DataSplit(self, data):\\n train_X,test_X,train_y,test_y=train_test_split(data[0],data[1], random_state=2)\\n valid_X,valid_y=train_test_split(data[0],data[1],random_state=2,test_size=0.15)[1],train_test_split(data[0],data[1],random_state=2,test_size=0.15)[3]\\n return (train_X,test_X,valid_X,train_y,test_y,valid_y)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6553474","0.6376504","0.6233736","0.5944764","0.59190506","0.5901625","0.58788","0.58554393","0.58391976","0.5713936","0.56517017","0.563909","0.56207126","0.56050724","0.5597223","0.5592754","0.55752015","0.5573872","0.5544355","0.5543345","0.55142456","0.54863673","0.54665613","0.54592353","0.5439544","0.5425093","0.5417525","0.540605","0.53963584","0.5385493","0.5346848","0.53380233","0.53228843","0.53082895","0.5307924","0.53043944","0.5291495","0.5289874","0.52824676","0.52793777","0.52676076","0.5266283","0.52631307","0.5254811","0.52469337","0.52409935","0.5239364","0.5237311","0.52353936","0.52246827","0.52230966","0.5202075","0.51943463","0.51943463","0.51880616","0.51842093","0.51774013","0.5174889","0.5174463","0.5168468","0.51682645","0.51605535","0.5154648","0.51538706","0.51487094","0.5147456","0.5147347","0.51407135","0.5136275","0.51277447","0.512179","0.51090187","0.510697","0.5101098","0.51003253","0.50974303","0.5080972","0.5078626","0.50756705","0.50715166","0.50715107","0.50594485","0.50512207","0.50488174","0.5046671","0.50461113","0.5042864","0.5042834","0.5037596","0.50338566","0.503385","0.50285023","0.5026845","0.50262535","0.50236195","0.5003633","0.5001806","0.49987125","0.49944222","0.49873993","0.49855462"],"string":"[\n \"0.6553474\",\n \"0.6376504\",\n \"0.6233736\",\n \"0.5944764\",\n \"0.59190506\",\n \"0.5901625\",\n \"0.58788\",\n \"0.58554393\",\n \"0.58391976\",\n \"0.5713936\",\n \"0.56517017\",\n \"0.563909\",\n \"0.56207126\",\n \"0.56050724\",\n \"0.5597223\",\n \"0.5592754\",\n \"0.55752015\",\n \"0.5573872\",\n \"0.5544355\",\n \"0.5543345\",\n \"0.55142456\",\n \"0.54863673\",\n \"0.54665613\",\n \"0.54592353\",\n \"0.5439544\",\n \"0.5425093\",\n \"0.5417525\",\n \"0.540605\",\n \"0.53963584\",\n \"0.5385493\",\n \"0.5346848\",\n \"0.53380233\",\n \"0.53228843\",\n \"0.53082895\",\n \"0.5307924\",\n \"0.53043944\",\n \"0.5291495\",\n \"0.5289874\",\n \"0.52824676\",\n \"0.52793777\",\n \"0.52676076\",\n \"0.5266283\",\n \"0.52631307\",\n \"0.5254811\",\n \"0.52469337\",\n \"0.52409935\",\n \"0.5239364\",\n \"0.5237311\",\n \"0.52353936\",\n \"0.52246827\",\n \"0.52230966\",\n \"0.5202075\",\n \"0.51943463\",\n \"0.51943463\",\n \"0.51880616\",\n \"0.51842093\",\n \"0.51774013\",\n \"0.5174889\",\n \"0.5174463\",\n \"0.5168468\",\n \"0.51682645\",\n \"0.51605535\",\n \"0.5154648\",\n \"0.51538706\",\n \"0.51487094\",\n \"0.5147456\",\n \"0.5147347\",\n \"0.51407135\",\n \"0.5136275\",\n \"0.51277447\",\n \"0.512179\",\n \"0.51090187\",\n \"0.510697\",\n \"0.5101098\",\n \"0.51003253\",\n \"0.50974303\",\n \"0.5080972\",\n \"0.5078626\",\n \"0.50756705\",\n \"0.50715166\",\n \"0.50715107\",\n \"0.50594485\",\n \"0.50512207\",\n \"0.50488174\",\n \"0.5046671\",\n \"0.50461113\",\n \"0.5042864\",\n \"0.5042834\",\n \"0.5037596\",\n \"0.50338566\",\n \"0.503385\",\n \"0.50285023\",\n \"0.5026845\",\n \"0.50262535\",\n \"0.50236195\",\n \"0.5003633\",\n \"0.5001806\",\n \"0.49987125\",\n \"0.49944222\",\n \"0.49873993\",\n \"0.49855462\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":7290,"cells":{"query":{"kind":"string","value":"Returns the indices without performing any operation on them. To be used for fitting on the whole dataset. This strategy is not compatible with HPO search."},"document":{"kind":"string","value":"def no_resampling(random_state: np.random.RandomState,\n indices: np.ndarray) -> np.ndarray:\n return indices"},"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 indices(self) -> np.ndarray:\n return self.impl.indices","def get_indices(self):\r\n return self._indices","def vir_indices(self):\n indices = []\n for index,item in enumerate(self):\n if item==0:\n indices.append(index)\n return indices","def get_unprescribed_indexes(self):\n total_dof = DOF_PER_NODE_STRUCTURAL * len(self.preprocessor.nodes)\n all_indexes = np.arange(total_dof)\n return np.delete(all_indexes, self.prescribed_indexes)","def _exclude_indices(self):\n idx = self._next_idx\n exclude = np.arange(idx - 1, idx + self.obs_len) % self._maxsize\n return exclude","def get_indexes(self, dataset: BaseDataset) -> int:\n\n index = [np.random.randint(0, len(dataset)) for _ in range(1)]\n\n return index","def _getNonPrototypeIndices(self, clusters: ndarray) -> ndarray:\n return np.delete(np.arange(self.dataSize), clusters.flatten())","def indices(self):\n _indices = []\n for h in self.miller.indices():\n _indices.append(self.indices_hkl(*h)[0])\n return _indices","def indices(self):\n return self.index.indices","def getIndices(self):\r\n return self._indices","def getLandmarkindices(self):\n return self.subsetindices","def indices(self):\n return range(len(self))","def ordered_indices(self):\n return self.base_dataset.ordered_indices()","def get_indexes(self):\n return set(k.index for k in self if k.has_index)","def get_indexes(self, dataset):\n\n for i in range(self.max_iters):\n index = random.randint(0, len(dataset))\n gt_bboxes_i = dataset.get_ann_info(index)['bboxes']\n if len(gt_bboxes_i) != 0:\n break\n\n return index","def getLandmarkindices(self):\n return self.subsetnodes_indices","def get_indexes(self, dataset):\n\n indexs = [random.randint(0, len(dataset)) for _ in range(3)]\n return indexs","def get_indices(self):\n selection_model = self.selectionModel()\n return selection_model.selectedRows()","def get_indexes(self, dataset: BaseDataset) -> int:\n\n indexes = [random.randint(0, len(dataset)) for _ in range(3)]\n return indexes","def indices(self, fit):\r\n lam = self.lam_reeval if self.lam_reeval else 2 + len(fit) / 20\r\n reev = int(lam) + ((lam % 1) > np.random.rand())\r\n return np.argsort(array(fit, copy=False)[:2 * (reev + 1)])[:reev]","def inidices(self):\n return [Index(name, index) for name, index in self._data['indices'].iteritems()]","def indices(self, position=None):\n \n raise NotImplementedError()","def non_masked_indices(mask):\n\treturn np.nonzero(np.ravel(mask-1,order='C'))[0]","def index(self):\n # Check is multiple orders were given\n try:\n orders = list(iter(self.orders))\n except TypeError:\n orders = [self.orders]\n sites = self._epistasismap.sites\n x = [i for i in range(1, len(sites)) if len(sites[i]) in orders]\n # Add the zeroth element if included\n if 0 in orders:\n x = [0] + x\n return np.array(x)","def get_unlabeled_idx(X_train, labeled_idx):\n return np.arange(X_train.shape[0])[np.logical_not(np.in1d(np.arange(X_train.shape[0]), labeled_idx))]","def get_unused_indices(program):\n used = get_used_indices(program)\n all_indices = set(range(len(program.var_types) - 1))\n return all_indices - used","def get_indexes(self):\n indexes = []\n for c in self.components:\n indexes.extend(c.get_indexes())\n return indexes","def indices(self, _user=None):\n return [p.index for p in self.get_active_smallvariant_cases()]","def _free_indicies(self):\n return np.logical_not(self._fixed_indicies)","def indices(self):\n return self._kbounded_partitions","def occ_indices(self):\n indices = []\n for index,item in enumerate(self):\n if item==1:\n indices.append(index)\n return indices","def _selected_indices(self, subset):\n # We want the DataFrame to be indexed the same way its values array is\n ftr = self.frametracks.reset_index(drop=True)\n if subset is not None:\n ftr['tmpindex'] = ftr.index.values\n ftr = ftr.set_index('particle').reindex(subset).set_index('tmpindex')\n if self.autoclip:\n # Boundaries are computed for the whole system\n xmin = self.frametracks.x.min() + self.nncutoff\n xmax = self.frametracks.x.max() - self.nncutoff\n ymin = self.frametracks.y.min() + self.nncutoff\n ymax = self.frametracks.y.max() - self.nncutoff\n r = ftr.index[ (ftr.x > xmin) & (ftr.x < xmax) & \\\n (ftr.y > ymin) & (ftr.y < ymax) ].values.astype(int)\n else:\n r = ftr.index.values.astype(int)\n if self.fast:\n return np.random.permutation(r)[:int(len(r) / 10)]\n else:\n return r","def create_jackknife_indexes(data):\n from numpy import arange, delete\n\n index_range = arange(0, len(data))\n return (delete(index_range, i) for i in index_range)","def get_agent_indices(array):\t\n\tagent_indices = np.argwhere(array != 0)\n\treturn agent_indices","def get_indices ( self, X ):\n \n # Shuffle if `self.shuffle` is true.\n nrows = X.shape [ 0 ]\n return (\n np.random.permutation (\n np.arange ( nrows )\n ) # Shuffle the rows if `self.shuffle`\n if self.shuffle\n else np.arange ( nrows )\n ) # End get_indices()","def get_34index_list(self):\n msk = self.load_mask()\n return [i for (i,v) in enumerate(msk) if v==1]","def drop_indices(self, df) -> None:\n assert self.is_appropriate_data_instance(df)\n # no operation needed","def get_final_pruned_indices(self):\n return self.final_pruned_indices","def all_sampled_nodes_indexes(self) -> torch.LongTensor:\n all_sampled_nodes_indexes: _typing.Any = self.__all_sampled_nodes_indexes\n return all_sampled_nodes_indexes","def indices_of_split(self, split_name='train'):\n return self.indices_of('split', split_name)","def get_data_idx(self)->list:\n return self.__data_idx","def index(self):\n return self.data.index.values","def _compute_indices(self):\n self.indices = np.arange(len(self.im_filenames))\n np.random.shuffle(self.indices)","def get_idxvals(self):\n input_rows = list()\n input_cols = list()\n for key in self.index:\n input_rows.append(key[0])\n input_cols.append(key[1])\n\n return list(OrderedSet(input_rows)), list(OrderedSet(input_cols))","def _get_index(self):\n\n return self.index\n\n # to avoid having differences bigger than 2pi","def master_ndindex(self): # itermaster_indices(self):\n return itertools_product(\n *[range(*r) for r in self.location]\n ) # TODO check","def masked_indices(mask):\n\treturn np.nonzero(np.ravel(mask,order='C'))[0]","def indexing(self):\n return exclusions.closed()","def get_overlapping_indices(self):\n return self._get_atomic_overlaps()","def eligible_edges_with_indexes(self):\n return enumerate(self.edges)","def indices(self):\n if self._indices is None:\n i = []\n\n # TODO: this is not right for multi-column keys\n # TODO: new style indexes\n\n global_name = '^DD(%s,0,\"IX\",\"0\")' % self.fileid\n prefix = '^DD(%s,0,\"IX\",' % self.fileid\n while 1:\n global_name = M.mexec('set s0=$query(%s)' % global_name, M.INOUT(\"\"))[0]\n if not global_name or not global_name.startswith(prefix):\n break\n suffix = global_name[len(prefix):-1]\n parts = suffix.split(\",\")\n idx_name = parts[0][1:-1]\n idx_table = parts[1]\n idx_columns = parts[2:]\n index = Index(idx_name, idx_table, idx_columns)\n i.append(index)\n\n # A second list, gives indices for a field\n columns = {}\n for idx in i:\n for c in idx.columns:\n columns[c] = 1\n\n # Now trawl the listed columns in the data dictionary, and load their\n # cross references.\n cr_names = {}\n for c in columns.keys():\n idx_root = M.Globals[\"^DD\"][self.fileid][c][1]\n if not idx_root[0].exists():\n continue\n for cr_id, val in idx_root.keys_with_decendants():\n if float(cr_id) > 0:\n cr_header = idx_root[cr_id][0].value\n parts = cr_header.split(\"^\")\n if len(parts) == 2 and parts[1]: # if more than 2 parts, assume MUMPs trigger\n f = cr_names.get(parts[1], list())\n f.append(c)\n cr_names[parts[1]] = f\n\n # Now, just delete items from the index list if they are not in cr_names\n self._indices = []\n for index in i:\n cr = cr_names.get(index.name)\n if cr:\n # verify columns - lots of errors in real systems\n if len(cr) == len(index.columns):\n invalid = False\n for c in cr:\n if c not in index.columns:\n invalid = True\n continue\n if not invalid:\n self._indices.append(index)\n\n return self._indices","def get_main_branch_indices(self):\n\n assert self.halt is not None\n prog_main_index = self.halt_index\n prog_main_indices = self.halt.prop(\n 'progenitor.main.indices', self.halt_index)\n self.main_branch_indices = prog_main_indices\n return prog_main_indices","def labeled_indices(self):\n return self._labeled_indices","def indexes(self):\r\n\r\n\r\n if not self.usesequence:\r\n\r\n if len(self.get_all_indexes()) != len(self.sortedindexes) \\\r\n or self.indexchanged or not self.sortedindexes:\r\n self.indexchanged = False\r\n self.sortedindexes = sorted(self.get_all_indexes(),\r\n key=lambda x_temp: Index(x_temp))\r\n return self.sortedindexes\r\n return self.sortedindexes\r\n else:\r\n if self.indexchanged:\r\n self.sortedindexes = self.default_dict['indexlist'].strings()\r\n return self.sortedindexes\r\n else:\r\n return self.sortedindexes","def test_get_indices_no_items_to_search(self):\r\n item_to_find = []\r\n self.assertEqual(_get_indices(self.dist_matrix_header, item_to_find),\r\n [])\r\n item_to_find = ''\r\n self.assertEqual(_get_indices(self.dist_matrix_header, item_to_find),\r\n [])\r\n item_to_find = None\r\n self.assertEqual(_get_indices(self.dist_matrix_header, item_to_find),\r\n [])","def _get_actor_unfilled_indices(self, actor_index, entries_per_buffer):\n filled_indices = set(\n self._get_replay_buffer_filled_indices(self._replay_buffers, actor_index)\n )\n actor_id_set = set(range(0, entries_per_buffer))\n unfilled_indices = actor_id_set - filled_indices\n return unfilled_indices","def get_index(self):\n return self.inverted_index","def get_cached_indices(self, start=None, end=None):\n params = {}\n indices = [\n y[\"sample_identifier\"]\n for y in self.mongo_database.cache.find(\n params, {\"_id\": 0, \"sample_identifier\": 1}\n )[start:end]\n ]\n return np.unique(indices).tolist()","def get_local_indices(self, part, ctx):\n return self.map_to_global(\n F.arange(0, self.local_size(part), ctx=ctx), part\n )","def ordered_indices(self):\r\n return np.arange(len(self), dtype=np.int64)","def query_indices(self):\n\n return set(\n ix for ix in self.es_client.cat.indices(\n index=f'{self.normalized_hostname}-*', h='index'\n ).splitlines()\n )","def get_indexes(self, variable, *args):\n\n return [get_subset_idxs(data, min, max)\n for data, (min, max) in args]","def ordered_indices(self):\n return self.d1.ordered_indices()\n # RETURN BASED ON D1's sizes","def reset_indexes(self) -> None:\n raise NotImplementedError","def get_pulling_indices(self, weight):\n pass","def mainIndices(self):\n return self.i1, self.i2","def untie_everything(self):\r\n self.tied_indices = []","def _get_k_indices(self, ks):\n if self.staticneighs:\n idx_ks = ks\n else:\n idx_ks = [self.ks.index(e) for e in ks]\n return idx_ks","def _fixed_indicies(self):\n fixed_inds = self.constraints == 'fixed'\n return fixed_inds","def get_active_register_indices(self):\n assert self.sketch.ndim == 1, 'Currently only support 1-dimensional sketch.'\n return np.flatnonzero(self.sketch)","def exclude_indices(x, excl):\n # ==========================================================================\n return np.array([x[i] for i in np.arange(len(x)) if i not in excl])","def _notstaticneighs_get_corestored_by_inds_notslice(self, inds):\n inds = [inds] if type(inds) == int else inds\n idxs = []\n for k in range(len(self.idxs)):\n idxs.append([self.idxs[k][i] for i in inds])\n idxs = np.array(idxs) if type(self.idxs) == np.ndarray else idxs\n\n if self.sp_relative_pos is not None:\n sp_relative_pos = []\n for k in range(len(self.sp_relative_pos)):\n sp_relative_pos += [[self.sp_relative_pos[k][i] for i in inds]]\n else:\n sp_relative_pos = None\n return idxs, sp_relative_pos","def test_ks_test_empty_indices():\n out = compute_indices_ks_test([], 1000, mode=\"D+\")\n assert all(o is None for o in out)","def get_prediction_indices(self):\r\n if self.full_df['Dates'][0] > self.full_df['Dates'][len(self.full_df) - 1]:\r\n self.full_df = self.full_df[::-1]\r\n self.full_df.reset_index(inplace=True)\r\n self.full_df.drop('index', axis=1, inplace=True)\r\n date_condition = ((self.full_df['Dates'] <= self.pred_end) &\r\n (self.full_df['Dates'] >= self.pred_start))\r\n self.pred_indices = list(self.full_df[date_condition].index)","def get_analytically_computed_optimization_parameter_indices(self):\n indices = []\n if '/offsetParameterIndices' in self.f:\n indices.extend(self.f['/offsetParameterIndices'])\n\n if '/scalingParameterIndices' in self.f:\n indices.extend(self.f['/scalingParameterIndices'])\n\n if '/sigmaParameterIndices' in self.f:\n indices.extend(self.f['/sigmaParameterIndices'])\n\n return list(set(indices))","def indexes(self):\n return getattr(self, '_indexes', None)","def _get_saved_indices(self, columns):\n # FIXME - assuming that the columns never change\n self._saved_indices = []\n for i in range(len(columns)):\n if self.pattern.match(columns[i]):\n self._saved_indices.append(i)\n return self._saved_indices","def index(self):\n return self.dataset.index","def test_get_indices_several_existing_items(self):\r\n control_ids = ['PC.354', 'PC.355', 'PC.356', 'PC.481', 'PC.593']\r\n exp_control_indices = [0, 1, 2, 3, 4]\r\n\r\n fast_ids = ['PC.607', 'PC.634', 'PC.635', 'PC.636']\r\n exp_fast_indices = [5, 6, 7, 8]\r\n\r\n obs_control = _get_indices(self.dist_matrix_header, control_ids)\r\n self.assertEqual(obs_control, exp_control_indices)\r\n\r\n obs_fast = _get_indices(self.dist_matrix_header, fast_ids)\r\n self.assertEqual(obs_fast, exp_fast_indices)","def get_unread_indexes(self):\n pass","def get_indications(self):\n indications = np.zeros_like(self.predictions)\n for i in range(self.predictions.shape[0]):\n ind = np.where(self.predictions[i, :] - self.labels != 0.0)[0]\n indications[i, ind] = 1.0\n\n return indications","def get_data_indices(aperiodic_mode):\n\n indices = {\n 'CF' : 0,\n 'PW' : 1,\n 'BW' : 2,\n 'offset' : 0,\n 'knee' : 1 if aperiodic_mode == 'knee' else None,\n 'exponent' : 1 if aperiodic_mode == 'fixed' else 2\n }\n\n return indices","def indices(self):\n return tuple([slice(*r) for r in self.location])","def get_5index_list(self):\n msk = self.load_mask()\n return [i for (i,v) in enumerate(msk) if v==0]","def mesh_span_indices(self):\n self._ensure_mesh()\n k2m = self._knots_to_mesh\n return np.where(k2m[1:] != k2m[:-1])[0]","def indexed_dataset(self) -> Dict[int, List]:\n if self.__indexed_dataset is None:\n dataset = self.dataset()\n truncated_dataset = dataset[:1000]\n self.__indexed_dataset = {\n i: dataset[i] for i in range(len(dataset))\n }\n return self.__indexed_dataset","def indices(self):\n i, j, _edge = self.indicesAndEdge()\n return i, j","def clear_indexes(self):\n for keypoints in self:\n keypoints.clear_index()","def discard_none_targets(dataset):\r\n indices = []\r\n for (ii,sample) in enumerate(dataset):\r\n target = sample[1]\r\n if target is not None:\r\n indices.append(ii)\r\n\r\n return Subset(dataset,indices)","def get_cont_indices(self, X, max_ord):\n indices = np.zeros(X.shape[1]).astype(bool)\n for i, col in enumerate(X.T):\n col_nonan = col[~np.isnan(col)]\n col_unique = np.unique(col_nonan)\n if len(col_unique) > max_ord:\n indices[i] = True\n return indices","def nonzero_indices(a):\n return (np.nonzero(a)[0])","def batch_indices(self):\n b = self.batch_size\n return [np.arange(i*b, i*b+b) for i in range(self.num_batches)]","def get_recorded_indices(self, application_vertex, variable):\n if variable not in self.__sampling_rates:\n return []\n if self.__indexes[variable] is None:\n return range(application_vertex.n_atoms)\n return self.__indexes[variable]","def getValidIndicies(self, points):\n try:\n inds = [ i for i in range(points.size) if points.flat[i] in self.maskSet ]\n return inds\n except Exception as error:\n print(\"failed in getValidIndicies\", error)\n return -1","def get_indices(self):\n\n def query(rel): \n return \"\"\"SELECT pg_class.relname, pg_index.indkey\n FROM pg_class, pg_index\n WHERE (pg_index.indexrelid = pg_class.oid)\n AND (pg_index.indrelid = (SELECT pg_class.oid FROM pg_class WHERE pg_class.relname = \\'{}\\'));\n \"\"\".format(rel)\n\n rels = tpch.schema.keys()\n idxs = dict.fromkeys(rels)\n\n with self.tpch_cxn.cursor() as curs:\n for rel in rels:\n curs.execute(query(rel))\n idxs_ = curs.fetchall()\n idxs_ = dict(idxs_) # index -> index keys \n \n # TODO this can be done cleanly in query\n # pg_index.indkey is a SQL array of attributes indices in their respective tables\n split=lambda attrs: attrs.split() \n cast=lambda attrs: list(map(lambda attr: int(attr)-1, attrs))\n invertindex=lambda attrs: list(np.array(schema[rel])[attrs])\n\n attrs = idxs_.values() \n attrs = list(map(split, attrs))\n attrs = list(map(cast, attrs))\n attrs = list(map(invertindex, attrs))\n\n idxs_ = {key : attrs[i] for i, key in enumerate(idxs_.keys())}\n idxs[rel] = idxs_\n return idxs","def indices(online: bool = False) -> dict:\n return _get_indices(online)","def _get_indices(scores: np.ndarray, shuffle_prop: float) -> np.ndarray:\n return _shuffle_subset(scores.argsort().argsort(), shuffle_prop)","def main_rep_idxs(self):\n\n if '{}/{}'.format(SETTINGS, MAIN_REP_IDXS) in self.h5:\n return self.h5['{}/{}'.format(SETTINGS, MAIN_REP_IDXS)][:]\n else:\n return None","def _dofidxs(self):\n return [const['dofidxs'] for i, const in self._constraints_df.iterrows()]","def get_vacancy_indices(array):\t\n\tvacancy_indices = np.argwhere(array == 0)\n\treturn vacancy_indices"],"string":"[\n \"def indices(self) -> np.ndarray:\\n return self.impl.indices\",\n \"def get_indices(self):\\r\\n return self._indices\",\n \"def vir_indices(self):\\n indices = []\\n for index,item in enumerate(self):\\n if item==0:\\n indices.append(index)\\n return indices\",\n \"def get_unprescribed_indexes(self):\\n total_dof = DOF_PER_NODE_STRUCTURAL * len(self.preprocessor.nodes)\\n all_indexes = np.arange(total_dof)\\n return np.delete(all_indexes, self.prescribed_indexes)\",\n \"def _exclude_indices(self):\\n idx = self._next_idx\\n exclude = np.arange(idx - 1, idx + self.obs_len) % self._maxsize\\n return exclude\",\n \"def get_indexes(self, dataset: BaseDataset) -> int:\\n\\n index = [np.random.randint(0, len(dataset)) for _ in range(1)]\\n\\n return index\",\n \"def _getNonPrototypeIndices(self, clusters: ndarray) -> ndarray:\\n return np.delete(np.arange(self.dataSize), clusters.flatten())\",\n \"def indices(self):\\n _indices = []\\n for h in self.miller.indices():\\n _indices.append(self.indices_hkl(*h)[0])\\n return _indices\",\n \"def indices(self):\\n return self.index.indices\",\n \"def getIndices(self):\\r\\n return self._indices\",\n \"def getLandmarkindices(self):\\n return self.subsetindices\",\n \"def indices(self):\\n return range(len(self))\",\n \"def ordered_indices(self):\\n return self.base_dataset.ordered_indices()\",\n \"def get_indexes(self):\\n return set(k.index for k in self if k.has_index)\",\n \"def get_indexes(self, dataset):\\n\\n for i in range(self.max_iters):\\n index = random.randint(0, len(dataset))\\n gt_bboxes_i = dataset.get_ann_info(index)['bboxes']\\n if len(gt_bboxes_i) != 0:\\n break\\n\\n return index\",\n \"def getLandmarkindices(self):\\n return self.subsetnodes_indices\",\n \"def get_indexes(self, dataset):\\n\\n indexs = [random.randint(0, len(dataset)) for _ in range(3)]\\n return indexs\",\n \"def get_indices(self):\\n selection_model = self.selectionModel()\\n return selection_model.selectedRows()\",\n \"def get_indexes(self, dataset: BaseDataset) -> int:\\n\\n indexes = [random.randint(0, len(dataset)) for _ in range(3)]\\n return indexes\",\n \"def indices(self, fit):\\r\\n lam = self.lam_reeval if self.lam_reeval else 2 + len(fit) / 20\\r\\n reev = int(lam) + ((lam % 1) > np.random.rand())\\r\\n return np.argsort(array(fit, copy=False)[:2 * (reev + 1)])[:reev]\",\n \"def inidices(self):\\n return [Index(name, index) for name, index in self._data['indices'].iteritems()]\",\n \"def indices(self, position=None):\\n \\n raise NotImplementedError()\",\n \"def non_masked_indices(mask):\\n\\treturn np.nonzero(np.ravel(mask-1,order='C'))[0]\",\n \"def index(self):\\n # Check is multiple orders were given\\n try:\\n orders = list(iter(self.orders))\\n except TypeError:\\n orders = [self.orders]\\n sites = self._epistasismap.sites\\n x = [i for i in range(1, len(sites)) if len(sites[i]) in orders]\\n # Add the zeroth element if included\\n if 0 in orders:\\n x = [0] + x\\n return np.array(x)\",\n \"def get_unlabeled_idx(X_train, labeled_idx):\\n return np.arange(X_train.shape[0])[np.logical_not(np.in1d(np.arange(X_train.shape[0]), labeled_idx))]\",\n \"def get_unused_indices(program):\\n used = get_used_indices(program)\\n all_indices = set(range(len(program.var_types) - 1))\\n return all_indices - used\",\n \"def get_indexes(self):\\n indexes = []\\n for c in self.components:\\n indexes.extend(c.get_indexes())\\n return indexes\",\n \"def indices(self, _user=None):\\n return [p.index for p in self.get_active_smallvariant_cases()]\",\n \"def _free_indicies(self):\\n return np.logical_not(self._fixed_indicies)\",\n \"def indices(self):\\n return self._kbounded_partitions\",\n \"def occ_indices(self):\\n indices = []\\n for index,item in enumerate(self):\\n if item==1:\\n indices.append(index)\\n return indices\",\n \"def _selected_indices(self, subset):\\n # We want the DataFrame to be indexed the same way its values array is\\n ftr = self.frametracks.reset_index(drop=True)\\n if subset is not None:\\n ftr['tmpindex'] = ftr.index.values\\n ftr = ftr.set_index('particle').reindex(subset).set_index('tmpindex')\\n if self.autoclip:\\n # Boundaries are computed for the whole system\\n xmin = self.frametracks.x.min() + self.nncutoff\\n xmax = self.frametracks.x.max() - self.nncutoff\\n ymin = self.frametracks.y.min() + self.nncutoff\\n ymax = self.frametracks.y.max() - self.nncutoff\\n r = ftr.index[ (ftr.x > xmin) & (ftr.x < xmax) & \\\\\\n (ftr.y > ymin) & (ftr.y < ymax) ].values.astype(int)\\n else:\\n r = ftr.index.values.astype(int)\\n if self.fast:\\n return np.random.permutation(r)[:int(len(r) / 10)]\\n else:\\n return r\",\n \"def create_jackknife_indexes(data):\\n from numpy import arange, delete\\n\\n index_range = arange(0, len(data))\\n return (delete(index_range, i) for i in index_range)\",\n \"def get_agent_indices(array):\\t\\n\\tagent_indices = np.argwhere(array != 0)\\n\\treturn agent_indices\",\n \"def get_indices ( self, X ):\\n \\n # Shuffle if `self.shuffle` is true.\\n nrows = X.shape [ 0 ]\\n return (\\n np.random.permutation (\\n np.arange ( nrows )\\n ) # Shuffle the rows if `self.shuffle`\\n if self.shuffle\\n else np.arange ( nrows )\\n ) # End get_indices()\",\n \"def get_34index_list(self):\\n msk = self.load_mask()\\n return [i for (i,v) in enumerate(msk) if v==1]\",\n \"def drop_indices(self, df) -> None:\\n assert self.is_appropriate_data_instance(df)\\n # no operation needed\",\n \"def get_final_pruned_indices(self):\\n return self.final_pruned_indices\",\n \"def all_sampled_nodes_indexes(self) -> torch.LongTensor:\\n all_sampled_nodes_indexes: _typing.Any = self.__all_sampled_nodes_indexes\\n return all_sampled_nodes_indexes\",\n \"def indices_of_split(self, split_name='train'):\\n return self.indices_of('split', split_name)\",\n \"def get_data_idx(self)->list:\\n return self.__data_idx\",\n \"def index(self):\\n return self.data.index.values\",\n \"def _compute_indices(self):\\n self.indices = np.arange(len(self.im_filenames))\\n np.random.shuffle(self.indices)\",\n \"def get_idxvals(self):\\n input_rows = list()\\n input_cols = list()\\n for key in self.index:\\n input_rows.append(key[0])\\n input_cols.append(key[1])\\n\\n return list(OrderedSet(input_rows)), list(OrderedSet(input_cols))\",\n \"def _get_index(self):\\n\\n return self.index\\n\\n # to avoid having differences bigger than 2pi\",\n \"def master_ndindex(self): # itermaster_indices(self):\\n return itertools_product(\\n *[range(*r) for r in self.location]\\n ) # TODO check\",\n \"def masked_indices(mask):\\n\\treturn np.nonzero(np.ravel(mask,order='C'))[0]\",\n \"def indexing(self):\\n return exclusions.closed()\",\n \"def get_overlapping_indices(self):\\n return self._get_atomic_overlaps()\",\n \"def eligible_edges_with_indexes(self):\\n return enumerate(self.edges)\",\n \"def indices(self):\\n if self._indices is None:\\n i = []\\n\\n # TODO: this is not right for multi-column keys\\n # TODO: new style indexes\\n\\n global_name = '^DD(%s,0,\\\"IX\\\",\\\"0\\\")' % self.fileid\\n prefix = '^DD(%s,0,\\\"IX\\\",' % self.fileid\\n while 1:\\n global_name = M.mexec('set s0=$query(%s)' % global_name, M.INOUT(\\\"\\\"))[0]\\n if not global_name or not global_name.startswith(prefix):\\n break\\n suffix = global_name[len(prefix):-1]\\n parts = suffix.split(\\\",\\\")\\n idx_name = parts[0][1:-1]\\n idx_table = parts[1]\\n idx_columns = parts[2:]\\n index = Index(idx_name, idx_table, idx_columns)\\n i.append(index)\\n\\n # A second list, gives indices for a field\\n columns = {}\\n for idx in i:\\n for c in idx.columns:\\n columns[c] = 1\\n\\n # Now trawl the listed columns in the data dictionary, and load their\\n # cross references.\\n cr_names = {}\\n for c in columns.keys():\\n idx_root = M.Globals[\\\"^DD\\\"][self.fileid][c][1]\\n if not idx_root[0].exists():\\n continue\\n for cr_id, val in idx_root.keys_with_decendants():\\n if float(cr_id) > 0:\\n cr_header = idx_root[cr_id][0].value\\n parts = cr_header.split(\\\"^\\\")\\n if len(parts) == 2 and parts[1]: # if more than 2 parts, assume MUMPs trigger\\n f = cr_names.get(parts[1], list())\\n f.append(c)\\n cr_names[parts[1]] = f\\n\\n # Now, just delete items from the index list if they are not in cr_names\\n self._indices = []\\n for index in i:\\n cr = cr_names.get(index.name)\\n if cr:\\n # verify columns - lots of errors in real systems\\n if len(cr) == len(index.columns):\\n invalid = False\\n for c in cr:\\n if c not in index.columns:\\n invalid = True\\n continue\\n if not invalid:\\n self._indices.append(index)\\n\\n return self._indices\",\n \"def get_main_branch_indices(self):\\n\\n assert self.halt is not None\\n prog_main_index = self.halt_index\\n prog_main_indices = self.halt.prop(\\n 'progenitor.main.indices', self.halt_index)\\n self.main_branch_indices = prog_main_indices\\n return prog_main_indices\",\n \"def labeled_indices(self):\\n return self._labeled_indices\",\n \"def indexes(self):\\r\\n\\r\\n\\r\\n if not self.usesequence:\\r\\n\\r\\n if len(self.get_all_indexes()) != len(self.sortedindexes) \\\\\\r\\n or self.indexchanged or not self.sortedindexes:\\r\\n self.indexchanged = False\\r\\n self.sortedindexes = sorted(self.get_all_indexes(),\\r\\n key=lambda x_temp: Index(x_temp))\\r\\n return self.sortedindexes\\r\\n return self.sortedindexes\\r\\n else:\\r\\n if self.indexchanged:\\r\\n self.sortedindexes = self.default_dict['indexlist'].strings()\\r\\n return self.sortedindexes\\r\\n else:\\r\\n return self.sortedindexes\",\n \"def test_get_indices_no_items_to_search(self):\\r\\n item_to_find = []\\r\\n self.assertEqual(_get_indices(self.dist_matrix_header, item_to_find),\\r\\n [])\\r\\n item_to_find = ''\\r\\n self.assertEqual(_get_indices(self.dist_matrix_header, item_to_find),\\r\\n [])\\r\\n item_to_find = None\\r\\n self.assertEqual(_get_indices(self.dist_matrix_header, item_to_find),\\r\\n [])\",\n \"def _get_actor_unfilled_indices(self, actor_index, entries_per_buffer):\\n filled_indices = set(\\n self._get_replay_buffer_filled_indices(self._replay_buffers, actor_index)\\n )\\n actor_id_set = set(range(0, entries_per_buffer))\\n unfilled_indices = actor_id_set - filled_indices\\n return unfilled_indices\",\n \"def get_index(self):\\n return self.inverted_index\",\n \"def get_cached_indices(self, start=None, end=None):\\n params = {}\\n indices = [\\n y[\\\"sample_identifier\\\"]\\n for y in self.mongo_database.cache.find(\\n params, {\\\"_id\\\": 0, \\\"sample_identifier\\\": 1}\\n )[start:end]\\n ]\\n return np.unique(indices).tolist()\",\n \"def get_local_indices(self, part, ctx):\\n return self.map_to_global(\\n F.arange(0, self.local_size(part), ctx=ctx), part\\n )\",\n \"def ordered_indices(self):\\r\\n return np.arange(len(self), dtype=np.int64)\",\n \"def query_indices(self):\\n\\n return set(\\n ix for ix in self.es_client.cat.indices(\\n index=f'{self.normalized_hostname}-*', h='index'\\n ).splitlines()\\n )\",\n \"def get_indexes(self, variable, *args):\\n\\n return [get_subset_idxs(data, min, max)\\n for data, (min, max) in args]\",\n \"def ordered_indices(self):\\n return self.d1.ordered_indices()\\n # RETURN BASED ON D1's sizes\",\n \"def reset_indexes(self) -> None:\\n raise NotImplementedError\",\n \"def get_pulling_indices(self, weight):\\n pass\",\n \"def mainIndices(self):\\n return self.i1, self.i2\",\n \"def untie_everything(self):\\r\\n self.tied_indices = []\",\n \"def _get_k_indices(self, ks):\\n if self.staticneighs:\\n idx_ks = ks\\n else:\\n idx_ks = [self.ks.index(e) for e in ks]\\n return idx_ks\",\n \"def _fixed_indicies(self):\\n fixed_inds = self.constraints == 'fixed'\\n return fixed_inds\",\n \"def get_active_register_indices(self):\\n assert self.sketch.ndim == 1, 'Currently only support 1-dimensional sketch.'\\n return np.flatnonzero(self.sketch)\",\n \"def exclude_indices(x, excl):\\n # ==========================================================================\\n return np.array([x[i] for i in np.arange(len(x)) if i not in excl])\",\n \"def _notstaticneighs_get_corestored_by_inds_notslice(self, inds):\\n inds = [inds] if type(inds) == int else inds\\n idxs = []\\n for k in range(len(self.idxs)):\\n idxs.append([self.idxs[k][i] for i in inds])\\n idxs = np.array(idxs) if type(self.idxs) == np.ndarray else idxs\\n\\n if self.sp_relative_pos is not None:\\n sp_relative_pos = []\\n for k in range(len(self.sp_relative_pos)):\\n sp_relative_pos += [[self.sp_relative_pos[k][i] for i in inds]]\\n else:\\n sp_relative_pos = None\\n return idxs, sp_relative_pos\",\n \"def test_ks_test_empty_indices():\\n out = compute_indices_ks_test([], 1000, mode=\\\"D+\\\")\\n assert all(o is None for o in out)\",\n \"def get_prediction_indices(self):\\r\\n if self.full_df['Dates'][0] > self.full_df['Dates'][len(self.full_df) - 1]:\\r\\n self.full_df = self.full_df[::-1]\\r\\n self.full_df.reset_index(inplace=True)\\r\\n self.full_df.drop('index', axis=1, inplace=True)\\r\\n date_condition = ((self.full_df['Dates'] <= self.pred_end) &\\r\\n (self.full_df['Dates'] >= self.pred_start))\\r\\n self.pred_indices = list(self.full_df[date_condition].index)\",\n \"def get_analytically_computed_optimization_parameter_indices(self):\\n indices = []\\n if '/offsetParameterIndices' in self.f:\\n indices.extend(self.f['/offsetParameterIndices'])\\n\\n if '/scalingParameterIndices' in self.f:\\n indices.extend(self.f['/scalingParameterIndices'])\\n\\n if '/sigmaParameterIndices' in self.f:\\n indices.extend(self.f['/sigmaParameterIndices'])\\n\\n return list(set(indices))\",\n \"def indexes(self):\\n return getattr(self, '_indexes', None)\",\n \"def _get_saved_indices(self, columns):\\n # FIXME - assuming that the columns never change\\n self._saved_indices = []\\n for i in range(len(columns)):\\n if self.pattern.match(columns[i]):\\n self._saved_indices.append(i)\\n return self._saved_indices\",\n \"def index(self):\\n return self.dataset.index\",\n \"def test_get_indices_several_existing_items(self):\\r\\n control_ids = ['PC.354', 'PC.355', 'PC.356', 'PC.481', 'PC.593']\\r\\n exp_control_indices = [0, 1, 2, 3, 4]\\r\\n\\r\\n fast_ids = ['PC.607', 'PC.634', 'PC.635', 'PC.636']\\r\\n exp_fast_indices = [5, 6, 7, 8]\\r\\n\\r\\n obs_control = _get_indices(self.dist_matrix_header, control_ids)\\r\\n self.assertEqual(obs_control, exp_control_indices)\\r\\n\\r\\n obs_fast = _get_indices(self.dist_matrix_header, fast_ids)\\r\\n self.assertEqual(obs_fast, exp_fast_indices)\",\n \"def get_unread_indexes(self):\\n pass\",\n \"def get_indications(self):\\n indications = np.zeros_like(self.predictions)\\n for i in range(self.predictions.shape[0]):\\n ind = np.where(self.predictions[i, :] - self.labels != 0.0)[0]\\n indications[i, ind] = 1.0\\n\\n return indications\",\n \"def get_data_indices(aperiodic_mode):\\n\\n indices = {\\n 'CF' : 0,\\n 'PW' : 1,\\n 'BW' : 2,\\n 'offset' : 0,\\n 'knee' : 1 if aperiodic_mode == 'knee' else None,\\n 'exponent' : 1 if aperiodic_mode == 'fixed' else 2\\n }\\n\\n return indices\",\n \"def indices(self):\\n return tuple([slice(*r) for r in self.location])\",\n \"def get_5index_list(self):\\n msk = self.load_mask()\\n return [i for (i,v) in enumerate(msk) if v==0]\",\n \"def mesh_span_indices(self):\\n self._ensure_mesh()\\n k2m = self._knots_to_mesh\\n return np.where(k2m[1:] != k2m[:-1])[0]\",\n \"def indexed_dataset(self) -> Dict[int, List]:\\n if self.__indexed_dataset is None:\\n dataset = self.dataset()\\n truncated_dataset = dataset[:1000]\\n self.__indexed_dataset = {\\n i: dataset[i] for i in range(len(dataset))\\n }\\n return self.__indexed_dataset\",\n \"def indices(self):\\n i, j, _edge = self.indicesAndEdge()\\n return i, j\",\n \"def clear_indexes(self):\\n for keypoints in self:\\n keypoints.clear_index()\",\n \"def discard_none_targets(dataset):\\r\\n indices = []\\r\\n for (ii,sample) in enumerate(dataset):\\r\\n target = sample[1]\\r\\n if target is not None:\\r\\n indices.append(ii)\\r\\n\\r\\n return Subset(dataset,indices)\",\n \"def get_cont_indices(self, X, max_ord):\\n indices = np.zeros(X.shape[1]).astype(bool)\\n for i, col in enumerate(X.T):\\n col_nonan = col[~np.isnan(col)]\\n col_unique = np.unique(col_nonan)\\n if len(col_unique) > max_ord:\\n indices[i] = True\\n return indices\",\n \"def nonzero_indices(a):\\n return (np.nonzero(a)[0])\",\n \"def batch_indices(self):\\n b = self.batch_size\\n return [np.arange(i*b, i*b+b) for i in range(self.num_batches)]\",\n \"def get_recorded_indices(self, application_vertex, variable):\\n if variable not in self.__sampling_rates:\\n return []\\n if self.__indexes[variable] is None:\\n return range(application_vertex.n_atoms)\\n return self.__indexes[variable]\",\n \"def getValidIndicies(self, points):\\n try:\\n inds = [ i for i in range(points.size) if points.flat[i] in self.maskSet ]\\n return inds\\n except Exception as error:\\n print(\\\"failed in getValidIndicies\\\", error)\\n return -1\",\n \"def get_indices(self):\\n\\n def query(rel): \\n return \\\"\\\"\\\"SELECT pg_class.relname, pg_index.indkey\\n FROM pg_class, pg_index\\n WHERE (pg_index.indexrelid = pg_class.oid)\\n AND (pg_index.indrelid = (SELECT pg_class.oid FROM pg_class WHERE pg_class.relname = \\\\'{}\\\\'));\\n \\\"\\\"\\\".format(rel)\\n\\n rels = tpch.schema.keys()\\n idxs = dict.fromkeys(rels)\\n\\n with self.tpch_cxn.cursor() as curs:\\n for rel in rels:\\n curs.execute(query(rel))\\n idxs_ = curs.fetchall()\\n idxs_ = dict(idxs_) # index -> index keys \\n \\n # TODO this can be done cleanly in query\\n # pg_index.indkey is a SQL array of attributes indices in their respective tables\\n split=lambda attrs: attrs.split() \\n cast=lambda attrs: list(map(lambda attr: int(attr)-1, attrs))\\n invertindex=lambda attrs: list(np.array(schema[rel])[attrs])\\n\\n attrs = idxs_.values() \\n attrs = list(map(split, attrs))\\n attrs = list(map(cast, attrs))\\n attrs = list(map(invertindex, attrs))\\n\\n idxs_ = {key : attrs[i] for i, key in enumerate(idxs_.keys())}\\n idxs[rel] = idxs_\\n return idxs\",\n \"def indices(online: bool = False) -> dict:\\n return _get_indices(online)\",\n \"def _get_indices(scores: np.ndarray, shuffle_prop: float) -> np.ndarray:\\n return _shuffle_subset(scores.argsort().argsort(), shuffle_prop)\",\n \"def main_rep_idxs(self):\\n\\n if '{}/{}'.format(SETTINGS, MAIN_REP_IDXS) in self.h5:\\n return self.h5['{}/{}'.format(SETTINGS, MAIN_REP_IDXS)][:]\\n else:\\n return None\",\n \"def _dofidxs(self):\\n return [const['dofidxs'] for i, const in self._constraints_df.iterrows()]\",\n \"def get_vacancy_indices(array):\\t\\n\\tvacancy_indices = np.argwhere(array == 0)\\n\\treturn vacancy_indices\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7181901","0.69676125","0.69128466","0.6892532","0.68412507","0.67869836","0.6754658","0.67145926","0.6703281","0.66633874","0.65803033","0.6534292","0.6509533","0.64898914","0.6441676","0.6402624","0.63538474","0.6317454","0.6311111","0.6274377","0.62597823","0.61934173","0.6184967","0.61595553","0.6139873","0.6131104","0.61173064","0.61140794","0.60923517","0.60844386","0.60834616","0.6048968","0.6044923","0.604333","0.60267025","0.6018209","0.60120195","0.5997289","0.59921813","0.59745514","0.5969518","0.59615505","0.5959979","0.594442","0.592906","0.59277785","0.5921589","0.59213626","0.59092915","0.59091157","0.590873","0.5908398","0.5899501","0.5879913","0.58794636","0.58774966","0.5875598","0.587039","0.58675563","0.5866331","0.58522666","0.5850105","0.5848071","0.58422244","0.5827174","0.58257365","0.5825301","0.582299","0.5814833","0.5814449","0.58019155","0.5800825","0.57961255","0.57934785","0.5780337","0.57793057","0.5775312","0.576487","0.57564765","0.575372","0.5752068","0.57451147","0.57406557","0.57380444","0.5732746","0.57260627","0.5711779","0.5704463","0.56967676","0.56938285","0.56898373","0.5671925","0.56660926","0.56602806","0.5657068","0.5654192","0.5650681","0.5643973","0.56419224","0.5640484"],"string":"[\n \"0.7181901\",\n \"0.69676125\",\n \"0.69128466\",\n \"0.6892532\",\n \"0.68412507\",\n \"0.67869836\",\n \"0.6754658\",\n \"0.67145926\",\n \"0.6703281\",\n \"0.66633874\",\n \"0.65803033\",\n \"0.6534292\",\n \"0.6509533\",\n \"0.64898914\",\n \"0.6441676\",\n \"0.6402624\",\n \"0.63538474\",\n \"0.6317454\",\n \"0.6311111\",\n \"0.6274377\",\n \"0.62597823\",\n \"0.61934173\",\n \"0.6184967\",\n \"0.61595553\",\n \"0.6139873\",\n \"0.6131104\",\n \"0.61173064\",\n \"0.61140794\",\n \"0.60923517\",\n \"0.60844386\",\n \"0.60834616\",\n \"0.6048968\",\n \"0.6044923\",\n \"0.604333\",\n \"0.60267025\",\n \"0.6018209\",\n \"0.60120195\",\n \"0.5997289\",\n \"0.59921813\",\n \"0.59745514\",\n \"0.5969518\",\n \"0.59615505\",\n \"0.5959979\",\n \"0.594442\",\n \"0.592906\",\n \"0.59277785\",\n \"0.5921589\",\n \"0.59213626\",\n \"0.59092915\",\n \"0.59091157\",\n \"0.590873\",\n \"0.5908398\",\n \"0.5899501\",\n \"0.5879913\",\n \"0.58794636\",\n \"0.58774966\",\n \"0.5875598\",\n \"0.587039\",\n \"0.58675563\",\n \"0.5866331\",\n \"0.58522666\",\n \"0.5850105\",\n \"0.5848071\",\n \"0.58422244\",\n \"0.5827174\",\n \"0.58257365\",\n \"0.5825301\",\n \"0.582299\",\n \"0.5814833\",\n \"0.5814449\",\n \"0.58019155\",\n \"0.5800825\",\n \"0.57961255\",\n \"0.57934785\",\n \"0.5780337\",\n \"0.57793057\",\n \"0.5775312\",\n \"0.576487\",\n \"0.57564765\",\n \"0.575372\",\n \"0.5752068\",\n \"0.57451147\",\n \"0.57406557\",\n \"0.57380444\",\n \"0.5732746\",\n \"0.57260627\",\n \"0.5711779\",\n \"0.5704463\",\n \"0.56967676\",\n \"0.56938285\",\n \"0.56898373\",\n \"0.5671925\",\n \"0.56660926\",\n \"0.56602806\",\n \"0.5657068\",\n \"0.5654192\",\n \"0.5650681\",\n \"0.5643973\",\n \"0.56419224\",\n \"0.5640484\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65598696"},"document_rank":{"kind":"string","value":"11"}}},{"rowIdx":7291,"cells":{"query":{"kind":"string","value":"Get open accounts Returns array with active account numbers"},"document":{"kind":"string","value":"async def get_open_accounts(self):\n result = []\n URL = API_HOST + \"/api/resources/header\"\n async with async_timeout.timeout(TIMEOUT):\n response = await self.session.get(URL)\n\n json_data = await response.json()\n accounts = json_data[\"data\"][\"accounts\"][\"data\"][\"data\"]\n\n for account in accounts:\n if account[\"statusCategory\"] == STATUS_CATEGORY_OPEN:\n result.append(account[\"accountNumber\"])\n\n return result"},"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_accounts(self):\n\n data = {\n 'customerId': self.personal_identity_number,\n 'responseControl': {\n 'filter': {\n 'includes': ['ALL']\n }\n }\n }\n\n headers = {'Content-type': 'application/json',\n 'Accept': 'application/json',\n 'CSRFToken': self.json_token}\n path = '/im/json/overview/getaccounts'\n req = self.session.post(\n self.BASE_URL + path,\n data=json.dumps(data),\n headers=headers)\n\n for account in req.json()['response']['accounts']:\n self.accounts[account['number']] = account\n del(self.accounts[account['number']]['number'])\n\n return self.accounts","def list_active_customers():\n active_customers = 0\n for customer in cm.Customers:\n if customer.status == \"Active \":\n active_customers += 1\n return active_customers","def list_accounts(self):\n pass","def getConnectedAccounts(**kwargs):\n strProdURL = kwargs[\"strProdURL\"]\n orgID = kwargs[\"ORG_ID\"]\n sessiontoken = kwargs[\"sessiontoken\"]\n\n accounts = get_connected_accounts_json(strProdURL, orgID, sessiontoken)\n orgtable = PrettyTable(['OrgID'])\n orgtable.add_row([orgID])\n print(str(orgtable))\n table = PrettyTable(['Account Number','id'])\n for i in accounts:\n table.add_row([i['account_number'],i['id']])\n \n print(\"Connected Accounts\")\n print(table)","def get_accounts(self):\r\n return self._accounts","def get_accounts(self):\n return self.accounts","def query_accounts(self):\n return self._call_txtrader_api('query_accounts', {})","def fetch_accounts(self):\n return self.fetch('/accounts')","def returnOpenOrders(self, account=None):\n if not account:\n if \"default_account\" in config:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n\n orders = self.dpay.rpc.get_open_orders(account, limit=1000)\n return orders","def get_accounts(self):\n return self.accounts.all()","def accounts(self):\r\n return acc.Accounts(self)","def get_accounts(self):\n\n\t\treturn self.__accounts","def fetch_owner_accounts():\n resp = oauth.tapkey.get('Owners')\n owner_accounts = resp.json()\n return owner_accounts","def list_active_customers():\n db_customers = Customers.select()\n LOGGER.debug(\"Calculating number of active customers\")\n # Technically used this in Lesson 03, but it is a comprehension. Another method added below.\n number_active = sum([int(x.status) for x in db_customers])\n LOGGER.info(\"There are %d active customers\", number_active)\n\n return number_active","def list_active_customers():\n customer_active = Customer.select().where(Customer.status == 'Active')\n print('{} Active Customers'.format(len(customer_active)))\n return len(customer_active)","def GetAccountList(self):\n\t\treturn self.accounts.keys()","def list_active_customer():\n active_customer = Customer.select().where(Customer.is_active).count()\n LOGGER.info('Number of active customers retrieved.')\n return active_customer","def get_accounts():\n graph = facebook.GraphAPI(mytoken)\n pages = graph.get_object('me/accounts')\n pages_info=[]\n for page in pages['data']:\n pages_info.append( ( page['name'], page['access_token'] ) )\n return pages_info","def accounts_info(self):\r\n param = {}\r\n param['appid'] = self.apiKey\r\n param['nonce'] = int(time.time() * 1000)\r\n param['timestamp'] = int(time.time())\r\n return self.__signed_GET('/api/v1/account/all', param, self.timeout)","def list_active_customers():\n init_database()\n return Customer.select().where(Customer.active_status).count()","def display_accounts(cls):\n return cls.account_list","def list_accounts(min_conf=1):\n min_conf = str(min_conf)\n try:\n stdout = subprocess.check_output([\"litecoin-cli\", \"listaccounts\", min_conf])\n accounts = json.loads(stdout.decode())\n except:\n sys.exit(1)\n\n return accounts","def list_active_customers():\n with cm.DATABASE.transaction():\n # .select() has a .where() method to specify criteria for searching\n active_customers = cm.Customer.select().where(\n cm.Customer.status == \"Active\").count()\n LOGGER.info(\"Active customers: %s\", active_customers)\n return active_customers","def getactiveusers(self):\n\n select_activeusers = (\n \"SELECT count(DISTINCT username) FROM public.jobs \"\n \"WHERE latestjobversion = True AND insertdate BETWEEN Date(%s) AND Date(%s) \"\n \"AND (username NOT IN (%s)) \"\n )\n\n\n self.pgcursor.execute(select_activeusers, (self.startdate, self.enddate, self.adminusers))\n\n activeusers = 0\n x = self.pgcursor.fetchone()\n if x is not None:\n activeusers = x[0]\n\n # print(\"No of active users: {0}\".format(activeusers))\n return activeusers","def active_users(self, *args, **kwargs):\r\n return self._get('ActiveUsers', *args, **kwargs)","def list(ctx):\n if ctx.obj.get('NAMESPACE') != 'accounts':\n click.echo(\n click.style('Only account data is available for listing.', fg='red')\n )\n return\n\n swag = create_swag_from_ctx(ctx)\n accounts = swag.get_all()\n _table = [[result['name'], result.get('id')] for result in accounts]\n click.echo(\n tabulate(_table, headers=[\"Account Name\", \"Account Number\"])\n )","def get_open_orders(self):\n url = 'https://coincheck.com/api/exchange/orders/opens'\n headers = make_header(url, access_key=self.access_key, secret_key=self.secret_key)\n r = requests.get(url, headers=headers, timeout=self.timeout)\n return json.loads(r.text)","def list_active_customers():\n return Customer.select().where(Customer.is_active).count()","def accounts(self):\n return self._accounts.values()","def return_active_users():\n return json.dumps(app.active_users)","def list_active_customers():\n with database.transaction():\n query = (Customer\n .select(fn.COUNT(Customer.status).alias('count'))\n .where(Customer.status == 'Active'))\n LOGGER.info(query)\n\n customer_count = [item.count for item in query]\n LOGGER.info('Number of active customers: %s', customer_count[0])\n\n return customer_count[0]","def retrieve_open_issues(self):\n return self._retrieve_issues(\"open\")","def list_active_customers():\n count_query = (Customer\n .select(Customer, fn.COUNT(Customer.name)\n .alias('cust_count'))\n .where(Customer.status == 'active'))\n for count in count_query:\n return count.cust_count","def get_open_transactions(self):\n return self.__open_transactions[:]","def get_accounts(self):\n me = objects.AdUser(fbid=\"me\")\n my_accounts = list(me.get_ad_accounts(fields=[\n 'id',\n 'name',\n 'timezone_name',\n 'amount_spent',\n 'currency']))\n return my_accounts","def list_active_customers():\n try:\n active_customer_count = 0\n for _ in Customer.select().where(Customer.status == 'Active'):\n active_customer_count += 1\n return active_customer_count\n except Exception as unknown_error:\n print(f'Error. Not able to count number of active customers. {unknown_error}')","async def get_open_order_nos(self):\n success, error = await self._rest_api.get_open_orders(self._raw_symbol)\n if error:\n return None, error\n order_nos = []\n for order_info in success:\n order_no = \"{}_{}\".format(order_info[\"orderId\"], order_info[\"clientOrderId\"])\n order_nos.append(order_no)\n return order_nos, None","def listaccounts(self, minconf=1, as_dict=False):\n if as_dict:\n return dict(self.proxy.listaccounts(minconf))\n else:\n return list(self.proxy.listaccounts(minconf).keys())","def test_getTopAcounts(self, **params):\n req = Account.getTopAccounts()\n print(req)\n self.assertEqual(req['success'], True)","def get_in_active_users(self) -> tuple:\n users_list: dict_list_type = [user.to_dict() for user in UserModel.query(UserModel.is_active == False).fetch()]\n return jsonify({'status': True, 'payload': users_list, 'message': 'successfully retrieved active users'}), 200","def list_active_customers():\n try:\n active_customer_count = 0\n for _ in Customer.select().where(Customer.status == 'Active'):\n active_customer_count += 1\n logger.info(\n f\"Successfully counted active customers {active_customer_count}\"\n )\n return active_customer_count\n except Exception as unknown_error:\n logger.error(f\"Error. Failed to count customers. {unknown_error}\")\n print(\n f'Error. Not able to count number of active customers.'\n ' {unknown_error}'\n )","async def get_open_order_nos(self):\n success, error = await self._rest_api.get_open_orders(self._raw_symbol)\n if error:\n return None, error\n else:\n order_nos = []\n for order_info in success:\n order_no = \"{}_{}\".format(order_info[\"orderId\"], order_info[\"clientOrderId\"])\n order_nos.append(order_no)\n return order_nos, None","def accounts_inactive(request):\r\n user_list = UserMgr.get_list(active=False)\r\n ret = {\r\n 'count': len(user_list),\r\n 'users': [dict(h) for h in user_list],\r\n }\r\n return _api_response(request, ret)","def get_open_orders(self, market):\n #{'success': True, 'message': '', 'result': [{'Uuid': None, 'OrderUuid': '7f43f22f-586b-46d8-a4b2-f457cfeb2aac', 'Exchange': 'BTC-GEO', 'OrderType': 'LIMIT_SELL', 'Quantity': 2.03478908, 'QuantityRemaining': 2.03478908, 'Limit': 0.00097503, 'CommissionPaid': 0.0, 'Price': 0.0, 'PricePerUnit': None, 'Opened': '2017-07-03T14:13:20.903', 'Closed': None, 'CancelInitiated': False, 'ImmediateOrCancel': False, 'IsConditional': False, 'Condition': 'NONE', 'ConditionTarget': None}]}\n #{'success': 1, 'return': {'240005185729406': {'pair': 'lsk_btc', 'type': 'sell', 'amount': 1, 'rate': 0.096319, 'timestamp_created': '1499255345', 'status': 0}}}\n result = self.api_query('ActiveOrders', {'pair': market})\n\n openOrder =[]\n if result['success'] == 1:\n try :\n for key, value in result['return'].items():\n openOrder.append({'OrderUuid':key})\n result = {'success': True, 'message': '', 'result' : openOrder}\n except:\n result = {'success': False, 'message': '', 'result': openOrder}\n else:\n result = {'success': False, 'message': '', 'result': openOrder}\n\n return result","def accounts(self):\n if self._accounts is None:\n url = f'{self._ynab.api_url}/budgets/{self.id}/accounts'\n response = self._ynab.session.get(url)\n if not response.ok:\n self._logger.error('Error retrieving accounts, response was : %s with status code : %s',\n response.text,\n response.status_code)\n return []\n self._accounts = [Account(self, account)\n for account in response.json().get('data', {}).get('accounts', [])]\n return self._accounts","def get_all_accounts():\n accounts = Account.query.all()\n print(accounts)\n return \"\"","def get_active_users(self) -> tuple:\n users_list: dict_list_type = [user.to_dict() for user in UserModel.query(UserModel.is_active == True).fetch()]\n return jsonify({'status': True, 'payload': users_list, 'message': 'successfully retrieved active users'}), 200","def accounts():","def get(self):\n return sync.get_open_orders()","def accounts(self):\n # get the summary data\n options = { 'PayLoadText' : self.request_xml() }\n\n print(self.url)\n print(options)\n\n response = requests.get(self.url, params=options) \\\n .content\n print(response)\n xml_tree = xml.etree.cElementTree.fromstring(response)\n\n status = xml_tree.find('ServiceResponse/Status').text\n\n if status != 'success':\n raise requests.exceptions.RequestException()\n\n self.security_token = xml_tree.find('ClientSecurityToken').text\n\n accounts = [ \n self.create_account(account)\n for account in xml_tree.iter('CardAccounts')\n ]\n\n return accounts","async def get_open_order_nos(self):\n success, error = await self._rest_api.get_open_orders(self._raw_symbol)\n if error:\n return False, error\n order_nos = []\n for order_info in success[\"data\"]:\n order_nos.append(order_info[\"order_id\"])\n return order_nos, None","def open_orders(self, **params):\n return self._get('openOrders', signed=True, params=params)","def users_active(self):\n return self.users(\"inactive == NO\")","def get_fedcm_account_list(self):\n pass","def get(self):\n held_accounts = User.get_held_accounts(\n get_jwt_identity(), initialize_models=True)\n\n schema = AccountsListSchema(many=True)\n response = schema.dumps(held_accounts)\n\n return jsonify_response(json.loads(response.data), 200)","def get_all_open_orders(self):\n self.__init_client()\n open_orders = retry(lambda: self.client\n .futures_get_open_orders(symbol=self.pair)) \n if len(open_orders) > 0:\n return open_orders\n else:\n return None","def activeusercount(self):\n sql = '''select to_char(count(*)-1, 'FM99999999999999990') retvalue \n from v$session where username is not null \n and status='ACTIVE' '''\n self.cur.execute(sql)\n res = self.cur.fetchall()\n for i in res:\n print(i[0])","def fetchAllAccounts(config):\n allAccounts = []\n currentStart = 1\n currentLimit = 99\n while currentLimit > 98 :\n currentPull = fetchBatchAccounts(accountsConfig, currentStart, currentLimit)['data']\n allAccounts = allAccounts + currentPull\n currentLimit = int(len(currentPull))\n currentStart = int(currentStart) + int(currentLimit)\n return allAccounts","def accounts(self):\r\n return accounts.Accounts(self)","def get_accounts(fints_login, user_scope):\n from erpnextfints.utils.fints_controller import FinTSController\n interactive = {\"docname\": user_scope, \"enabled\": True}\n\n return {\n \"accounts\": FinTSController(\n fints_login,\n interactive).get_fints_accounts()\n }","def get_open_orders(self, asset=None):\n try:\n self.ask_request()\n response = self._request('orders', None)\n order_statuses = response.json()\n except Exception as e:\n raise ExchangeRequestError(error=e)\n\n if 'message' in order_statuses:\n raise ExchangeRequestError(\n error='Unable to retrieve open orders: {}'.format(\n order_statuses['message'])\n )\n\n orders = []\n for order_status in order_statuses:\n order, executed_price = self._create_order(order_status)\n if asset is None or asset == order.sid:\n orders.append(order)\n\n return orders","def get_account_transactions(self, min_row=0, max_row=100):\n data = {\n 'min_row': min_row,\n 'max_row': max_row\n }\n query_string = build_query_string(data)\n\n r = requests.get(build_api_call(self.base_url, ACCOUNTID, 'transactions', query_string),\n auth=HTTPBasicAuth(KEY, SECRET))\n\n if r.status_code == 200:\n return r.json()\n else:\n return 'error'","def get_all_accounts_information(self):\n\t\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_ENTITY_OWNER_SUDO_OPERATION, us.SERVER_COMMAND_GET_ALL_ACCOUNTS_INFORMATION)","def return_open_orders(self, currency_pair):\n return self.api_query('returnOpenOrders', {\"currencyPair\": currency_pair})","def get_accounts_for_ou(logger, options, org_client, path):\n logger.debug(\"Getting accounts for OU: %s\", path)\n org_unit = get_ou_from_path(logger, org_client, path)\n ous = []\n if options.no_recursive:\n ous.append(org_unit)\n else:\n ous.extend(get_child_ous(logger, org_client, org_unit))\n\n result = []\n for org_unit in ous:\n args = {\"ParentId\":org_unit[\"Id\"]}\n accounts = utils.generic_paginator(logger, org_client.list_accounts_for_parent,\n \"Accounts\", **args)\n for acc in accounts:\n acc[\"Path\"] = org_unit[\"Path\"]\n if 'Status' in acc:\n if acc['Status'] != 'SUSPENDED':\n result.append(acc)\n else:\n logger.info(\"found suspended account %s, ignoring it.\" % acc)\n return result","def ldap_get_active_members():\n return _ldap_get_group_members('active')","def accounts(self):\r\n return resources.Accounts(self)","def list_active_emails():\n db_customers = Customers.select().where(Customers.status)\n LOGGER.debug(\"Returning list of active customer emails\")\n email_list = [x.email_address for x in db_customers]\n LOGGER.info(\"Email list: %s\", email_list)\n return email_list","def get_all_active_members(debug, contactsUrl):\n\n valid_date = str(datetime.date.today() - datetime.timedelta(days=7)) # 7 days ago in yyyy-mm-dd format\n\n #params = {'$filter': 'member eq true AND Status eq Active',\n # '$async': 'false'}\n params = {'$filter': \"member eq true AND ( Status eq Active OR ( Status eq PendingRenewal AND 'Renewal due' ge \" + valid_date + \"))\",\n '$async': 'false'}\n request_url = contactsUrl + '?' + urllib.parse.urlencode(params)\n if debug: print('Making api call to get contacts')\n return api.execute_request(request_url).Contacts","def list_accounts():\n\n try:\n accounts = Account.query.all()\n except NoResultFound:\n print(f\"No account configured yet.\")\n return\n n_len = max([len(a.nickname) for a in accounts if a.nickname != 'no.name'])\n fmt = \"{nickname:\" + str(n_len) + \"s}: {email:s}\"\n #import pdb; pdb.set_trace()\n for acct in [acct for acct in accounts if acct.nickname != 'no.name']:\n print(fmt.format(nickname=acct.nickname, email=acct.email))\n return","def get_status(self, rows):\n\n\t\taccount_status = {}\n\t\tfor row in rows:\n\t\t\t(account_number, status) = (int(row[0]), row[2])\n\t\t\tif account_status.has_key(account_number):\n\t\t\t\taccount_status[account_number].append(status)\n\t\t\t\t# Log account information if account has more than 1 current active status\n\t\t\t\tself.log.debug(\"Multiple Current Statuses for Account Number:\" + account_number)\n\t\t\telse:\n\t\t\t\taccount_status[account_number] = [status]\n\n\t\treturn account_status","def get_accounts(self):\n uri = '/credentials'\n response = gate_request(uri=uri)\n assert response.ok, 'Failed to get accounts: {0}'.format(response.text)\n\n all_accounts = response.json()\n self.log.debug('Accounts in Spinnaker:\\n%s', all_accounts)\n\n filtered_accounts = []\n for account in all_accounts:\n if account['type'] == self.provider:\n filtered_accounts.append(account)\n\n if not filtered_accounts:\n raise ForemastError('No Accounts matching {0}.'.format(self.provider))\n\n return filtered_accounts","def list_accounts(self):\n information = []\n for provider in self._accounts.values():\n information.append({\n 'token': provider.credentials.token,\n 'url': provider.credentials.url,\n })\n\n return information","def accounts():\n if not session.get('authed', False):\n flash(\"Please log in.\")\n return redirect(my_url('index'))\n account_ids = redis_client.smembers('%s-accounts' % session['phone'])\n accounts = [kloudless.Account.retrieve(i) for i in account_ids]\n callback_url = quote_plus(my_url('auth_callback'))\n return render_template('accounts.html', accounts=accounts, app_number=APP_NUMBER,\n callback_url=callback_url, app_id=KLOUDLESS_APP_ID)","def getFoursquareCheckins(self, accessToken):\n return self.getFoursquareApi('users/self/checkins', accessToken)","def getCustomerAccount(self):\n self.logger.debug(\"\")\n for cust in self.getCustomerAccountData():\n accounts = len(cust['accounts'])\n self.logger.debug(\"%d accounts in %s\", accounts, cust['CustomerId'])\n ii = 1\n for acct in cust['accounts']:\n self.logger.debug(\"yield %s, %s\", cust['CustomerId'], acct['Id'])\n yield cust['CustomerId'], acct['Id'], ii, accounts\n ii += 1","def manager_active_list(self):\n _, body = self.request('/v1.1/managers/active', 'GET')\n return body","async def get_in_active_users_async(self) -> tuple:\n users_list: dict_list_type = [user.to_dict() for user in UserModel.query(UserModel.is_active == False).fetch_async().get_result()]\n return jsonify({'status': True, 'payload': users_list, 'message': 'successfully retrieved active users'}), 200","def getActiveObjects(doc):\n lst = list()\n op = doc.GetFirstObject()\n while op:\n if op.GetBit(c4d.BIT_ACTIVE) == True: \n lst.append(op)\n op = Helpers.getHNext(op)\n return lst","def accounts(web3):\n return web3.eth.accounts","def fusion_api_get_active_sessions(self):\n return self.loginsession.get_active_sessions()","def fetch_users(self):\n users = super(type(self), self).fetch_users()\n return list(filter(self._check_active, users))","def _get_ad_accounts() -> [adaccount.AdAccount]:\n system_user = user.User(fbid='me')\n ad_accounts = system_user.get_ad_accounts(fields=['account_id',\n 'name',\n 'created_time',\n 'timezone_offset_hours_utc'])\n return list(ad_accounts)","def invoices(self):\r\n return inv.AccountInvoices(self)","def get(self):\n accounts = database.get_all(Accounts)\n all_accounts = []\n for account in accounts:\n all_transactions = []\n for transaction in account.transactions:\n all_transactions.append(transaction.id)\n new_account = {\n \"id\": account.id,\n \"name\": account.name,\n \"iban\": account.iban,\n \"balance\": float(account.balance),\n \"currency\": account.currency,\n \"transactions ids\": all_transactions\n }\n\n all_accounts.append(new_account)\n return json.dumps(all_accounts), 200","def get_list(active=None, order=None, limit=None):\r\n user_query = User.query.order_by(User.username)\r\n\r\n if active is not None:\r\n user_query = user_query.filter(User.activated == active)\r\n\r\n if order:\r\n user_query = user_query.order_by(getattr(User, order))\r\n else:\r\n user_query = user_query.order_by(User.signup)\r\n\r\n if limit:\r\n user_query = user_query.limit(limit)\r\n\r\n return user_query.all()","def fetchById(accountIdList):\n accounts= []\n url = accountsConfig['domain']\n for accId in accountIdList:\n r = requests.get(url +'/'+ str(accId), headers=accountsConfig['headers']).json()\n accounts.append(r)\n return accounts","async def fetch_open_orders(self, symbol: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):\n request = {\n 'filter': {\n 'open': True,\n },\n }\n return await self.fetch_orders(symbol, since, limit, self.deep_extend(request, params))","def getInterestedUsers():","def get_users(self, email):\n print(\"bu\")\n active_users = UserModel._default_manager.filter(**{\n '%s__iexact' % UserModel.get_username_field_name(): username,\n 'is_active': True,\n })\n print(active_users)\n # active_users = UserModel._default_manager.filter(**{\n # '%s__iexact' % UserModel.get_email_field_name(): email,\n # 'is_active': True,\n # })\n return (u for u in active_users if u.has_usable_password())","def open_orders(self, **params):\n return self._get('option/openOrders', signed=True, params=params, version=None)","def _get_linkedin_accounts(self, linkedin_access_token):\n response = requests.get(\n 'https://api.linkedin.com/v2/me?projection='\n + '(id,localizedLastName,localizedFirstName,'\n + 'profilePicture(displayImage~:playableStreams))',\n headers={\n 'Authorization': 'Bearer ' + linkedin_access_token,\n 'cache-control': 'no-cache',\n 'X-Restli-Protocol-Version': '2.0.0'\n }\n ).json()\n\n if ('id' in response and 'localizedLastName' in response\n and 'localizedFirstName' in response):\n linkedin_account_id = 'urn:li:person:' + response['id']\n\n try:\n image_url = response['profilePicture']['displayImage~']['elements'][0]['identifiers'][0]['identifier']\n linkedin_profile_image = base64.b64encode(requests.get(image_url).content)\n except Exception:\n linkedin_profile_image = ''\n\n # TODO - STD: add each companies page\n return [{\n 'name': response['localizedLastName'] + ' ' + response['localizedFirstName'],\n 'linkedin_account_id': linkedin_account_id,\n 'linkedin_access_token': linkedin_access_token,\n 'image': linkedin_profile_image\n }]\n\n return []","def list(self, request, *args, **kwargs):\n queryset = BankConnections.objects.filter(user=self.request.user)\n \n response = [{\n \"connected\": True if connection.isTokenValid else False,\n \"bank\": connection.bank_branch.bank.id\n } for connection in queryset]\n\n return Response(response)","def get_active_users(mins):\n min_dt = now() - timedelta(minutes=mins)\n return User.objects.filter(profile__accessed__gte=min_dt).count()","def get_users(self, email):\n active_users = User.objects.filter(\n email__iexact=email,\n is_active=True\n )\n return (u for u in active_users)","def get_company_users(self, company_referece, active=True):\n url = 'companies/{0}/users'.format(company_referece)\n if active:\n data = {'status_in_company': 'active'}\n else:\n data = {'status_in_company': 'inactive'}\n result = self.get(url, data)\n return result.get('users', result)","def get_users(self):\r\n\t\tlogger.debug(\"Fetch users\")\r\n\t\t\r\n\t\treturn login.get_users()","def list_users(access_token):\n request_url = OKTA_URL + \"api/v1/users\"\n headers = {\"Authorization\": \"Bearer \" + access_token}\n group_request = requests.get(request_url, headers=headers).json()\n return group_request","def returnOpenOrders(self, currency_pair=\"all\"):\n pass","def show_accounts(conn, userid):\n print('\\n\\nAccount statment for user', (userid))\n with conn.cursor() as curs:\n curs.execute('SELECT id, type, balance FROM accounts WHERE owner_id=%s', (userid,))\n rows = curs.fetchall()\n print('Number of results:', curs.rowcount)\n for row in rows:\n print(row)"],"string":"[\n \"def get_accounts(self):\\n\\n data = {\\n 'customerId': self.personal_identity_number,\\n 'responseControl': {\\n 'filter': {\\n 'includes': ['ALL']\\n }\\n }\\n }\\n\\n headers = {'Content-type': 'application/json',\\n 'Accept': 'application/json',\\n 'CSRFToken': self.json_token}\\n path = '/im/json/overview/getaccounts'\\n req = self.session.post(\\n self.BASE_URL + path,\\n data=json.dumps(data),\\n headers=headers)\\n\\n for account in req.json()['response']['accounts']:\\n self.accounts[account['number']] = account\\n del(self.accounts[account['number']]['number'])\\n\\n return self.accounts\",\n \"def list_active_customers():\\n active_customers = 0\\n for customer in cm.Customers:\\n if customer.status == \\\"Active \\\":\\n active_customers += 1\\n return active_customers\",\n \"def list_accounts(self):\\n pass\",\n \"def getConnectedAccounts(**kwargs):\\n strProdURL = kwargs[\\\"strProdURL\\\"]\\n orgID = kwargs[\\\"ORG_ID\\\"]\\n sessiontoken = kwargs[\\\"sessiontoken\\\"]\\n\\n accounts = get_connected_accounts_json(strProdURL, orgID, sessiontoken)\\n orgtable = PrettyTable(['OrgID'])\\n orgtable.add_row([orgID])\\n print(str(orgtable))\\n table = PrettyTable(['Account Number','id'])\\n for i in accounts:\\n table.add_row([i['account_number'],i['id']])\\n \\n print(\\\"Connected Accounts\\\")\\n print(table)\",\n \"def get_accounts(self):\\r\\n return self._accounts\",\n \"def get_accounts(self):\\n return self.accounts\",\n \"def query_accounts(self):\\n return self._call_txtrader_api('query_accounts', {})\",\n \"def fetch_accounts(self):\\n return self.fetch('/accounts')\",\n \"def returnOpenOrders(self, account=None):\\n if not account:\\n if \\\"default_account\\\" in config:\\n account = config[\\\"default_account\\\"]\\n if not account:\\n raise ValueError(\\\"You need to provide an account\\\")\\n\\n orders = self.dpay.rpc.get_open_orders(account, limit=1000)\\n return orders\",\n \"def get_accounts(self):\\n return self.accounts.all()\",\n \"def accounts(self):\\r\\n return acc.Accounts(self)\",\n \"def get_accounts(self):\\n\\n\\t\\treturn self.__accounts\",\n \"def fetch_owner_accounts():\\n resp = oauth.tapkey.get('Owners')\\n owner_accounts = resp.json()\\n return owner_accounts\",\n \"def list_active_customers():\\n db_customers = Customers.select()\\n LOGGER.debug(\\\"Calculating number of active customers\\\")\\n # Technically used this in Lesson 03, but it is a comprehension. Another method added below.\\n number_active = sum([int(x.status) for x in db_customers])\\n LOGGER.info(\\\"There are %d active customers\\\", number_active)\\n\\n return number_active\",\n \"def list_active_customers():\\n customer_active = Customer.select().where(Customer.status == 'Active')\\n print('{} Active Customers'.format(len(customer_active)))\\n return len(customer_active)\",\n \"def GetAccountList(self):\\n\\t\\treturn self.accounts.keys()\",\n \"def list_active_customer():\\n active_customer = Customer.select().where(Customer.is_active).count()\\n LOGGER.info('Number of active customers retrieved.')\\n return active_customer\",\n \"def get_accounts():\\n graph = facebook.GraphAPI(mytoken)\\n pages = graph.get_object('me/accounts')\\n pages_info=[]\\n for page in pages['data']:\\n pages_info.append( ( page['name'], page['access_token'] ) )\\n return pages_info\",\n \"def accounts_info(self):\\r\\n param = {}\\r\\n param['appid'] = self.apiKey\\r\\n param['nonce'] = int(time.time() * 1000)\\r\\n param['timestamp'] = int(time.time())\\r\\n return self.__signed_GET('/api/v1/account/all', param, self.timeout)\",\n \"def list_active_customers():\\n init_database()\\n return Customer.select().where(Customer.active_status).count()\",\n \"def display_accounts(cls):\\n return cls.account_list\",\n \"def list_accounts(min_conf=1):\\n min_conf = str(min_conf)\\n try:\\n stdout = subprocess.check_output([\\\"litecoin-cli\\\", \\\"listaccounts\\\", min_conf])\\n accounts = json.loads(stdout.decode())\\n except:\\n sys.exit(1)\\n\\n return accounts\",\n \"def list_active_customers():\\n with cm.DATABASE.transaction():\\n # .select() has a .where() method to specify criteria for searching\\n active_customers = cm.Customer.select().where(\\n cm.Customer.status == \\\"Active\\\").count()\\n LOGGER.info(\\\"Active customers: %s\\\", active_customers)\\n return active_customers\",\n \"def getactiveusers(self):\\n\\n select_activeusers = (\\n \\\"SELECT count(DISTINCT username) FROM public.jobs \\\"\\n \\\"WHERE latestjobversion = True AND insertdate BETWEEN Date(%s) AND Date(%s) \\\"\\n \\\"AND (username NOT IN (%s)) \\\"\\n )\\n\\n\\n self.pgcursor.execute(select_activeusers, (self.startdate, self.enddate, self.adminusers))\\n\\n activeusers = 0\\n x = self.pgcursor.fetchone()\\n if x is not None:\\n activeusers = x[0]\\n\\n # print(\\\"No of active users: {0}\\\".format(activeusers))\\n return activeusers\",\n \"def active_users(self, *args, **kwargs):\\r\\n return self._get('ActiveUsers', *args, **kwargs)\",\n \"def list(ctx):\\n if ctx.obj.get('NAMESPACE') != 'accounts':\\n click.echo(\\n click.style('Only account data is available for listing.', fg='red')\\n )\\n return\\n\\n swag = create_swag_from_ctx(ctx)\\n accounts = swag.get_all()\\n _table = [[result['name'], result.get('id')] for result in accounts]\\n click.echo(\\n tabulate(_table, headers=[\\\"Account Name\\\", \\\"Account Number\\\"])\\n )\",\n \"def get_open_orders(self):\\n url = 'https://coincheck.com/api/exchange/orders/opens'\\n headers = make_header(url, access_key=self.access_key, secret_key=self.secret_key)\\n r = requests.get(url, headers=headers, timeout=self.timeout)\\n return json.loads(r.text)\",\n \"def list_active_customers():\\n return Customer.select().where(Customer.is_active).count()\",\n \"def accounts(self):\\n return self._accounts.values()\",\n \"def return_active_users():\\n return json.dumps(app.active_users)\",\n \"def list_active_customers():\\n with database.transaction():\\n query = (Customer\\n .select(fn.COUNT(Customer.status).alias('count'))\\n .where(Customer.status == 'Active'))\\n LOGGER.info(query)\\n\\n customer_count = [item.count for item in query]\\n LOGGER.info('Number of active customers: %s', customer_count[0])\\n\\n return customer_count[0]\",\n \"def retrieve_open_issues(self):\\n return self._retrieve_issues(\\\"open\\\")\",\n \"def list_active_customers():\\n count_query = (Customer\\n .select(Customer, fn.COUNT(Customer.name)\\n .alias('cust_count'))\\n .where(Customer.status == 'active'))\\n for count in count_query:\\n return count.cust_count\",\n \"def get_open_transactions(self):\\n return self.__open_transactions[:]\",\n \"def get_accounts(self):\\n me = objects.AdUser(fbid=\\\"me\\\")\\n my_accounts = list(me.get_ad_accounts(fields=[\\n 'id',\\n 'name',\\n 'timezone_name',\\n 'amount_spent',\\n 'currency']))\\n return my_accounts\",\n \"def list_active_customers():\\n try:\\n active_customer_count = 0\\n for _ in Customer.select().where(Customer.status == 'Active'):\\n active_customer_count += 1\\n return active_customer_count\\n except Exception as unknown_error:\\n print(f'Error. Not able to count number of active customers. {unknown_error}')\",\n \"async def get_open_order_nos(self):\\n success, error = await self._rest_api.get_open_orders(self._raw_symbol)\\n if error:\\n return None, error\\n order_nos = []\\n for order_info in success:\\n order_no = \\\"{}_{}\\\".format(order_info[\\\"orderId\\\"], order_info[\\\"clientOrderId\\\"])\\n order_nos.append(order_no)\\n return order_nos, None\",\n \"def listaccounts(self, minconf=1, as_dict=False):\\n if as_dict:\\n return dict(self.proxy.listaccounts(minconf))\\n else:\\n return list(self.proxy.listaccounts(minconf).keys())\",\n \"def test_getTopAcounts(self, **params):\\n req = Account.getTopAccounts()\\n print(req)\\n self.assertEqual(req['success'], True)\",\n \"def get_in_active_users(self) -> tuple:\\n users_list: dict_list_type = [user.to_dict() for user in UserModel.query(UserModel.is_active == False).fetch()]\\n return jsonify({'status': True, 'payload': users_list, 'message': 'successfully retrieved active users'}), 200\",\n \"def list_active_customers():\\n try:\\n active_customer_count = 0\\n for _ in Customer.select().where(Customer.status == 'Active'):\\n active_customer_count += 1\\n logger.info(\\n f\\\"Successfully counted active customers {active_customer_count}\\\"\\n )\\n return active_customer_count\\n except Exception as unknown_error:\\n logger.error(f\\\"Error. Failed to count customers. {unknown_error}\\\")\\n print(\\n f'Error. Not able to count number of active customers.'\\n ' {unknown_error}'\\n )\",\n \"async def get_open_order_nos(self):\\n success, error = await self._rest_api.get_open_orders(self._raw_symbol)\\n if error:\\n return None, error\\n else:\\n order_nos = []\\n for order_info in success:\\n order_no = \\\"{}_{}\\\".format(order_info[\\\"orderId\\\"], order_info[\\\"clientOrderId\\\"])\\n order_nos.append(order_no)\\n return order_nos, None\",\n \"def accounts_inactive(request):\\r\\n user_list = UserMgr.get_list(active=False)\\r\\n ret = {\\r\\n 'count': len(user_list),\\r\\n 'users': [dict(h) for h in user_list],\\r\\n }\\r\\n return _api_response(request, ret)\",\n \"def get_open_orders(self, market):\\n #{'success': True, 'message': '', 'result': [{'Uuid': None, 'OrderUuid': '7f43f22f-586b-46d8-a4b2-f457cfeb2aac', 'Exchange': 'BTC-GEO', 'OrderType': 'LIMIT_SELL', 'Quantity': 2.03478908, 'QuantityRemaining': 2.03478908, 'Limit': 0.00097503, 'CommissionPaid': 0.0, 'Price': 0.0, 'PricePerUnit': None, 'Opened': '2017-07-03T14:13:20.903', 'Closed': None, 'CancelInitiated': False, 'ImmediateOrCancel': False, 'IsConditional': False, 'Condition': 'NONE', 'ConditionTarget': None}]}\\n #{'success': 1, 'return': {'240005185729406': {'pair': 'lsk_btc', 'type': 'sell', 'amount': 1, 'rate': 0.096319, 'timestamp_created': '1499255345', 'status': 0}}}\\n result = self.api_query('ActiveOrders', {'pair': market})\\n\\n openOrder =[]\\n if result['success'] == 1:\\n try :\\n for key, value in result['return'].items():\\n openOrder.append({'OrderUuid':key})\\n result = {'success': True, 'message': '', 'result' : openOrder}\\n except:\\n result = {'success': False, 'message': '', 'result': openOrder}\\n else:\\n result = {'success': False, 'message': '', 'result': openOrder}\\n\\n return result\",\n \"def accounts(self):\\n if self._accounts is None:\\n url = f'{self._ynab.api_url}/budgets/{self.id}/accounts'\\n response = self._ynab.session.get(url)\\n if not response.ok:\\n self._logger.error('Error retrieving accounts, response was : %s with status code : %s',\\n response.text,\\n response.status_code)\\n return []\\n self._accounts = [Account(self, account)\\n for account in response.json().get('data', {}).get('accounts', [])]\\n return self._accounts\",\n \"def get_all_accounts():\\n accounts = Account.query.all()\\n print(accounts)\\n return \\\"\\\"\",\n \"def get_active_users(self) -> tuple:\\n users_list: dict_list_type = [user.to_dict() for user in UserModel.query(UserModel.is_active == True).fetch()]\\n return jsonify({'status': True, 'payload': users_list, 'message': 'successfully retrieved active users'}), 200\",\n \"def accounts():\",\n \"def get(self):\\n return sync.get_open_orders()\",\n \"def accounts(self):\\n # get the summary data\\n options = { 'PayLoadText' : self.request_xml() }\\n\\n print(self.url)\\n print(options)\\n\\n response = requests.get(self.url, params=options) \\\\\\n .content\\n print(response)\\n xml_tree = xml.etree.cElementTree.fromstring(response)\\n\\n status = xml_tree.find('ServiceResponse/Status').text\\n\\n if status != 'success':\\n raise requests.exceptions.RequestException()\\n\\n self.security_token = xml_tree.find('ClientSecurityToken').text\\n\\n accounts = [ \\n self.create_account(account)\\n for account in xml_tree.iter('CardAccounts')\\n ]\\n\\n return accounts\",\n \"async def get_open_order_nos(self):\\n success, error = await self._rest_api.get_open_orders(self._raw_symbol)\\n if error:\\n return False, error\\n order_nos = []\\n for order_info in success[\\\"data\\\"]:\\n order_nos.append(order_info[\\\"order_id\\\"])\\n return order_nos, None\",\n \"def open_orders(self, **params):\\n return self._get('openOrders', signed=True, params=params)\",\n \"def users_active(self):\\n return self.users(\\\"inactive == NO\\\")\",\n \"def get_fedcm_account_list(self):\\n pass\",\n \"def get(self):\\n held_accounts = User.get_held_accounts(\\n get_jwt_identity(), initialize_models=True)\\n\\n schema = AccountsListSchema(many=True)\\n response = schema.dumps(held_accounts)\\n\\n return jsonify_response(json.loads(response.data), 200)\",\n \"def get_all_open_orders(self):\\n self.__init_client()\\n open_orders = retry(lambda: self.client\\n .futures_get_open_orders(symbol=self.pair)) \\n if len(open_orders) > 0:\\n return open_orders\\n else:\\n return None\",\n \"def activeusercount(self):\\n sql = '''select to_char(count(*)-1, 'FM99999999999999990') retvalue \\n from v$session where username is not null \\n and status='ACTIVE' '''\\n self.cur.execute(sql)\\n res = self.cur.fetchall()\\n for i in res:\\n print(i[0])\",\n \"def fetchAllAccounts(config):\\n allAccounts = []\\n currentStart = 1\\n currentLimit = 99\\n while currentLimit > 98 :\\n currentPull = fetchBatchAccounts(accountsConfig, currentStart, currentLimit)['data']\\n allAccounts = allAccounts + currentPull\\n currentLimit = int(len(currentPull))\\n currentStart = int(currentStart) + int(currentLimit)\\n return allAccounts\",\n \"def accounts(self):\\r\\n return accounts.Accounts(self)\",\n \"def get_accounts(fints_login, user_scope):\\n from erpnextfints.utils.fints_controller import FinTSController\\n interactive = {\\\"docname\\\": user_scope, \\\"enabled\\\": True}\\n\\n return {\\n \\\"accounts\\\": FinTSController(\\n fints_login,\\n interactive).get_fints_accounts()\\n }\",\n \"def get_open_orders(self, asset=None):\\n try:\\n self.ask_request()\\n response = self._request('orders', None)\\n order_statuses = response.json()\\n except Exception as e:\\n raise ExchangeRequestError(error=e)\\n\\n if 'message' in order_statuses:\\n raise ExchangeRequestError(\\n error='Unable to retrieve open orders: {}'.format(\\n order_statuses['message'])\\n )\\n\\n orders = []\\n for order_status in order_statuses:\\n order, executed_price = self._create_order(order_status)\\n if asset is None or asset == order.sid:\\n orders.append(order)\\n\\n return orders\",\n \"def get_account_transactions(self, min_row=0, max_row=100):\\n data = {\\n 'min_row': min_row,\\n 'max_row': max_row\\n }\\n query_string = build_query_string(data)\\n\\n r = requests.get(build_api_call(self.base_url, ACCOUNTID, 'transactions', query_string),\\n auth=HTTPBasicAuth(KEY, SECRET))\\n\\n if r.status_code == 200:\\n return r.json()\\n else:\\n return 'error'\",\n \"def get_all_accounts_information(self):\\n\\t\\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_ENTITY_OWNER_SUDO_OPERATION, us.SERVER_COMMAND_GET_ALL_ACCOUNTS_INFORMATION)\",\n \"def return_open_orders(self, currency_pair):\\n return self.api_query('returnOpenOrders', {\\\"currencyPair\\\": currency_pair})\",\n \"def get_accounts_for_ou(logger, options, org_client, path):\\n logger.debug(\\\"Getting accounts for OU: %s\\\", path)\\n org_unit = get_ou_from_path(logger, org_client, path)\\n ous = []\\n if options.no_recursive:\\n ous.append(org_unit)\\n else:\\n ous.extend(get_child_ous(logger, org_client, org_unit))\\n\\n result = []\\n for org_unit in ous:\\n args = {\\\"ParentId\\\":org_unit[\\\"Id\\\"]}\\n accounts = utils.generic_paginator(logger, org_client.list_accounts_for_parent,\\n \\\"Accounts\\\", **args)\\n for acc in accounts:\\n acc[\\\"Path\\\"] = org_unit[\\\"Path\\\"]\\n if 'Status' in acc:\\n if acc['Status'] != 'SUSPENDED':\\n result.append(acc)\\n else:\\n logger.info(\\\"found suspended account %s, ignoring it.\\\" % acc)\\n return result\",\n \"def ldap_get_active_members():\\n return _ldap_get_group_members('active')\",\n \"def accounts(self):\\r\\n return resources.Accounts(self)\",\n \"def list_active_emails():\\n db_customers = Customers.select().where(Customers.status)\\n LOGGER.debug(\\\"Returning list of active customer emails\\\")\\n email_list = [x.email_address for x in db_customers]\\n LOGGER.info(\\\"Email list: %s\\\", email_list)\\n return email_list\",\n \"def get_all_active_members(debug, contactsUrl):\\n\\n valid_date = str(datetime.date.today() - datetime.timedelta(days=7)) # 7 days ago in yyyy-mm-dd format\\n\\n #params = {'$filter': 'member eq true AND Status eq Active',\\n # '$async': 'false'}\\n params = {'$filter': \\\"member eq true AND ( Status eq Active OR ( Status eq PendingRenewal AND 'Renewal due' ge \\\" + valid_date + \\\"))\\\",\\n '$async': 'false'}\\n request_url = contactsUrl + '?' + urllib.parse.urlencode(params)\\n if debug: print('Making api call to get contacts')\\n return api.execute_request(request_url).Contacts\",\n \"def list_accounts():\\n\\n try:\\n accounts = Account.query.all()\\n except NoResultFound:\\n print(f\\\"No account configured yet.\\\")\\n return\\n n_len = max([len(a.nickname) for a in accounts if a.nickname != 'no.name'])\\n fmt = \\\"{nickname:\\\" + str(n_len) + \\\"s}: {email:s}\\\"\\n #import pdb; pdb.set_trace()\\n for acct in [acct for acct in accounts if acct.nickname != 'no.name']:\\n print(fmt.format(nickname=acct.nickname, email=acct.email))\\n return\",\n \"def get_status(self, rows):\\n\\n\\t\\taccount_status = {}\\n\\t\\tfor row in rows:\\n\\t\\t\\t(account_number, status) = (int(row[0]), row[2])\\n\\t\\t\\tif account_status.has_key(account_number):\\n\\t\\t\\t\\taccount_status[account_number].append(status)\\n\\t\\t\\t\\t# Log account information if account has more than 1 current active status\\n\\t\\t\\t\\tself.log.debug(\\\"Multiple Current Statuses for Account Number:\\\" + account_number)\\n\\t\\t\\telse:\\n\\t\\t\\t\\taccount_status[account_number] = [status]\\n\\n\\t\\treturn account_status\",\n \"def get_accounts(self):\\n uri = '/credentials'\\n response = gate_request(uri=uri)\\n assert response.ok, 'Failed to get accounts: {0}'.format(response.text)\\n\\n all_accounts = response.json()\\n self.log.debug('Accounts in Spinnaker:\\\\n%s', all_accounts)\\n\\n filtered_accounts = []\\n for account in all_accounts:\\n if account['type'] == self.provider:\\n filtered_accounts.append(account)\\n\\n if not filtered_accounts:\\n raise ForemastError('No Accounts matching {0}.'.format(self.provider))\\n\\n return filtered_accounts\",\n \"def list_accounts(self):\\n information = []\\n for provider in self._accounts.values():\\n information.append({\\n 'token': provider.credentials.token,\\n 'url': provider.credentials.url,\\n })\\n\\n return information\",\n \"def accounts():\\n if not session.get('authed', False):\\n flash(\\\"Please log in.\\\")\\n return redirect(my_url('index'))\\n account_ids = redis_client.smembers('%s-accounts' % session['phone'])\\n accounts = [kloudless.Account.retrieve(i) for i in account_ids]\\n callback_url = quote_plus(my_url('auth_callback'))\\n return render_template('accounts.html', accounts=accounts, app_number=APP_NUMBER,\\n callback_url=callback_url, app_id=KLOUDLESS_APP_ID)\",\n \"def getFoursquareCheckins(self, accessToken):\\n return self.getFoursquareApi('users/self/checkins', accessToken)\",\n \"def getCustomerAccount(self):\\n self.logger.debug(\\\"\\\")\\n for cust in self.getCustomerAccountData():\\n accounts = len(cust['accounts'])\\n self.logger.debug(\\\"%d accounts in %s\\\", accounts, cust['CustomerId'])\\n ii = 1\\n for acct in cust['accounts']:\\n self.logger.debug(\\\"yield %s, %s\\\", cust['CustomerId'], acct['Id'])\\n yield cust['CustomerId'], acct['Id'], ii, accounts\\n ii += 1\",\n \"def manager_active_list(self):\\n _, body = self.request('/v1.1/managers/active', 'GET')\\n return body\",\n \"async def get_in_active_users_async(self) -> tuple:\\n users_list: dict_list_type = [user.to_dict() for user in UserModel.query(UserModel.is_active == False).fetch_async().get_result()]\\n return jsonify({'status': True, 'payload': users_list, 'message': 'successfully retrieved active users'}), 200\",\n \"def getActiveObjects(doc):\\n lst = list()\\n op = doc.GetFirstObject()\\n while op:\\n if op.GetBit(c4d.BIT_ACTIVE) == True: \\n lst.append(op)\\n op = Helpers.getHNext(op)\\n return lst\",\n \"def accounts(web3):\\n return web3.eth.accounts\",\n \"def fusion_api_get_active_sessions(self):\\n return self.loginsession.get_active_sessions()\",\n \"def fetch_users(self):\\n users = super(type(self), self).fetch_users()\\n return list(filter(self._check_active, users))\",\n \"def _get_ad_accounts() -> [adaccount.AdAccount]:\\n system_user = user.User(fbid='me')\\n ad_accounts = system_user.get_ad_accounts(fields=['account_id',\\n 'name',\\n 'created_time',\\n 'timezone_offset_hours_utc'])\\n return list(ad_accounts)\",\n \"def invoices(self):\\r\\n return inv.AccountInvoices(self)\",\n \"def get(self):\\n accounts = database.get_all(Accounts)\\n all_accounts = []\\n for account in accounts:\\n all_transactions = []\\n for transaction in account.transactions:\\n all_transactions.append(transaction.id)\\n new_account = {\\n \\\"id\\\": account.id,\\n \\\"name\\\": account.name,\\n \\\"iban\\\": account.iban,\\n \\\"balance\\\": float(account.balance),\\n \\\"currency\\\": account.currency,\\n \\\"transactions ids\\\": all_transactions\\n }\\n\\n all_accounts.append(new_account)\\n return json.dumps(all_accounts), 200\",\n \"def get_list(active=None, order=None, limit=None):\\r\\n user_query = User.query.order_by(User.username)\\r\\n\\r\\n if active is not None:\\r\\n user_query = user_query.filter(User.activated == active)\\r\\n\\r\\n if order:\\r\\n user_query = user_query.order_by(getattr(User, order))\\r\\n else:\\r\\n user_query = user_query.order_by(User.signup)\\r\\n\\r\\n if limit:\\r\\n user_query = user_query.limit(limit)\\r\\n\\r\\n return user_query.all()\",\n \"def fetchById(accountIdList):\\n accounts= []\\n url = accountsConfig['domain']\\n for accId in accountIdList:\\n r = requests.get(url +'/'+ str(accId), headers=accountsConfig['headers']).json()\\n accounts.append(r)\\n return accounts\",\n \"async def fetch_open_orders(self, symbol: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):\\n request = {\\n 'filter': {\\n 'open': True,\\n },\\n }\\n return await self.fetch_orders(symbol, since, limit, self.deep_extend(request, params))\",\n \"def getInterestedUsers():\",\n \"def get_users(self, email):\\n print(\\\"bu\\\")\\n active_users = UserModel._default_manager.filter(**{\\n '%s__iexact' % UserModel.get_username_field_name(): username,\\n 'is_active': True,\\n })\\n print(active_users)\\n # active_users = UserModel._default_manager.filter(**{\\n # '%s__iexact' % UserModel.get_email_field_name(): email,\\n # 'is_active': True,\\n # })\\n return (u for u in active_users if u.has_usable_password())\",\n \"def open_orders(self, **params):\\n return self._get('option/openOrders', signed=True, params=params, version=None)\",\n \"def _get_linkedin_accounts(self, linkedin_access_token):\\n response = requests.get(\\n 'https://api.linkedin.com/v2/me?projection='\\n + '(id,localizedLastName,localizedFirstName,'\\n + 'profilePicture(displayImage~:playableStreams))',\\n headers={\\n 'Authorization': 'Bearer ' + linkedin_access_token,\\n 'cache-control': 'no-cache',\\n 'X-Restli-Protocol-Version': '2.0.0'\\n }\\n ).json()\\n\\n if ('id' in response and 'localizedLastName' in response\\n and 'localizedFirstName' in response):\\n linkedin_account_id = 'urn:li:person:' + response['id']\\n\\n try:\\n image_url = response['profilePicture']['displayImage~']['elements'][0]['identifiers'][0]['identifier']\\n linkedin_profile_image = base64.b64encode(requests.get(image_url).content)\\n except Exception:\\n linkedin_profile_image = ''\\n\\n # TODO - STD: add each companies page\\n return [{\\n 'name': response['localizedLastName'] + ' ' + response['localizedFirstName'],\\n 'linkedin_account_id': linkedin_account_id,\\n 'linkedin_access_token': linkedin_access_token,\\n 'image': linkedin_profile_image\\n }]\\n\\n return []\",\n \"def list(self, request, *args, **kwargs):\\n queryset = BankConnections.objects.filter(user=self.request.user)\\n \\n response = [{\\n \\\"connected\\\": True if connection.isTokenValid else False,\\n \\\"bank\\\": connection.bank_branch.bank.id\\n } for connection in queryset]\\n\\n return Response(response)\",\n \"def get_active_users(mins):\\n min_dt = now() - timedelta(minutes=mins)\\n return User.objects.filter(profile__accessed__gte=min_dt).count()\",\n \"def get_users(self, email):\\n active_users = User.objects.filter(\\n email__iexact=email,\\n is_active=True\\n )\\n return (u for u in active_users)\",\n \"def get_company_users(self, company_referece, active=True):\\n url = 'companies/{0}/users'.format(company_referece)\\n if active:\\n data = {'status_in_company': 'active'}\\n else:\\n data = {'status_in_company': 'inactive'}\\n result = self.get(url, data)\\n return result.get('users', result)\",\n \"def get_users(self):\\r\\n\\t\\tlogger.debug(\\\"Fetch users\\\")\\r\\n\\t\\t\\r\\n\\t\\treturn login.get_users()\",\n \"def list_users(access_token):\\n request_url = OKTA_URL + \\\"api/v1/users\\\"\\n headers = {\\\"Authorization\\\": \\\"Bearer \\\" + access_token}\\n group_request = requests.get(request_url, headers=headers).json()\\n return group_request\",\n \"def returnOpenOrders(self, currency_pair=\\\"all\\\"):\\n pass\",\n \"def show_accounts(conn, userid):\\n print('\\\\n\\\\nAccount statment for user', (userid))\\n with conn.cursor() as curs:\\n curs.execute('SELECT id, type, balance FROM accounts WHERE owner_id=%s', (userid,))\\n rows = curs.fetchall()\\n print('Number of results:', curs.rowcount)\\n for row in rows:\\n print(row)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63580984","0.6303217","0.62876016","0.6213196","0.61325455","0.61324793","0.6089535","0.6086548","0.6079627","0.6079134","0.6050323","0.6013716","0.59957004","0.59836334","0.59793425","0.5972705","0.5965284","0.59572","0.5945932","0.59283507","0.5911551","0.58857083","0.58805954","0.5874453","0.58570915","0.5855002","0.58417356","0.58339196","0.5831123","0.5826693","0.57704306","0.5758257","0.5756581","0.5748724","0.5748157","0.56824094","0.568109","0.567365","0.56666267","0.56568575","0.5639378","0.5627847","0.5625639","0.5624547","0.5618651","0.561276","0.55751914","0.5560087","0.55544776","0.5542565","0.5542394","0.5522518","0.5509156","0.54996496","0.5495248","0.546898","0.54689515","0.5450077","0.544766","0.54432875","0.5436816","0.54146427","0.54051924","0.5399515","0.5395862","0.53814876","0.537924","0.53598934","0.5351286","0.53503925","0.53408813","0.53301525","0.53277856","0.53259075","0.53198946","0.5317665","0.5307938","0.53026325","0.5273024","0.52723044","0.526244","0.52620655","0.5250415","0.5243769","0.5240452","0.522988","0.52152175","0.5210329","0.5209422","0.52005637","0.519889","0.51965934","0.5196394","0.51901567","0.51639503","0.51595116","0.51556957","0.51549405","0.51547194","0.514872"],"string":"[\n \"0.63580984\",\n \"0.6303217\",\n \"0.62876016\",\n \"0.6213196\",\n \"0.61325455\",\n \"0.61324793\",\n \"0.6089535\",\n \"0.6086548\",\n \"0.6079627\",\n \"0.6079134\",\n \"0.6050323\",\n \"0.6013716\",\n \"0.59957004\",\n \"0.59836334\",\n \"0.59793425\",\n \"0.5972705\",\n \"0.5965284\",\n \"0.59572\",\n \"0.5945932\",\n \"0.59283507\",\n \"0.5911551\",\n \"0.58857083\",\n \"0.58805954\",\n \"0.5874453\",\n \"0.58570915\",\n \"0.5855002\",\n \"0.58417356\",\n \"0.58339196\",\n \"0.5831123\",\n \"0.5826693\",\n \"0.57704306\",\n \"0.5758257\",\n \"0.5756581\",\n \"0.5748724\",\n \"0.5748157\",\n \"0.56824094\",\n \"0.568109\",\n \"0.567365\",\n \"0.56666267\",\n \"0.56568575\",\n \"0.5639378\",\n \"0.5627847\",\n \"0.5625639\",\n \"0.5624547\",\n \"0.5618651\",\n \"0.561276\",\n \"0.55751914\",\n \"0.5560087\",\n \"0.55544776\",\n \"0.5542565\",\n \"0.5542394\",\n \"0.5522518\",\n \"0.5509156\",\n \"0.54996496\",\n \"0.5495248\",\n \"0.546898\",\n \"0.54689515\",\n \"0.5450077\",\n \"0.544766\",\n \"0.54432875\",\n \"0.5436816\",\n \"0.54146427\",\n \"0.54051924\",\n \"0.5399515\",\n \"0.5395862\",\n \"0.53814876\",\n \"0.537924\",\n \"0.53598934\",\n \"0.5351286\",\n \"0.53503925\",\n \"0.53408813\",\n \"0.53301525\",\n \"0.53277856\",\n \"0.53259075\",\n \"0.53198946\",\n \"0.5317665\",\n \"0.5307938\",\n \"0.53026325\",\n \"0.5273024\",\n \"0.52723044\",\n \"0.526244\",\n \"0.52620655\",\n \"0.5250415\",\n \"0.5243769\",\n \"0.5240452\",\n \"0.522988\",\n \"0.52152175\",\n \"0.5210329\",\n \"0.5209422\",\n \"0.52005637\",\n \"0.519889\",\n \"0.51965934\",\n \"0.5196394\",\n \"0.51901567\",\n \"0.51639503\",\n \"0.51595116\",\n \"0.51556957\",\n \"0.51549405\",\n \"0.51547194\",\n \"0.514872\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8321022"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":7292,"cells":{"query":{"kind":"string","value":"Logging out from fpl"},"document":{"kind":"string","value":"async def logout(self):\n _LOGGER.info(\"Logging out\")\n\n URL_LOGOUT = API_HOST + \"/api/resources/logout\"\n try:\n async with async_timeout.timeout(TIMEOUT):\n await self.session.get(URL_LOGOUT)\n except Exception as e:\n _LOGGER.error(e)"},"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 logout():","def logout():\n login()","def logout(self):","def logout(self):\n pass","def do_logout():\n\n session['authenticated'] = False\n session['username'] = None\n session['name'] = None\n session['cpi'] = None\n session['grp_size'] = None\n\n return home()","def logOut(self):\n self.client.logout()","def logout(self):\r\n self._api_entrypoint.logout(self._session_token)","def logout():\n rino.login.logout()","def logout(self):\n logger.info(\"Logging out\")\n self._limited_call(self._requests.get, constants.FA_ROOT + \"/logout/\")","def logoff(self,username,password):\n functions.checkLogged()\n thread.stop()\n try:\n r = urllib2.urlopen(\"http://cs302.pythonanywhere.com/logoff?username={0}&password={1}\".format(username, password), timeout=4)\n except socket.timeout, e:\n logging.debug('Request to login server timed out')\n except urllib2.URLError, e:\n logging.debug('Unable to contact the login server')\n cherrypy.lib.sessions.expire()\n raise cherrypy.HTTPRedirect('/')","def logout(self, **kwargs):\n\tself.call('logout')","def logout(self):\n self.client.get(f\"{host}/logout\")","def logout_user():\n pass","def logout(self):\n self.__send_command(\"LOGOUT\")","def logout():\n print(colored('\\nYou have successfully logged out.\\n', 'yellow',\n attrs=['bold']))\n exit()","def log_out():\n\n del session[\"user_id\"]\n # print session[\"user_id\"]\n flash('You were successfully logged out')\n return render_template('homepage.html')\n\n #Additional reference for log in/log out can be found in project tracker project","def logout():\n return logout_user()","def logout():\n session.clear()\n return redirect(\"/showlog\")","def logout(self):\n try:\n log.info(\"Logging out of the netscaler\")\n self.post(\"/logout\", {\"logout\": {}})\n except BadNetScaler as error:\n log.error(\"Failed to logout of the netscaler: %s\", error)\n self.sessionid = \"\"","def t24_logoff(self):\n if self.home_page:\n self.login_page = self.home_page.sign_off()\n self.home_page = None","def test_logout(self):\r\n self.logout()","def log_out():\n if 'name' in session:\n PLAN.logout_user(session['name'])\n session.pop('name', None)\n return redirect(url_for('log_in'))\n return redirect(url_for('log_in'))","def logout(self):\n url = \"https://%s/game/index.php?page=logout\" % self.server\n #\"https://s103-pt.ogame.gameforge.com/game/index.php?page=logout\"\n self.session.get(url)","def logout(self):\n self.auth = None","def logout():\n session.pop('logged_in', None)\n session.pop('fname', None)\n session.pop('patron', None)\n flash('You were logged out')\n return redirect('/')","def logoff(self):\n\t\treturn Job(SDK.PrlSrv_Logoff(self.handle)[0])","def log_out(self):\n DB.log_out()\n self.customer.log_out()\n self.displayUi = LoginScreen()\n self.hide()\n self.displayUi.show()","def log_out(self):\n self.__is_logged_in = False","def _logout(self):\n self.api_query(action=\"logout\")\n self._cookiejar.clear()\n self._save_cookiejar()","def logout():\n\n do_logout()\n flash(f\"You are now logged out!\", \"success\")\n return redirect('/')","def logout(self, request):\n pass","def logout(self):\n with self.client.post(\"/logout\", catch_response=True) as response:\n for r_hist in response.history:\n if r_hist.status_code > 200 and r_hist.status_code < 400:\n response.success()\n self.user.username = None\n # go to UnauthenticatedTasks\n self.interrupt()","def _CAS_logout(self):\n import urllib\n redirect(\"%s?service=%s\" % (self.cas_logout_url, self.cas_my_url))","def logout():\n name = current_user.name\n logout_user()\n return f\"Logged out of {name}'s account!\"","def axapi_logoff(self):\n module = 'logoff'\n method = 'POST'\n response = self.axapi_call(module, method,'')\n if '2' in str(response.status_code):\n print(self.device + ' Successfully logged off of the device')\n else:\n print(self.device + ' There was an error trying to log off of the device')","def logout():\n\n do_logout()\n flash('successfully logged out')\n return redirect(\"/\")","def logout():\n flash(\"You have been logged out\")\n session.pop(\"user\")\n return redirect(url_for(\"tips\"))","def logout_post():\n\treturn \"LOGOUT\"","def log_out_user(self):\n flask_login.logout_user()","def logout():\n session.pop('userinfo', None)\n # no more steps necessary, because we don't keep the token around\n if 'target' not in session.keys():\n return redirect(\"/\")\n return redirect(session['target'])","def logout():\n update_session(\"X-GEMINI-APIKEY\", \"\")\n set_secret_key(\"\".encode())\n set_login_state(False)","def logout():\n if \"username\" in session.keys():\n del session[\"username\"]\n if not app.config[\"DISABLE_AUTH\"]:\n return redirect(url_for(\"login\") + \"?slo\")\n else:\n return redirect(url_for(\"index\"))","def logout():\n\n session.pop(\"leader_logged_in\", False)\n session.pop(\"leader_id\", None)\n session.pop(\"leader_email\", None)\n\n return redirect(f\"{BASEPATH}/login\")","def do_logout():\n del session[CURRENT_USER_KEY]","def process_logout():\n\n print \" LOGGED OUT USER \"\n\n del session[\"user_id\"]\n\n flash(\"You have Successfully Logged Out!\")\n\n return redirect(\"/\")","def process_logout():\n\n print \" LOGGED OUT USER \"\n\n del session[\"user_id\"]\n\n flash(\"You have Successfully Logged Out!\")\n\n return redirect(\"/\")","def remove_florlp_session(session):\n try:\n requests.get(FLORLP_LOGOUT_URL,\n cookies=session,\n allow_redirects=False)\n except requests.exceptions.RequestException, ex:\n log.debug('error while removing session: %s', ex)","def fusion_api_logout_appliance(self, headers=None):\n # logger._log_to_console_and_log_file(\"Logging out of appliance\")\n return self.loginsession.logout(headers)","def logout():\n flash(_('You were logged out'))\n session.pop('user_id', None)\n return redirect(url_for('index'))\n #return redirect(url_for('public_timeline'))","def logOut(self, e):\n\n\t\tself.unBind()\n\t\tself.menu_manager.runLogin()\n\t\tself.main_menu_window.root.destroy()","def logout():\n session.pop('logged_in', None)\n flash('You were logged out')\n return redirect(url_for('get_devices'))","def logout():\n\n do_logout()\n flash(\"Successfully logged out\", \"success\")\n return redirect('/')","def logout(self):\n self.__isroot = 0","def login():","def login():","def logout():\n logout_user()\n return redirect(url_for('main.index'))","def logout():\r\n logout_user()\r\n flash('You were logged out.')\r\n return redirect(url_for('index'))","def close(self):\n\n if self.closed:\n return\n\n url = '{0}://{1}/admin/launch?script=rh&template=logout&action=logout'\n\n try:\n resp = self._handle.open(url.format(self.proto, self.host))\n pg = resp.read()\n if 'You have been successfully logged out.' not in pg:\n self.log('Failed logout, somehow:\\n{0}'.format(pg))\n else:\n self._closed = True\n except (urllib2.HTTPError, urllib2.URLError) as e:\n self.log('{0}: {1}'.format(e.__class__.__name__, e))","def logout(self):\n self.__aceQLHttpApi.logout()","def logout():\n session.pop('microsoft_token', None)\n session.pop('state', None)\n return redirect(url_for('index'))","def logout():\n session.pop('microsoft_token', None)\n session.pop('state', None)\n return redirect(url_for('index'))","def signout(self):\n username = cherrypy.session.get('username')\n if username is None:\n pass\n else:\n cherrypy.lib.sessions.expire()\n raise cherrypy.HTTPRedirect('/')","def logout(self):\n data = {'action': 'logout'}\n self.call(data)\n self._high_limits = None\n return True","def logout():\n session.pop('logged_in', None)\n flash('You were logged out', 'success')\n return redirect(url_for('show_entries'))","def logout():\n logout_user()\n flash('You have successfully been logged out')\n\n # redirect to login page\n return redirect(url_for('auth.login'))","def logout():\n session_logout()\n return redirect(url_for(\"home\"))","def GET_logout(self):\r\n self.logout()\r\n return self.redirect('/')","def logout():\n \n del session[\"logged_in\"]\n flash(\"See you later! ;)\")\n return redirect('/')","def logout(session):\r\n response = session.get(LOGOUT_URL)\r\n response.raise_for_status()","def logout():\n # clear user data from session and flag as logged out\n for x in ['provider', 'state', 'user']:\n if x in flask.session:\n del flask.session[x]\n flask.session['logged_in'] = False\n\n flash('logout successful', 'info')\n return redirect(request.referrer or url_for('catalog.index'))","def logout(self):\n self.getLink('Logout').click()\n self.html_redirect()\n assert 'You have been logged out successfully.' in self.message, \\\n 'Not successfully logged out: message={0.message!r}'.format(self)","def logout_redirect():\n login_session.clear()\n flash('You have logged out')\n return redirect(url_for('show_homepage'))","def logout():\n\n session.clear()\n return redirect(url_for('index'))","def logout():\n\n session.clear()\n return redirect(url_for('index'))","def logout():\n session.pop('username', None)\n session.pop('user_id', None)\n session.pop('logged_in', None)\n session.pop('is_admin', None)\n\n flash('Successfully logged out', 'alert-info')\n\n return redirect(url_for('index'))","def _handle_logout(self):\n self.food_service.log_out()\n self._handle_after_logout()","def logout():\n logout_user()\n flash('You have successfully been logged out.')\n\n # redirect to the login page\n return redirect(url_for('auth.login'))","def logout():\n logout_user()\n flash('You have successfully been logged out.')\n\n # redirect to the login page\n return redirect(url_for('auth.login'))","def logout(endpoint):\n communicator = ClickCallback()\n logout_command().with_communicator(communicator).build().execute(endpoint=endpoint)\n click.secho(\"Successfully logged out.\", fg=\"green\")","def logout():\n flask_login.logout_user()\n flask.flash('Logged out')\n return flask.redirect(flask.url_for('index'))","async def exit(self, ctx):\n print('Logging out...')\n await ctx.bot.logout()","def logout():\n\n session.clear()\n crud.logout()\n \n return \"Logout Success\"","def logout():\n session['user_id'] = None\n session['user_email'] = None\n return redirect(url_for('main'))","def logout():\n logout_user()\n flash('You have successfully been logged out.')\n # redirect to the login page\n return redirect(url_for('view.login'))","def logout():\n flash('You were logged out')\n session.pop('user_id', None)\n return redirect(url_for('leaderboard'))","def _backend_logout_cleanup(self, name):\n self.log.info(\"User logged out: %s\", name)\n self.clear_login_cookie()\n self.statsd.incr('logout')","def logout():\n session.clear()\n return redirect(url_for('index'))","def logout():\n session['logged_in'] = False\n return '', 204","def logout():\n session.clear()\n return redirect(url_for(\"index\"))","def logout():\n session.clear()\n return redirect(url_for(\"index\"))","def logout():\n session.clear()\n return redirect(url_for(\"index\"))","def logout(self):\n flask_login.logout_user()\n self.app.logger.info(\"User logged out!\")\n return 'Logged out'","def logout():\n\n # remove the username from the session if it is there\n out_user = current_user.get_id()\n logout_user()\n logger.info(out_user + ' has been logged out.')\n return redirect(url_for('home'))","def logout():\n\n oidc.logout()\n return 'Hi, you have been logged out! <a href=\"/oidc/\">Return</a>'","def logout():\n oidc.logout()\n return 'Hi, you have been logged out! <a href=\"/\">Return</a>'","def logout():\n session.clear()\n return redirect(url_for(\"home\"))","def logout():\n logout_user()\n return redirect(url_for(\".login\"))","def logout():\n session.clear()\n return redirect(url_for('home'))","def test_logout(self):\n # Logging in voluntarily the quick way:\n resp = self.app.get('/login_handler?login=manager&password=managepass',\n status=302)\n resp = resp.follow(status=302)\n ok_('authtkt' in resp.request.cookies,\n 'Session cookie was not defined: %s' % resp.request.cookies)\n # Logging out:\n resp = self.app.get('/logout_handler', status=302)\n ok_(resp.location.startswith('http://localhost/post_logout'))\n # Finally, redirected to the home page:\n home_page = resp.follow(status=302)\n authtkt = home_page.request.cookies.get('authtkt')\n ok_(not authtkt or authtkt == 'INVALID',\n 'Session cookie was not deleted: %s' % home_page.request.cookies)\n eq_(home_page.location, 'http://localhost/')","def logout():\n session.pop('logged_in', None)\n return redirect(url_for('home'))","def logout():\n flash('You were logged out')\n session.pop('username', None)\n return redirect(url_for('welcome_page'))"],"string":"[\n \"def logout():\",\n \"def logout():\\n login()\",\n \"def logout(self):\",\n \"def logout(self):\\n pass\",\n \"def do_logout():\\n\\n session['authenticated'] = False\\n session['username'] = None\\n session['name'] = None\\n session['cpi'] = None\\n session['grp_size'] = None\\n\\n return home()\",\n \"def logOut(self):\\n self.client.logout()\",\n \"def logout(self):\\r\\n self._api_entrypoint.logout(self._session_token)\",\n \"def logout():\\n rino.login.logout()\",\n \"def logout(self):\\n logger.info(\\\"Logging out\\\")\\n self._limited_call(self._requests.get, constants.FA_ROOT + \\\"/logout/\\\")\",\n \"def logoff(self,username,password):\\n functions.checkLogged()\\n thread.stop()\\n try:\\n r = urllib2.urlopen(\\\"http://cs302.pythonanywhere.com/logoff?username={0}&password={1}\\\".format(username, password), timeout=4)\\n except socket.timeout, e:\\n logging.debug('Request to login server timed out')\\n except urllib2.URLError, e:\\n logging.debug('Unable to contact the login server')\\n cherrypy.lib.sessions.expire()\\n raise cherrypy.HTTPRedirect('/')\",\n \"def logout(self, **kwargs):\\n\\tself.call('logout')\",\n \"def logout(self):\\n self.client.get(f\\\"{host}/logout\\\")\",\n \"def logout_user():\\n pass\",\n \"def logout(self):\\n self.__send_command(\\\"LOGOUT\\\")\",\n \"def logout():\\n print(colored('\\\\nYou have successfully logged out.\\\\n', 'yellow',\\n attrs=['bold']))\\n exit()\",\n \"def log_out():\\n\\n del session[\\\"user_id\\\"]\\n # print session[\\\"user_id\\\"]\\n flash('You were successfully logged out')\\n return render_template('homepage.html')\\n\\n #Additional reference for log in/log out can be found in project tracker project\",\n \"def logout():\\n return logout_user()\",\n \"def logout():\\n session.clear()\\n return redirect(\\\"/showlog\\\")\",\n \"def logout(self):\\n try:\\n log.info(\\\"Logging out of the netscaler\\\")\\n self.post(\\\"/logout\\\", {\\\"logout\\\": {}})\\n except BadNetScaler as error:\\n log.error(\\\"Failed to logout of the netscaler: %s\\\", error)\\n self.sessionid = \\\"\\\"\",\n \"def t24_logoff(self):\\n if self.home_page:\\n self.login_page = self.home_page.sign_off()\\n self.home_page = None\",\n \"def test_logout(self):\\r\\n self.logout()\",\n \"def log_out():\\n if 'name' in session:\\n PLAN.logout_user(session['name'])\\n session.pop('name', None)\\n return redirect(url_for('log_in'))\\n return redirect(url_for('log_in'))\",\n \"def logout(self):\\n url = \\\"https://%s/game/index.php?page=logout\\\" % self.server\\n #\\\"https://s103-pt.ogame.gameforge.com/game/index.php?page=logout\\\"\\n self.session.get(url)\",\n \"def logout(self):\\n self.auth = None\",\n \"def logout():\\n session.pop('logged_in', None)\\n session.pop('fname', None)\\n session.pop('patron', None)\\n flash('You were logged out')\\n return redirect('/')\",\n \"def logoff(self):\\n\\t\\treturn Job(SDK.PrlSrv_Logoff(self.handle)[0])\",\n \"def log_out(self):\\n DB.log_out()\\n self.customer.log_out()\\n self.displayUi = LoginScreen()\\n self.hide()\\n self.displayUi.show()\",\n \"def log_out(self):\\n self.__is_logged_in = False\",\n \"def _logout(self):\\n self.api_query(action=\\\"logout\\\")\\n self._cookiejar.clear()\\n self._save_cookiejar()\",\n \"def logout():\\n\\n do_logout()\\n flash(f\\\"You are now logged out!\\\", \\\"success\\\")\\n return redirect('/')\",\n \"def logout(self, request):\\n pass\",\n \"def logout(self):\\n with self.client.post(\\\"/logout\\\", catch_response=True) as response:\\n for r_hist in response.history:\\n if r_hist.status_code > 200 and r_hist.status_code < 400:\\n response.success()\\n self.user.username = None\\n # go to UnauthenticatedTasks\\n self.interrupt()\",\n \"def _CAS_logout(self):\\n import urllib\\n redirect(\\\"%s?service=%s\\\" % (self.cas_logout_url, self.cas_my_url))\",\n \"def logout():\\n name = current_user.name\\n logout_user()\\n return f\\\"Logged out of {name}'s account!\\\"\",\n \"def axapi_logoff(self):\\n module = 'logoff'\\n method = 'POST'\\n response = self.axapi_call(module, method,'')\\n if '2' in str(response.status_code):\\n print(self.device + ' Successfully logged off of the device')\\n else:\\n print(self.device + ' There was an error trying to log off of the device')\",\n \"def logout():\\n\\n do_logout()\\n flash('successfully logged out')\\n return redirect(\\\"/\\\")\",\n \"def logout():\\n flash(\\\"You have been logged out\\\")\\n session.pop(\\\"user\\\")\\n return redirect(url_for(\\\"tips\\\"))\",\n \"def logout_post():\\n\\treturn \\\"LOGOUT\\\"\",\n \"def log_out_user(self):\\n flask_login.logout_user()\",\n \"def logout():\\n session.pop('userinfo', None)\\n # no more steps necessary, because we don't keep the token around\\n if 'target' not in session.keys():\\n return redirect(\\\"/\\\")\\n return redirect(session['target'])\",\n \"def logout():\\n update_session(\\\"X-GEMINI-APIKEY\\\", \\\"\\\")\\n set_secret_key(\\\"\\\".encode())\\n set_login_state(False)\",\n \"def logout():\\n if \\\"username\\\" in session.keys():\\n del session[\\\"username\\\"]\\n if not app.config[\\\"DISABLE_AUTH\\\"]:\\n return redirect(url_for(\\\"login\\\") + \\\"?slo\\\")\\n else:\\n return redirect(url_for(\\\"index\\\"))\",\n \"def logout():\\n\\n session.pop(\\\"leader_logged_in\\\", False)\\n session.pop(\\\"leader_id\\\", None)\\n session.pop(\\\"leader_email\\\", None)\\n\\n return redirect(f\\\"{BASEPATH}/login\\\")\",\n \"def do_logout():\\n del session[CURRENT_USER_KEY]\",\n \"def process_logout():\\n\\n print \\\" LOGGED OUT USER \\\"\\n\\n del session[\\\"user_id\\\"]\\n\\n flash(\\\"You have Successfully Logged Out!\\\")\\n\\n return redirect(\\\"/\\\")\",\n \"def process_logout():\\n\\n print \\\" LOGGED OUT USER \\\"\\n\\n del session[\\\"user_id\\\"]\\n\\n flash(\\\"You have Successfully Logged Out!\\\")\\n\\n return redirect(\\\"/\\\")\",\n \"def remove_florlp_session(session):\\n try:\\n requests.get(FLORLP_LOGOUT_URL,\\n cookies=session,\\n allow_redirects=False)\\n except requests.exceptions.RequestException, ex:\\n log.debug('error while removing session: %s', ex)\",\n \"def fusion_api_logout_appliance(self, headers=None):\\n # logger._log_to_console_and_log_file(\\\"Logging out of appliance\\\")\\n return self.loginsession.logout(headers)\",\n \"def logout():\\n flash(_('You were logged out'))\\n session.pop('user_id', None)\\n return redirect(url_for('index'))\\n #return redirect(url_for('public_timeline'))\",\n \"def logOut(self, e):\\n\\n\\t\\tself.unBind()\\n\\t\\tself.menu_manager.runLogin()\\n\\t\\tself.main_menu_window.root.destroy()\",\n \"def logout():\\n session.pop('logged_in', None)\\n flash('You were logged out')\\n return redirect(url_for('get_devices'))\",\n \"def logout():\\n\\n do_logout()\\n flash(\\\"Successfully logged out\\\", \\\"success\\\")\\n return redirect('/')\",\n \"def logout(self):\\n self.__isroot = 0\",\n \"def login():\",\n \"def login():\",\n \"def logout():\\n logout_user()\\n return redirect(url_for('main.index'))\",\n \"def logout():\\r\\n logout_user()\\r\\n flash('You were logged out.')\\r\\n return redirect(url_for('index'))\",\n \"def close(self):\\n\\n if self.closed:\\n return\\n\\n url = '{0}://{1}/admin/launch?script=rh&template=logout&action=logout'\\n\\n try:\\n resp = self._handle.open(url.format(self.proto, self.host))\\n pg = resp.read()\\n if 'You have been successfully logged out.' not in pg:\\n self.log('Failed logout, somehow:\\\\n{0}'.format(pg))\\n else:\\n self._closed = True\\n except (urllib2.HTTPError, urllib2.URLError) as e:\\n self.log('{0}: {1}'.format(e.__class__.__name__, e))\",\n \"def logout(self):\\n self.__aceQLHttpApi.logout()\",\n \"def logout():\\n session.pop('microsoft_token', None)\\n session.pop('state', None)\\n return redirect(url_for('index'))\",\n \"def logout():\\n session.pop('microsoft_token', None)\\n session.pop('state', None)\\n return redirect(url_for('index'))\",\n \"def signout(self):\\n username = cherrypy.session.get('username')\\n if username is None:\\n pass\\n else:\\n cherrypy.lib.sessions.expire()\\n raise cherrypy.HTTPRedirect('/')\",\n \"def logout(self):\\n data = {'action': 'logout'}\\n self.call(data)\\n self._high_limits = None\\n return True\",\n \"def logout():\\n session.pop('logged_in', None)\\n flash('You were logged out', 'success')\\n return redirect(url_for('show_entries'))\",\n \"def logout():\\n logout_user()\\n flash('You have successfully been logged out')\\n\\n # redirect to login page\\n return redirect(url_for('auth.login'))\",\n \"def logout():\\n session_logout()\\n return redirect(url_for(\\\"home\\\"))\",\n \"def GET_logout(self):\\r\\n self.logout()\\r\\n return self.redirect('/')\",\n \"def logout():\\n \\n del session[\\\"logged_in\\\"]\\n flash(\\\"See you later! ;)\\\")\\n return redirect('/')\",\n \"def logout(session):\\r\\n response = session.get(LOGOUT_URL)\\r\\n response.raise_for_status()\",\n \"def logout():\\n # clear user data from session and flag as logged out\\n for x in ['provider', 'state', 'user']:\\n if x in flask.session:\\n del flask.session[x]\\n flask.session['logged_in'] = False\\n\\n flash('logout successful', 'info')\\n return redirect(request.referrer or url_for('catalog.index'))\",\n \"def logout(self):\\n self.getLink('Logout').click()\\n self.html_redirect()\\n assert 'You have been logged out successfully.' in self.message, \\\\\\n 'Not successfully logged out: message={0.message!r}'.format(self)\",\n \"def logout_redirect():\\n login_session.clear()\\n flash('You have logged out')\\n return redirect(url_for('show_homepage'))\",\n \"def logout():\\n\\n session.clear()\\n return redirect(url_for('index'))\",\n \"def logout():\\n\\n session.clear()\\n return redirect(url_for('index'))\",\n \"def logout():\\n session.pop('username', None)\\n session.pop('user_id', None)\\n session.pop('logged_in', None)\\n session.pop('is_admin', None)\\n\\n flash('Successfully logged out', 'alert-info')\\n\\n return redirect(url_for('index'))\",\n \"def _handle_logout(self):\\n self.food_service.log_out()\\n self._handle_after_logout()\",\n \"def logout():\\n logout_user()\\n flash('You have successfully been logged out.')\\n\\n # redirect to the login page\\n return redirect(url_for('auth.login'))\",\n \"def logout():\\n logout_user()\\n flash('You have successfully been logged out.')\\n\\n # redirect to the login page\\n return redirect(url_for('auth.login'))\",\n \"def logout(endpoint):\\n communicator = ClickCallback()\\n logout_command().with_communicator(communicator).build().execute(endpoint=endpoint)\\n click.secho(\\\"Successfully logged out.\\\", fg=\\\"green\\\")\",\n \"def logout():\\n flask_login.logout_user()\\n flask.flash('Logged out')\\n return flask.redirect(flask.url_for('index'))\",\n \"async def exit(self, ctx):\\n print('Logging out...')\\n await ctx.bot.logout()\",\n \"def logout():\\n\\n session.clear()\\n crud.logout()\\n \\n return \\\"Logout Success\\\"\",\n \"def logout():\\n session['user_id'] = None\\n session['user_email'] = None\\n return redirect(url_for('main'))\",\n \"def logout():\\n logout_user()\\n flash('You have successfully been logged out.')\\n # redirect to the login page\\n return redirect(url_for('view.login'))\",\n \"def logout():\\n flash('You were logged out')\\n session.pop('user_id', None)\\n return redirect(url_for('leaderboard'))\",\n \"def _backend_logout_cleanup(self, name):\\n self.log.info(\\\"User logged out: %s\\\", name)\\n self.clear_login_cookie()\\n self.statsd.incr('logout')\",\n \"def logout():\\n session.clear()\\n return redirect(url_for('index'))\",\n \"def logout():\\n session['logged_in'] = False\\n return '', 204\",\n \"def logout():\\n session.clear()\\n return redirect(url_for(\\\"index\\\"))\",\n \"def logout():\\n session.clear()\\n return redirect(url_for(\\\"index\\\"))\",\n \"def logout():\\n session.clear()\\n return redirect(url_for(\\\"index\\\"))\",\n \"def logout(self):\\n flask_login.logout_user()\\n self.app.logger.info(\\\"User logged out!\\\")\\n return 'Logged out'\",\n \"def logout():\\n\\n # remove the username from the session if it is there\\n out_user = current_user.get_id()\\n logout_user()\\n logger.info(out_user + ' has been logged out.')\\n return redirect(url_for('home'))\",\n \"def logout():\\n\\n oidc.logout()\\n return 'Hi, you have been logged out! <a href=\\\"/oidc/\\\">Return</a>'\",\n \"def logout():\\n oidc.logout()\\n return 'Hi, you have been logged out! <a href=\\\"/\\\">Return</a>'\",\n \"def logout():\\n session.clear()\\n return redirect(url_for(\\\"home\\\"))\",\n \"def logout():\\n logout_user()\\n return redirect(url_for(\\\".login\\\"))\",\n \"def logout():\\n session.clear()\\n return redirect(url_for('home'))\",\n \"def test_logout(self):\\n # Logging in voluntarily the quick way:\\n resp = self.app.get('/login_handler?login=manager&password=managepass',\\n status=302)\\n resp = resp.follow(status=302)\\n ok_('authtkt' in resp.request.cookies,\\n 'Session cookie was not defined: %s' % resp.request.cookies)\\n # Logging out:\\n resp = self.app.get('/logout_handler', status=302)\\n ok_(resp.location.startswith('http://localhost/post_logout'))\\n # Finally, redirected to the home page:\\n home_page = resp.follow(status=302)\\n authtkt = home_page.request.cookies.get('authtkt')\\n ok_(not authtkt or authtkt == 'INVALID',\\n 'Session cookie was not deleted: %s' % home_page.request.cookies)\\n eq_(home_page.location, 'http://localhost/')\",\n \"def logout():\\n session.pop('logged_in', None)\\n return redirect(url_for('home'))\",\n \"def logout():\\n flash('You were logged out')\\n session.pop('username', None)\\n return redirect(url_for('welcome_page'))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7692397","0.73293793","0.7156266","0.70811003","0.7076655","0.70410043","0.70080215","0.6955402","0.6835801","0.6776245","0.67325246","0.6707584","0.67055","0.6672805","0.66292965","0.661934","0.6611719","0.6587299","0.6579601","0.6559363","0.6532657","0.652281","0.6512069","0.6510874","0.6507719","0.64661473","0.6452549","0.64431024","0.63743013","0.6358471","0.6343165","0.6332889","0.6330973","0.631329","0.62983817","0.6291967","0.6291616","0.62868255","0.62825036","0.62788975","0.6276006","0.6266274","0.6264183","0.62421834","0.62360024","0.62360024","0.6233862","0.6231952","0.6231309","0.6228663","0.62275606","0.6218061","0.6217264","0.6214039","0.6214039","0.62111115","0.62108487","0.6204969","0.62048197","0.6199702","0.6199702","0.6199417","0.6187214","0.61870974","0.6179584","0.61776316","0.6177053","0.61740357","0.61738926","0.6168662","0.61684394","0.61679053","0.61578757","0.61578757","0.61557317","0.6154602","0.6152497","0.6152497","0.61523116","0.61460096","0.6140666","0.6140635","0.61343503","0.6124619","0.612217","0.6120571","0.6114195","0.6114046","0.611088","0.611088","0.611088","0.61102104","0.6108009","0.6105357","0.6100985","0.6098438","0.6097895","0.609622","0.6093335","0.60872936","0.6086858"],"string":"[\n \"0.7692397\",\n \"0.73293793\",\n \"0.7156266\",\n \"0.70811003\",\n \"0.7076655\",\n \"0.70410043\",\n \"0.70080215\",\n \"0.6955402\",\n \"0.6835801\",\n \"0.6776245\",\n \"0.67325246\",\n \"0.6707584\",\n \"0.67055\",\n \"0.6672805\",\n \"0.66292965\",\n \"0.661934\",\n \"0.6611719\",\n \"0.6587299\",\n \"0.6579601\",\n \"0.6559363\",\n \"0.6532657\",\n \"0.652281\",\n \"0.6512069\",\n \"0.6510874\",\n \"0.6507719\",\n \"0.64661473\",\n \"0.6452549\",\n \"0.64431024\",\n \"0.63743013\",\n \"0.6358471\",\n \"0.6343165\",\n \"0.6332889\",\n \"0.6330973\",\n \"0.631329\",\n \"0.62983817\",\n \"0.6291967\",\n \"0.6291616\",\n \"0.62868255\",\n \"0.62825036\",\n \"0.62788975\",\n \"0.6276006\",\n \"0.6266274\",\n \"0.6264183\",\n \"0.62421834\",\n \"0.62360024\",\n \"0.62360024\",\n \"0.6233862\",\n \"0.6231952\",\n \"0.6231309\",\n \"0.6228663\",\n \"0.62275606\",\n \"0.6218061\",\n \"0.6217264\",\n \"0.6214039\",\n \"0.6214039\",\n \"0.62111115\",\n \"0.62108487\",\n \"0.6204969\",\n \"0.62048197\",\n \"0.6199702\",\n \"0.6199702\",\n \"0.6199417\",\n \"0.6187214\",\n \"0.61870974\",\n \"0.6179584\",\n \"0.61776316\",\n \"0.6177053\",\n \"0.61740357\",\n \"0.61738926\",\n \"0.6168662\",\n \"0.61684394\",\n \"0.61679053\",\n \"0.61578757\",\n \"0.61578757\",\n \"0.61557317\",\n \"0.6154602\",\n \"0.6152497\",\n \"0.6152497\",\n \"0.61523116\",\n \"0.61460096\",\n \"0.6140666\",\n \"0.6140635\",\n \"0.61343503\",\n \"0.6124619\",\n \"0.612217\",\n \"0.6120571\",\n \"0.6114195\",\n \"0.6114046\",\n \"0.611088\",\n \"0.611088\",\n \"0.611088\",\n \"0.61102104\",\n \"0.6108009\",\n \"0.6105357\",\n \"0.6100985\",\n \"0.6098438\",\n \"0.6097895\",\n \"0.609622\",\n \"0.6093335\",\n \"0.60872936\",\n \"0.6086858\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":7293,"cells":{"query":{"kind":"string","value":"Get data from resources endpoint"},"document":{"kind":"string","value":"async def update(self, account) -> dict:\n data = {}\n\n URL_RESOURCES_ACCOUNT = API_HOST + \"/api/resources/account/{account}\"\n\n async with async_timeout.timeout(TIMEOUT):\n response = await self.session.get(\n URL_RESOURCES_ACCOUNT.format(account=account)\n )\n account_data = (await response.json())[\"data\"]\n\n premise = account_data.get(\"premiseNumber\").zfill(9)\n\n data[\"meterSerialNo\"] = account_data[\"meterSerialNo\"]\n\n # currentBillDate\n currentBillDate = datetime.strptime(\n account_data[\"currentBillDate\"].replace(\"-\", \"\").split(\"T\")[0], \"%Y%m%d\"\n ).date()\n\n # nextBillDate\n nextBillDate = datetime.strptime(\n account_data[\"nextBillDate\"].replace(\"-\", \"\").split(\"T\")[0], \"%Y%m%d\"\n ).date()\n\n data[\"current_bill_date\"] = str(currentBillDate)\n data[\"next_bill_date\"] = str(nextBillDate)\n\n today = datetime.now().date()\n\n data[\"service_days\"] = (nextBillDate - currentBillDate).days\n data[\"as_of_days\"] = (today - currentBillDate).days\n data[\"remaining_days\"] = (nextBillDate - today).days\n\n # zip code\n # zip_code = accountData[\"serviceAddress\"][\"zip\"]\n\n # projected bill\n pbData = await self.__getFromProjectedBill(account, premise, currentBillDate)\n data.update(pbData)\n\n # programs\n programsData = account_data[\"programs\"][\"data\"]\n\n programs = dict()\n _LOGGER.info(\"Getting Programs\")\n for program in programsData:\n if \"enrollmentStatus\" in program.keys():\n key = program[\"name\"]\n programs[key] = program[\"enrollmentStatus\"] == ENROLLED\n\n def hasProgram(programName) -> bool:\n return programName in programs and programs[programName]\n\n # Budget Billing program\n if hasProgram(\"BBL\"):\n data[\"budget_bill\"] = True\n bbl_data = await self.__getBBL_async(account, data)\n data.update(bbl_data)\n else:\n data[\"budget_bill\"] = False\n\n # Get data from energy service\n data.update(\n await self.__getDataFromEnergyService(account, premise, currentBillDate)\n )\n\n # Get data from energy service ( hourly )\n # data.update(\n # await self.__getDataFromEnergyServiceHourly(\n # account, premise, currentBillDate\n # )\n # )\n\n data.update(await self.__getDataFromApplianceUsage(account, currentBillDate))\n data.update(await self.__getDataFromBalance(account))\n\n return data"},"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_resources():\n return Response(f\"{Resource.get_all_resources()}\", 200, mimetype='text/plain')","def list(self, **kwargs):\n data, self.endpoint = self.data_endpoint(kwargs)\n r = super(Resource, self).list(**data)\n\n # Change display settings and data format for human consumption\n self.configure_display(r)\n return r","def get(self) -> Response:\n try:\n resource = request.args.getlist(\"resource\")[0]\n return set_response_headers(jsonify(get_fragments(resource)))\n except:\n return set_response_headers(jsonify(get_doc().generate()))","def get_resources():\n user_id = session[\"email\"]\n resources = fm.get_resources(user_id)\n returned_val = dict(resources=resources)\n return jsonify(returned_val)","def all(self, resource):\n return self.request('/' + resource)","def get_resource_data(self, resource):\n url = self.api_url + resource\n return self.get_url_data(url)","def get(self, resource, ids, page=1):\n url = urljoin(self.base_url, resource)\n response = requests.get(url, params={'ids[]': ids, 'page': page})\n\n return response.json()","def get_resources(self, resource_id):\n url = \"%s/resource/%s\" % ('None', resource_id)\n resp, body = self.get(url)\n self.expected_success(200, resp.status)\n body = json.loads(body)\n return service_client.ResponseBody(resp, body)","def get(self, data):\n ret = self._rest_call({}, 'GET')\n return json.loads(ret[2])","async def get_resources(self, **kwargs) -> dict:\n resources = await self.request.get(self._base_path, **kwargs)\n self._sanitize_resources(resources)\n return resources","def on_get_resource(self, req, resp, **params):\n instance = self.get_object(**params)\n resp.json(**instance.as_resource)","def GetResourceSample():\n client = CreateClient()\n for e1 in client.GetResources(limit=5).entry:\n e2 = client.GetResource(e1)\n print 'Refetched: ', e2.title.text, e2.resource_id.text","def get(self, id=None, o=None):\n\n response = []\n current_user = self.get_current_user()\n\n # [?timestamp_start=<XXX>×tamp_end=<XXX>]\n ts = self.get_argument('timestamp_start',None)\n te = self.get_argument('timestamp_end',None)\n\n # GET /resources\n if not id and not o and not ts and not te:\n cursor = yield r.table('resources') \\\n .run(self.dbconnection)\n while (yield cursor.fetch_next()):\n item = yield cursor.next()\n response.append(item)\n\n # GET /resources?timestamp_start=<XXX>×tamp_end=<XXX>\n elif not id and not o:\n try:\n nb_leases = yield r.table(\"leases\").count().run(self.dbconnection)\n if nb_leases > 0:\n # Resources NOT in Leases\n cursor = yield r.table('resources') \\\n .filter({'available':'true'}) \\\n .filter( lambda resource:\n r.table(\"leases\").map(lambda l:\n l['resources'].coerce_to('array')\n ).reduce(lambda left, right:\n left.set_union(right)\n ).contains(resource['id']).not_() \\\n ).run(self.dbconnection)\n while (yield cursor.fetch_next()):\n item = yield cursor.next()\n response.append(item)\n\n if ts and te:\n # List of Resources ids in Leases but not in the given time range\n in_leases = yield r.table(\"leases\").filter(lambda l:\n r.or_(l['start_time'].gt(int(te)),l['end_time'].lt(int(ts)))\n ).map(lambda l:\n l['resources'].coerce_to('array')\n ).reduce(lambda left, right:\n left.set_union(right)\n ).map(lambda x:\n r.table('resources').get(x) \\\n ).run(self.dbconnection)\n logger.debug(in_leases)\n response = response + in_leases\n\n if ts and not te:\n # List of Resources ids in Leases but not in the given time range\n in_leases = yield r.table(\"leases\").filter(lambda l:\n l['end_time'].lt(int(ts))\n ).map(lambda l:\n l['resources'].coerce_to('array')\n ).reduce(lambda left, right:\n left.set_union(right)\n ).map(lambda x:\n r.table('resources').get(x) \\\n ).run(self.dbconnection)\n response = response + in_leases\n\n if not ts and te:\n # List of Resources ids in Leases but not in the given time range\n in_leases = yield r.table(\"leases\").filter(lambda l:\n l['start_time'].gt(int(te))\n ).map(lambda l:\n l['resources'].coerce_to('array')\n ).reduce(lambda left, right:\n left.set_union(right)\n ).map(lambda x:\n r.table('resources').get(x) \\\n ).run(self.dbconnection)\n response = response + in_leases\n else:\n # All available Resources (No Leases in DB)\n cursor = yield r.table('resources') \\\n .filter({'available':'true'}) \\\n .run(self.dbconnection)\n while (yield cursor.fetch_next()):\n item = yield cursor.next()\n response.append(item)\n except Exception as e:\n logger.exception(e)\n\n # GET /resources/<id>\n elif not o and id and self.isUrn(id):\n\n cursor = yield r.table('resources') \\\n .filter({'id': id}) \\\n .run(self.dbconnection)\n while (yield cursor.fetch_next()):\n item = yield cursor.next()\n response.append(item)\n # GET /resources/<id>/leases\n elif id and self.isUrn(id) and o == 'leases':\n cursor = yield r.table(o) \\\n .filter(lambda lease: lease[\"resources\"].contains(id)) \\\n .run(self.dbconnection)\n #\n\n while (yield cursor.fetch_next()):\n item = yield cursor.next()\n response.append(item)\n # GET /resources/<id>/slices\n elif id and self.isUrn(id) and o == 'slices':\n cursor = yield r.table(o) \\\n .filter(lambda slice: slice[\"resources\"]==id) \\\n .run(self.dbconnection)\n #\n\n while (yield cursor.fetch_next()):\n item = yield cursor.next()\n response.append(item)\n # GET /resources/<id>/testbeds\n elif id and self.isUrn(id) and o == 'testbeds':\n cursor = yield r.table('resources') .filter({'id': id}) \\\n .pluck('id','testbed','manager') \\\n .merge(lambda res: {\n 'testbeds': r.table('testbeds').get_all(res['testbed'], index='id') \\\n .coerce_to('array')\n }) \\\n .run(self.dbconnection)\n while (yield cursor.fetch_next()):\n item = yield cursor.next()\n response.append(item)\n else:\n self.userError(\"invalid request\")\n\n return\n\n self.finish(json.dumps({\"result\": response}, cls=myJSONEncoder))","def GetResourcesSample():\n client = CreateClient()\n # Get a feed and print it\n feed = client.GetResources()\n PrintFeed(feed)","def test_get_api_resources(self):\n pass","def _get_resource(self, *args, **kwargs):\r\n r = []\r\n if kwargs['resource'] in self.resources:\r\n r = self.get_list(\r\n api_endpoint=settings.GITHUB_SETTINGS['GITHUB_USER_REPO_API'].format(**kwargs), **kwargs\r\n )\r\n else:\r\n ValueError(\"{resource} - Resource Not Supported\".format(**kwargs)) \r\n return r","def get(self):\n try:\n query_parameters = request.args\n logging.debug(f\" query params - {query_parameters}\")\n top, skip, expand_code, selects = parse_args(query_parameters)\n ds_list = Datastreams.return_page_with_expand(\n top, skip, expand_code, selects\n )\n response = jsonify(ds_list)\n response.status_code = 200\n except Exception as e:\n logging.warning(e)\n response = jsonify({\"message\": \"error\"})\n response.status_code = 400\n\n finally:\n return response","def get_all(self, context, filters=None):\n try:\n db_resources_data = self.db_api.get_all_resources(\n context, **filters)\n\n _resources_data = []\n for db_resource_data in db_resources_data:\n _resources_data.append(_make_response(db_resource_data))\n except Exception as e:\n msg = (\"Error retrieving the 'resources' reason : %s\"\n % e.message)\n LOG.exception(msg)\n raise exception.RetrieveException(e.message)\n return _resources_data","def get(self, request, *args, **kwargs):\n return self.list(request, *args, **kwargs)","def get(self, request, *args, **kwargs):\n return self.list(request, *args, **kwargs)","def get(self, request, *args, **kwargs):\n return self.list(request, *args, **kwargs)","def get(self, request, *args, **kwargs):\n return self.list(request, *args, **kwargs)","def get(self, request, *args, **kwargs):\n return self.list(request, *args, **kwargs)","def get(self, url_or_path):\n return self.request.get(url_or_path).json()","def get(self, data):\n pass","def test_get_resource(self):\n for i in range(11):\n self.app.post(f'/v1/resource/{ResourceTypeName.get()}', data=json.dumps({'actions': ['tr:action1']}),\n headers=admin_headers)\n self._test_paging('/v1/resources', admin_headers, 10, 'resources')","def get(self, context, id_):\n try:\n db_resource_data = self.db_api.get_resource(\n context, id_)\n _resource_data = _make_response(db_resource_data,\n meta_data=False)\n\n except exception.NotFound as e:\n raise e\n\n except Exception as e:\n msg = (\"Error retrieving the 'resource':%s. Reason: %s\"\n % (id_, e.message))\n LOG.exception(msg)\n raise exception.RetrieveException(e.message)\n\n LOG.info(\"Resource manager data is %s \" %\n logging.mask_password(_resource_data))\n return _resource_data","def get(self):\n try:\n query_parameters = request.args\n logging.debug(f\" query params - {query_parameters}\")\n if query_parameters:\n thing = None\n sensor = None\n if \"thing\" in query_parameters:\n thing = request.args[\"thing\"]\n if \"sensor\" in query_parameters:\n sensor = request.args[\"sensor\"]\n logging.debug(f\"thing={thing},sensor={sensor}\")\n datastreams = Datastreams.filter_by_thing_sensor(thing, sensor)\n else:\n result = {\"message\": \"no known query parameters\"}\n response = jsonify(result)\n response.status_code = 400\n return response\n\n except Exception as e:\n logging.warning(e)\n result = {\"message\": \"error\"}\n response = jsonify(result)\n response.status_code = 400\n return response\n\n if datastreams:\n response = jsonify(datastreams)\n response.status_code = 200\n return response\n else:\n result = {\"message\": \"No datastreams found\"}\n response = jsonify(result)\n response.status_code = 200\n return response","def get_resources(self, resource_url):\n response = self.response(resource_url)\n body = response[0]\n return ResourceParser.extract_resources(body)","def get(owner, resource):\n resource = logic.resource.find(owner, resource)\n return jsonify(resource)","def get(self):\r\n return http.Request('GET', self.get_url()), parsers.parse_json","def get(self):\r\n return http.Request('GET', self.get_url()), parsers.parse_json","async def get(self, filters: dict = None):\n\n res = self.__get_data(filters)\n\n return res","def get(self, *path, **data):\n\t\treturn self.request('GET', *path, **data)","def handle_get():\n for resource in resources:\n\n # acquire lock\n res_lock = resource.get(\"lock\")\n res_lock.acquire()\n\n # Get if available\n if resource.get(\"available\") == \"true\":\n # Available - acquire resource and return\n resource.update({\"available\": \"false\"})\n res_lock.release()\n return jsonify(resource.get(\"data\"))\n\n # Not available, release and continue\n res_lock.release()\n\n # All resources are taken\n return app.make_response(('No available resource', 500))","def getResourceData(self, authenticationToken, guid):\r\n pass","def list(self):\n url = self._resource_name\n return self._get(url)","def get_data(self, url):\n return self.get(url).get('data', [])","def get(self, *args):\n return self.docs.get(*args)","def ResourceList(self):\n url = AddToUrl(self, 'https://api.spiget.org/v2/resources?')\n return ApiSearch(url)","def get():\n\n # \\todo List of available data, fetched and processed\n\n return jsonify({'valid_resources': ['balance', 'balance_usd', 'trade_history', 'balance_norm_price_history', 'open_orders']})","def get(self, prefix, paths, data_type, use_models):\n pass","def _get(self, *args, **kwargs):\n return self._request('get', *args, **kwargs)","def get(self):\n\n try:\n args = api_parameters.parse_args()\n limit = args.get(\"limit\")\n controller = self.controller()\n schema = self.schema(many=True)\n raw_data = controller.get_list(**args)\n\n if limit:\n items = raw_data.items\n items = schema.dump(items)\n data = ResponseHandler.get_section_paginate(raw_data, items)\n\n else:\n data = schema.dump(raw_data)\n\n return ResponseHandler.render_response(data=data)\n\n except Exception as ex:\n\n return ResponseHandler.render_response(status=ERR, message=traceback.format_exc())","def resources(self):","def _get(self, path):\n r = requests.get(self._url(path))\n assert r.status_code == 200\n return r.json","def get_resources(resource_client) -> list:\n resource_list = []\n paginator = resource_client.get_paginator(BOTO3_LIST_FUNCTION)\n pages = paginator.paginate()\n for page in pages:\n # Your going to have to look through the response and append the correct value to the list\n resource = page[\"something\"]\n resource_list = resource_list + resource\n return resource_list","def get(self, *args, **kwargs):\n return self._request('get', *args, **kwargs)","def get(resource, lookup):\n\n documents = []\n response = {}\n etag = None\n req = parse_request(resource)\n embedded_fields = _resolve_embedded_fields(resource, req)\n\n # facilitate cached responses\n if req.if_modified_since:\n # client has made this request before, has it changed?\n # this request does not account for deleted documents!!! (issue #243)\n preflight_req = copy.copy(req)\n preflight_req.max_results = 1\n\n cursor = app.data.find(resource, preflight_req, lookup)\n if cursor.count() == 0:\n # make sure the datasource is not empty (#243).\n if not app.data.is_empty(resource):\n # the if-modified-since conditional request returned no\n # documents, we send back a 304 Not-Modified, which means that\n # the client already has the up-to-date representation of the\n # resultset.\n status = 304\n last_modified = None\n return response, last_modified, etag, status\n\n # continue processing the full request\n last_update = epoch()\n req.if_modified_since = None\n cursor = app.data.find(resource, req, lookup)\n\n for document in cursor:\n _build_response_document(document, resource, embedded_fields)\n documents.append(document)\n\n # build last update for entire response\n if document[config.LAST_UPDATED] > last_update:\n last_update = document[config.LAST_UPDATED]\n\n status = 200\n last_modified = last_update if last_update > epoch() else None\n\n # notify registered callback functions. Please note that, should the\n # functions modify the documents, the last_modified and etag won't be\n # updated to reflect the changes (they always reflect the documents\n # state on the database.)\n\n getattr(app, \"on_fetched_resource\")(resource, documents)\n getattr(app, \"on_fetched_resource_%s\" % resource)(documents)\n\n if config.DOMAIN[resource]['hateoas']:\n response[config.ITEMS] = documents\n response[config.LINKS] = _pagination_links(resource, req,\n cursor.count())\n else:\n response = documents\n\n # the 'extra' cursor field, if present, will be added to the response.\n # Can be used by Eve extensions to add extra, custom data to any\n # response.\n if hasattr(cursor, 'extra'):\n getattr(cursor, 'extra')(response)\n\n return response, last_modified, etag, status","def get(self, request, resource=None, **kwargs):\n if resource is not None and resource != '':\n return self.to_simple(request, resource, **kwargs)\n\n return self.to_simple(request, self.collection, many=True, **kwargs)","def get_resource(self, resource, method='get', data=None, headers=None, json=False, **kwargs): # nolint\r\n method = getattr(self.client, method)\r\n resource, headers, data = self.get_params(\r\n resource, headers, data, **kwargs)\r\n\r\n # Support JSON request\r\n if json:\r\n headers['content_type'] = 'application/json'\r\n data = simplejson.dumps(data)\r\n\r\n response = method(resource, data=data, **headers)\r\n return self._jsonify(response)","def resource_bundle(resource_type, methods=[\"GET\"]):\n token = validate_auth()\n url = current_app.config.get('MAP_API') + resource_type\n params = {'_count': 1000}\n params.update(request.args)\n resp = requests.get(url, auth=BearerAuth(token), params=params)\n try:\n resp.raise_for_status()\n except requests.exceptions.HTTPError as err:\n abort(err.response.status_code, err)\n\n return jsonify(resp.json())","def get_data(self, request, url):\n data = request.get(endpoint=url)\n return data[0], data[1]","def _fetch_resource(self):\n\n qs = self._build_qs() # Build the query string\n url = self._build_url(qs) # Build the full url\n fp = self._api_call(url) # Fetch the data as a file pointer\n\n # Parse the list of dicts in to a dict generator\n return csv.DictReader(fp)","def get_all(self):\n result_get = GetRest(function = self.function).performRequest()\n return result_get","async def get_api_data(self, referer: str, params: list) -> list:\n return await asyncio.ensure_future(self.get_response(referer, params))","def get(self, endpoint, data=None):\n if endpoint.startswith(\"http\"):\n url = endpoint\n elif endpoint.startswith(\"/\"):\n url = \"{}{}\".format(api_endpoint, endpoint)\n else:\n url = \"{}/{}\".format(api_endpoint, endpoint)\n\n response = requests.get(\n url,\n data=data,\n headers= {\n \"Content-Type\": \"application/json\",\n \"Accept\": \"application/json\",\n \"Authorization\": \"Bearer \" + self.token,\n }\n )\n\n if response.status_code == 200:\n return response.json()\n elif response.status_code == 404:\n print(\"404: Probably invalid endpoint\")\n else:\n print(\"ERROR IN REQUEST: {}\".format(response.content))\n return response","def get(self, id):\n try:\n query_parameters = request.args\n logging.debug(f\" query params - {query_parameters}\")\n top, skip, expand_code, selects = parse_args(query_parameters)\n\n ds_list = Datastreams.filter_by_thing_id(\n id, top, skip, expand_code, selects\n )\n response = jsonify(ds_list)\n response.status_code = 200\n except Exception as e:\n logging.warning(e)\n response = jsonify({\"message\": \"error\"})\n response.status_code = 400\n return response\n\n finally:\n return response","def list(self):\n return self.request(\"GET\")","def get_api_resources(self, **kwargs):\n\n all_params = []\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method get_api_resources\" % key\n )\n params[key] = val\n del params['kwargs']\n\n\n resource_path = '/oapi/v1'.replace('{format}', 'json')\n path_params = {}\n\n query_params = {}\n\n header_params = {}\n\n form_params = []\n local_var_files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json', 'application/yaml'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json', 'application/yaml'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, 'GET',\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=local_var_files,\n response_type=None,\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response","def get(self, *args, **kwargs):\n return self._hit(\"GET\", *args, **kwargs)","def get(self, *args, **kwargs) -> Any:\n return self.raw_data.get(*args, **kwargs)","def get(self, *args, **kwargs):","def get(self, request, **resources):\r\n\r\n instance = resources.get(self._meta.name)\r\n if not instance is None:\r\n return instance\r\n\r\n return self.paginate(\r\n request, self.get_collection(request, **resources))","def get_rest_data_source(uri):\n def players_from_rest():\n response = requests.get(uri)\n response.raise_for_status()\n return parse_players_json(response.text)\n return players_from_rest","async def get(self, path, params=None, json_data=None):\n response = await self.request('GET', path, params, json_data)\n return response","def request_endpoints(self):\n\n endpoints_url = self.std[\"api\"]\n endpoints_paramd = {\n \"access_token\": self.std[\"access_token\"]\n }\n\n endpoints_response = requests.get(url=endpoints_url, params=endpoints_paramd)\n print endpoints_response\n self.endpointd = endpoints_response.json()[0]","def getResource(self, authenticationToken, guid, withData, withRecognition, withAttributes, withAlternateData):\r\n pass","def get(self, start=None, limit=None):\r\n params = base.get_params(None, locals())\r\n return http.Request('GET', self.get_url(), params), parsers.parse_json","def get_data_by_uuid(request, uuid, hours):\n\tif request.method == 'GET':\n\t\treadings = get_data_by_uuid_helper(uuid, hours)\n\t\treturn Response(readings)","def GetAllResourcesSample():\n client = CreateClient()\n # Unlike client.GetResources, this returns a list of resources\n for resource in client.GetAllResources():\n PrintResource(resource)","async def get(self, **context):\n return {}","def get(self, *args, **kwargs):\n url = urljoin(self.instance(), args[0])\n return self._requests_call(util.requests_get, url, *args[1:], **kwargs)","def index():\n return make_json_response(ENDPOINT_LIST)","def get(self):\r\n request = http.Request('GET', self.get_url())\r\n\r\n return request, parsers.parse_json","def get(self):\r\n request = http.Request('GET', self.get_url())\r\n\r\n return request, parsers.parse_json","def get(self):\r\n request = http.Request('GET', self.get_url())\r\n\r\n return request, parsers.parse_json","def get(self):\r\n request = http.Request('GET', self.get_url())\r\n\r\n return request, parsers.parse_json","def get(self):\r\n return get_all()","def _get_all_data(self, resource):\n response = self._get_raising('{}{}?per_page=100&page=1'.format(\n self.GH_API_ENDPOINT, resource\n ))\n yield from response.json()\n while 'next' in response.links:\n response = self._get_raising(response.links['next']['url'])\n yield from response.json()","def getResourceDef(url, user, pWd, resourceName):\n \n print(\"getting resource for catalog:-\" + url + \" resource=\" + resourceName +\n ' user=' + user)\n apiURL = url + '/access/1/catalog/resources/' + resourceName\n # print(\"\\turl=\" + apiURL)\n header = {\"Accept\": \"application/json\"} \n tResp = requests.get(apiURL, params={}, headers=header, auth=HTTPBasicAuth(user,pWd))\n print(\"\\tresponse=\" + str(tResp.status_code))\n if tResp.status_code == 200:\n # valid - return the jsom\n return tResp.status_code, json.loads(tResp.text)\n else:\n # not valid\n return tResp.status_code, None","def _get(self):\n return self.request(method=\"get\", path=self.router.fields)","def get(self, *args, **kwargs):\n pass","def get(self, *args, **kwargs):\n pass","def process_resource_listing_api(self, resources, listing_api, context):\n pass","def get(cls, client, name=\"\", option_=\"\") :\n\t\ttry :\n\t\t\tif not name :\n\t\t\t\tobj = l3param()\n\t\t\t\tresponse = obj.get_resources(client, option_)\n\t\t\treturn response\n\t\texcept Exception as e :\n\t\t\traise e","def get(self, embed=None, fields=None):\r\n params = base.get_params(None, locals())\r\n\r\n return http.Request('GET', self.get_url(), params), parsers.parse_json","def get(self, format=None, page=None, per_page=None):\r\n url = self.get_url()\r\n params = base.get_params(('page', 'per_page'), locals())\r\n headers = resource.mimetype_accept(format)\r\n\r\n return http.Request('GET', url, params, headers), parsers.parse_json","def get(self, Muted=None, Page=None, PageSize=None, AfterSid=None):\r\n params = resource.get_params(None, locals())\r\n request = http.Request('GET', self.get_url(), params)\r\n\r\n return request, parsers.parse_json","def get(self, *args):","def get(self, api_path, *args, **kwargs):\n\n\t\treturn self._do_operation(u'get', api_path, *args, **kwargs)","def get_all_data():\n return jsonify(service.get_all_data())","def get(self, path: str) -> Response:\n endpoint_ = checkEndpoint(\"GET\", path)\n if not endpoint_[\"method\"]:\n # If endpoint and Get method not supported in the API\n abort(endpoint_[\"status\"])\n return item_collection_get_response(path)","def _get(self, path, params=None):\n return self._api.get_json(path, headers={\"Hawkular-Tenant\": self.tenant_id}, params=params)","def resources(self, query):\n return _MockResponse()","def resource_by_id(resource_type, resource_id, methods=[\"GET\"]):\n token = validate_auth()\n url = f\"{current_app.config.get('MAP_API')}{resource_type}/{resource_id}\"\n resp = requests.get(url, auth=BearerAuth(token))\n try:\n resp.raise_for_status()\n except requests.exceptions.HTTPError as err:\n abort(err.response.status_code, err)\n\n return jsonify(resp.json())","def get_data(self):","def get(self, *args, **kwargs):\n self.request(\"get\", *args, **kwargs)","def getAll(self):\n result_get = GetRest(function = self.function).performRequest()\n return result_get","def get_resources(genome_build, fasta_ref, data):\n config = tz.get_in([\"config\", CONFIG_KEY], data)\n find_fn = _find_file(config)\n def normalize(f):\n return _get_id_fname(f)[-1]\n return sret.get_resources(genome_build, fasta_ref, config,\n data, _open_remote, _list(config), find_fn, normalize)","def get(log, session, args):\n url = \"{}datasets/{}\".format(\n http.get_api_url(args.url, args.project),\n args.id)\n log.debug('GET: {}'.format(url))\n response_json = http.get(session, url)\n log.print_json(response_json, \"dataset\", \"get\")"],"string":"[\n \"def get_resources():\\n return Response(f\\\"{Resource.get_all_resources()}\\\", 200, mimetype='text/plain')\",\n \"def list(self, **kwargs):\\n data, self.endpoint = self.data_endpoint(kwargs)\\n r = super(Resource, self).list(**data)\\n\\n # Change display settings and data format for human consumption\\n self.configure_display(r)\\n return r\",\n \"def get(self) -> Response:\\n try:\\n resource = request.args.getlist(\\\"resource\\\")[0]\\n return set_response_headers(jsonify(get_fragments(resource)))\\n except:\\n return set_response_headers(jsonify(get_doc().generate()))\",\n \"def get_resources():\\n user_id = session[\\\"email\\\"]\\n resources = fm.get_resources(user_id)\\n returned_val = dict(resources=resources)\\n return jsonify(returned_val)\",\n \"def all(self, resource):\\n return self.request('/' + resource)\",\n \"def get_resource_data(self, resource):\\n url = self.api_url + resource\\n return self.get_url_data(url)\",\n \"def get(self, resource, ids, page=1):\\n url = urljoin(self.base_url, resource)\\n response = requests.get(url, params={'ids[]': ids, 'page': page})\\n\\n return response.json()\",\n \"def get_resources(self, resource_id):\\n url = \\\"%s/resource/%s\\\" % ('None', resource_id)\\n resp, body = self.get(url)\\n self.expected_success(200, resp.status)\\n body = json.loads(body)\\n return service_client.ResponseBody(resp, body)\",\n \"def get(self, data):\\n ret = self._rest_call({}, 'GET')\\n return json.loads(ret[2])\",\n \"async def get_resources(self, **kwargs) -> dict:\\n resources = await self.request.get(self._base_path, **kwargs)\\n self._sanitize_resources(resources)\\n return resources\",\n \"def on_get_resource(self, req, resp, **params):\\n instance = self.get_object(**params)\\n resp.json(**instance.as_resource)\",\n \"def GetResourceSample():\\n client = CreateClient()\\n for e1 in client.GetResources(limit=5).entry:\\n e2 = client.GetResource(e1)\\n print 'Refetched: ', e2.title.text, e2.resource_id.text\",\n \"def get(self, id=None, o=None):\\n\\n response = []\\n current_user = self.get_current_user()\\n\\n # [?timestamp_start=<XXX>×tamp_end=<XXX>]\\n ts = self.get_argument('timestamp_start',None)\\n te = self.get_argument('timestamp_end',None)\\n\\n # GET /resources\\n if not id and not o and not ts and not te:\\n cursor = yield r.table('resources') \\\\\\n .run(self.dbconnection)\\n while (yield cursor.fetch_next()):\\n item = yield cursor.next()\\n response.append(item)\\n\\n # GET /resources?timestamp_start=<XXX>×tamp_end=<XXX>\\n elif not id and not o:\\n try:\\n nb_leases = yield r.table(\\\"leases\\\").count().run(self.dbconnection)\\n if nb_leases > 0:\\n # Resources NOT in Leases\\n cursor = yield r.table('resources') \\\\\\n .filter({'available':'true'}) \\\\\\n .filter( lambda resource:\\n r.table(\\\"leases\\\").map(lambda l:\\n l['resources'].coerce_to('array')\\n ).reduce(lambda left, right:\\n left.set_union(right)\\n ).contains(resource['id']).not_() \\\\\\n ).run(self.dbconnection)\\n while (yield cursor.fetch_next()):\\n item = yield cursor.next()\\n response.append(item)\\n\\n if ts and te:\\n # List of Resources ids in Leases but not in the given time range\\n in_leases = yield r.table(\\\"leases\\\").filter(lambda l:\\n r.or_(l['start_time'].gt(int(te)),l['end_time'].lt(int(ts)))\\n ).map(lambda l:\\n l['resources'].coerce_to('array')\\n ).reduce(lambda left, right:\\n left.set_union(right)\\n ).map(lambda x:\\n r.table('resources').get(x) \\\\\\n ).run(self.dbconnection)\\n logger.debug(in_leases)\\n response = response + in_leases\\n\\n if ts and not te:\\n # List of Resources ids in Leases but not in the given time range\\n in_leases = yield r.table(\\\"leases\\\").filter(lambda l:\\n l['end_time'].lt(int(ts))\\n ).map(lambda l:\\n l['resources'].coerce_to('array')\\n ).reduce(lambda left, right:\\n left.set_union(right)\\n ).map(lambda x:\\n r.table('resources').get(x) \\\\\\n ).run(self.dbconnection)\\n response = response + in_leases\\n\\n if not ts and te:\\n # List of Resources ids in Leases but not in the given time range\\n in_leases = yield r.table(\\\"leases\\\").filter(lambda l:\\n l['start_time'].gt(int(te))\\n ).map(lambda l:\\n l['resources'].coerce_to('array')\\n ).reduce(lambda left, right:\\n left.set_union(right)\\n ).map(lambda x:\\n r.table('resources').get(x) \\\\\\n ).run(self.dbconnection)\\n response = response + in_leases\\n else:\\n # All available Resources (No Leases in DB)\\n cursor = yield r.table('resources') \\\\\\n .filter({'available':'true'}) \\\\\\n .run(self.dbconnection)\\n while (yield cursor.fetch_next()):\\n item = yield cursor.next()\\n response.append(item)\\n except Exception as e:\\n logger.exception(e)\\n\\n # GET /resources/<id>\\n elif not o and id and self.isUrn(id):\\n\\n cursor = yield r.table('resources') \\\\\\n .filter({'id': id}) \\\\\\n .run(self.dbconnection)\\n while (yield cursor.fetch_next()):\\n item = yield cursor.next()\\n response.append(item)\\n # GET /resources/<id>/leases\\n elif id and self.isUrn(id) and o == 'leases':\\n cursor = yield r.table(o) \\\\\\n .filter(lambda lease: lease[\\\"resources\\\"].contains(id)) \\\\\\n .run(self.dbconnection)\\n #\\n\\n while (yield cursor.fetch_next()):\\n item = yield cursor.next()\\n response.append(item)\\n # GET /resources/<id>/slices\\n elif id and self.isUrn(id) and o == 'slices':\\n cursor = yield r.table(o) \\\\\\n .filter(lambda slice: slice[\\\"resources\\\"]==id) \\\\\\n .run(self.dbconnection)\\n #\\n\\n while (yield cursor.fetch_next()):\\n item = yield cursor.next()\\n response.append(item)\\n # GET /resources/<id>/testbeds\\n elif id and self.isUrn(id) and o == 'testbeds':\\n cursor = yield r.table('resources') .filter({'id': id}) \\\\\\n .pluck('id','testbed','manager') \\\\\\n .merge(lambda res: {\\n 'testbeds': r.table('testbeds').get_all(res['testbed'], index='id') \\\\\\n .coerce_to('array')\\n }) \\\\\\n .run(self.dbconnection)\\n while (yield cursor.fetch_next()):\\n item = yield cursor.next()\\n response.append(item)\\n else:\\n self.userError(\\\"invalid request\\\")\\n\\n return\\n\\n self.finish(json.dumps({\\\"result\\\": response}, cls=myJSONEncoder))\",\n \"def GetResourcesSample():\\n client = CreateClient()\\n # Get a feed and print it\\n feed = client.GetResources()\\n PrintFeed(feed)\",\n \"def test_get_api_resources(self):\\n pass\",\n \"def _get_resource(self, *args, **kwargs):\\r\\n r = []\\r\\n if kwargs['resource'] in self.resources:\\r\\n r = self.get_list(\\r\\n api_endpoint=settings.GITHUB_SETTINGS['GITHUB_USER_REPO_API'].format(**kwargs), **kwargs\\r\\n )\\r\\n else:\\r\\n ValueError(\\\"{resource} - Resource Not Supported\\\".format(**kwargs)) \\r\\n return r\",\n \"def get(self):\\n try:\\n query_parameters = request.args\\n logging.debug(f\\\" query params - {query_parameters}\\\")\\n top, skip, expand_code, selects = parse_args(query_parameters)\\n ds_list = Datastreams.return_page_with_expand(\\n top, skip, expand_code, selects\\n )\\n response = jsonify(ds_list)\\n response.status_code = 200\\n except Exception as e:\\n logging.warning(e)\\n response = jsonify({\\\"message\\\": \\\"error\\\"})\\n response.status_code = 400\\n\\n finally:\\n return response\",\n \"def get_all(self, context, filters=None):\\n try:\\n db_resources_data = self.db_api.get_all_resources(\\n context, **filters)\\n\\n _resources_data = []\\n for db_resource_data in db_resources_data:\\n _resources_data.append(_make_response(db_resource_data))\\n except Exception as e:\\n msg = (\\\"Error retrieving the 'resources' reason : %s\\\"\\n % e.message)\\n LOG.exception(msg)\\n raise exception.RetrieveException(e.message)\\n return _resources_data\",\n \"def get(self, request, *args, **kwargs):\\n return self.list(request, *args, **kwargs)\",\n \"def get(self, request, *args, **kwargs):\\n return self.list(request, *args, **kwargs)\",\n \"def get(self, request, *args, **kwargs):\\n return self.list(request, *args, **kwargs)\",\n \"def get(self, request, *args, **kwargs):\\n return self.list(request, *args, **kwargs)\",\n \"def get(self, request, *args, **kwargs):\\n return self.list(request, *args, **kwargs)\",\n \"def get(self, url_or_path):\\n return self.request.get(url_or_path).json()\",\n \"def get(self, data):\\n pass\",\n \"def test_get_resource(self):\\n for i in range(11):\\n self.app.post(f'/v1/resource/{ResourceTypeName.get()}', data=json.dumps({'actions': ['tr:action1']}),\\n headers=admin_headers)\\n self._test_paging('/v1/resources', admin_headers, 10, 'resources')\",\n \"def get(self, context, id_):\\n try:\\n db_resource_data = self.db_api.get_resource(\\n context, id_)\\n _resource_data = _make_response(db_resource_data,\\n meta_data=False)\\n\\n except exception.NotFound as e:\\n raise e\\n\\n except Exception as e:\\n msg = (\\\"Error retrieving the 'resource':%s. Reason: %s\\\"\\n % (id_, e.message))\\n LOG.exception(msg)\\n raise exception.RetrieveException(e.message)\\n\\n LOG.info(\\\"Resource manager data is %s \\\" %\\n logging.mask_password(_resource_data))\\n return _resource_data\",\n \"def get(self):\\n try:\\n query_parameters = request.args\\n logging.debug(f\\\" query params - {query_parameters}\\\")\\n if query_parameters:\\n thing = None\\n sensor = None\\n if \\\"thing\\\" in query_parameters:\\n thing = request.args[\\\"thing\\\"]\\n if \\\"sensor\\\" in query_parameters:\\n sensor = request.args[\\\"sensor\\\"]\\n logging.debug(f\\\"thing={thing},sensor={sensor}\\\")\\n datastreams = Datastreams.filter_by_thing_sensor(thing, sensor)\\n else:\\n result = {\\\"message\\\": \\\"no known query parameters\\\"}\\n response = jsonify(result)\\n response.status_code = 400\\n return response\\n\\n except Exception as e:\\n logging.warning(e)\\n result = {\\\"message\\\": \\\"error\\\"}\\n response = jsonify(result)\\n response.status_code = 400\\n return response\\n\\n if datastreams:\\n response = jsonify(datastreams)\\n response.status_code = 200\\n return response\\n else:\\n result = {\\\"message\\\": \\\"No datastreams found\\\"}\\n response = jsonify(result)\\n response.status_code = 200\\n return response\",\n \"def get_resources(self, resource_url):\\n response = self.response(resource_url)\\n body = response[0]\\n return ResourceParser.extract_resources(body)\",\n \"def get(owner, resource):\\n resource = logic.resource.find(owner, resource)\\n return jsonify(resource)\",\n \"def get(self):\\r\\n return http.Request('GET', self.get_url()), parsers.parse_json\",\n \"def get(self):\\r\\n return http.Request('GET', self.get_url()), parsers.parse_json\",\n \"async def get(self, filters: dict = None):\\n\\n res = self.__get_data(filters)\\n\\n return res\",\n \"def get(self, *path, **data):\\n\\t\\treturn self.request('GET', *path, **data)\",\n \"def handle_get():\\n for resource in resources:\\n\\n # acquire lock\\n res_lock = resource.get(\\\"lock\\\")\\n res_lock.acquire()\\n\\n # Get if available\\n if resource.get(\\\"available\\\") == \\\"true\\\":\\n # Available - acquire resource and return\\n resource.update({\\\"available\\\": \\\"false\\\"})\\n res_lock.release()\\n return jsonify(resource.get(\\\"data\\\"))\\n\\n # Not available, release and continue\\n res_lock.release()\\n\\n # All resources are taken\\n return app.make_response(('No available resource', 500))\",\n \"def getResourceData(self, authenticationToken, guid):\\r\\n pass\",\n \"def list(self):\\n url = self._resource_name\\n return self._get(url)\",\n \"def get_data(self, url):\\n return self.get(url).get('data', [])\",\n \"def get(self, *args):\\n return self.docs.get(*args)\",\n \"def ResourceList(self):\\n url = AddToUrl(self, 'https://api.spiget.org/v2/resources?')\\n return ApiSearch(url)\",\n \"def get():\\n\\n # \\\\todo List of available data, fetched and processed\\n\\n return jsonify({'valid_resources': ['balance', 'balance_usd', 'trade_history', 'balance_norm_price_history', 'open_orders']})\",\n \"def get(self, prefix, paths, data_type, use_models):\\n pass\",\n \"def _get(self, *args, **kwargs):\\n return self._request('get', *args, **kwargs)\",\n \"def get(self):\\n\\n try:\\n args = api_parameters.parse_args()\\n limit = args.get(\\\"limit\\\")\\n controller = self.controller()\\n schema = self.schema(many=True)\\n raw_data = controller.get_list(**args)\\n\\n if limit:\\n items = raw_data.items\\n items = schema.dump(items)\\n data = ResponseHandler.get_section_paginate(raw_data, items)\\n\\n else:\\n data = schema.dump(raw_data)\\n\\n return ResponseHandler.render_response(data=data)\\n\\n except Exception as ex:\\n\\n return ResponseHandler.render_response(status=ERR, message=traceback.format_exc())\",\n \"def resources(self):\",\n \"def _get(self, path):\\n r = requests.get(self._url(path))\\n assert r.status_code == 200\\n return r.json\",\n \"def get_resources(resource_client) -> list:\\n resource_list = []\\n paginator = resource_client.get_paginator(BOTO3_LIST_FUNCTION)\\n pages = paginator.paginate()\\n for page in pages:\\n # Your going to have to look through the response and append the correct value to the list\\n resource = page[\\\"something\\\"]\\n resource_list = resource_list + resource\\n return resource_list\",\n \"def get(self, *args, **kwargs):\\n return self._request('get', *args, **kwargs)\",\n \"def get(resource, lookup):\\n\\n documents = []\\n response = {}\\n etag = None\\n req = parse_request(resource)\\n embedded_fields = _resolve_embedded_fields(resource, req)\\n\\n # facilitate cached responses\\n if req.if_modified_since:\\n # client has made this request before, has it changed?\\n # this request does not account for deleted documents!!! (issue #243)\\n preflight_req = copy.copy(req)\\n preflight_req.max_results = 1\\n\\n cursor = app.data.find(resource, preflight_req, lookup)\\n if cursor.count() == 0:\\n # make sure the datasource is not empty (#243).\\n if not app.data.is_empty(resource):\\n # the if-modified-since conditional request returned no\\n # documents, we send back a 304 Not-Modified, which means that\\n # the client already has the up-to-date representation of the\\n # resultset.\\n status = 304\\n last_modified = None\\n return response, last_modified, etag, status\\n\\n # continue processing the full request\\n last_update = epoch()\\n req.if_modified_since = None\\n cursor = app.data.find(resource, req, lookup)\\n\\n for document in cursor:\\n _build_response_document(document, resource, embedded_fields)\\n documents.append(document)\\n\\n # build last update for entire response\\n if document[config.LAST_UPDATED] > last_update:\\n last_update = document[config.LAST_UPDATED]\\n\\n status = 200\\n last_modified = last_update if last_update > epoch() else None\\n\\n # notify registered callback functions. Please note that, should the\\n # functions modify the documents, the last_modified and etag won't be\\n # updated to reflect the changes (they always reflect the documents\\n # state on the database.)\\n\\n getattr(app, \\\"on_fetched_resource\\\")(resource, documents)\\n getattr(app, \\\"on_fetched_resource_%s\\\" % resource)(documents)\\n\\n if config.DOMAIN[resource]['hateoas']:\\n response[config.ITEMS] = documents\\n response[config.LINKS] = _pagination_links(resource, req,\\n cursor.count())\\n else:\\n response = documents\\n\\n # the 'extra' cursor field, if present, will be added to the response.\\n # Can be used by Eve extensions to add extra, custom data to any\\n # response.\\n if hasattr(cursor, 'extra'):\\n getattr(cursor, 'extra')(response)\\n\\n return response, last_modified, etag, status\",\n \"def get(self, request, resource=None, **kwargs):\\n if resource is not None and resource != '':\\n return self.to_simple(request, resource, **kwargs)\\n\\n return self.to_simple(request, self.collection, many=True, **kwargs)\",\n \"def get_resource(self, resource, method='get', data=None, headers=None, json=False, **kwargs): # nolint\\r\\n method = getattr(self.client, method)\\r\\n resource, headers, data = self.get_params(\\r\\n resource, headers, data, **kwargs)\\r\\n\\r\\n # Support JSON request\\r\\n if json:\\r\\n headers['content_type'] = 'application/json'\\r\\n data = simplejson.dumps(data)\\r\\n\\r\\n response = method(resource, data=data, **headers)\\r\\n return self._jsonify(response)\",\n \"def resource_bundle(resource_type, methods=[\\\"GET\\\"]):\\n token = validate_auth()\\n url = current_app.config.get('MAP_API') + resource_type\\n params = {'_count': 1000}\\n params.update(request.args)\\n resp = requests.get(url, auth=BearerAuth(token), params=params)\\n try:\\n resp.raise_for_status()\\n except requests.exceptions.HTTPError as err:\\n abort(err.response.status_code, err)\\n\\n return jsonify(resp.json())\",\n \"def get_data(self, request, url):\\n data = request.get(endpoint=url)\\n return data[0], data[1]\",\n \"def _fetch_resource(self):\\n\\n qs = self._build_qs() # Build the query string\\n url = self._build_url(qs) # Build the full url\\n fp = self._api_call(url) # Fetch the data as a file pointer\\n\\n # Parse the list of dicts in to a dict generator\\n return csv.DictReader(fp)\",\n \"def get_all(self):\\n result_get = GetRest(function = self.function).performRequest()\\n return result_get\",\n \"async def get_api_data(self, referer: str, params: list) -> list:\\n return await asyncio.ensure_future(self.get_response(referer, params))\",\n \"def get(self, endpoint, data=None):\\n if endpoint.startswith(\\\"http\\\"):\\n url = endpoint\\n elif endpoint.startswith(\\\"/\\\"):\\n url = \\\"{}{}\\\".format(api_endpoint, endpoint)\\n else:\\n url = \\\"{}/{}\\\".format(api_endpoint, endpoint)\\n\\n response = requests.get(\\n url,\\n data=data,\\n headers= {\\n \\\"Content-Type\\\": \\\"application/json\\\",\\n \\\"Accept\\\": \\\"application/json\\\",\\n \\\"Authorization\\\": \\\"Bearer \\\" + self.token,\\n }\\n )\\n\\n if response.status_code == 200:\\n return response.json()\\n elif response.status_code == 404:\\n print(\\\"404: Probably invalid endpoint\\\")\\n else:\\n print(\\\"ERROR IN REQUEST: {}\\\".format(response.content))\\n return response\",\n \"def get(self, id):\\n try:\\n query_parameters = request.args\\n logging.debug(f\\\" query params - {query_parameters}\\\")\\n top, skip, expand_code, selects = parse_args(query_parameters)\\n\\n ds_list = Datastreams.filter_by_thing_id(\\n id, top, skip, expand_code, selects\\n )\\n response = jsonify(ds_list)\\n response.status_code = 200\\n except Exception as e:\\n logging.warning(e)\\n response = jsonify({\\\"message\\\": \\\"error\\\"})\\n response.status_code = 400\\n return response\\n\\n finally:\\n return response\",\n \"def list(self):\\n return self.request(\\\"GET\\\")\",\n \"def get_api_resources(self, **kwargs):\\n\\n all_params = []\\n all_params.append('callback')\\n\\n params = locals()\\n for key, val in iteritems(params['kwargs']):\\n if key not in all_params:\\n raise TypeError(\\n \\\"Got an unexpected keyword argument '%s'\\\"\\n \\\" to method get_api_resources\\\" % key\\n )\\n params[key] = val\\n del params['kwargs']\\n\\n\\n resource_path = '/oapi/v1'.replace('{format}', 'json')\\n path_params = {}\\n\\n query_params = {}\\n\\n header_params = {}\\n\\n form_params = []\\n local_var_files = {}\\n\\n body_params = None\\n\\n # HTTP header `Accept`\\n header_params['Accept'] = self.api_client.\\\\\\n select_header_accept(['application/json', 'application/yaml'])\\n if not header_params['Accept']:\\n del header_params['Accept']\\n\\n # HTTP header `Content-Type`\\n header_params['Content-Type'] = self.api_client.\\\\\\n select_header_content_type(['application/json', 'application/yaml'])\\n\\n # Authentication setting\\n auth_settings = []\\n\\n response = self.api_client.call_api(resource_path, 'GET',\\n path_params,\\n query_params,\\n header_params,\\n body=body_params,\\n post_params=form_params,\\n files=local_var_files,\\n response_type=None,\\n auth_settings=auth_settings,\\n callback=params.get('callback'))\\n return response\",\n \"def get(self, *args, **kwargs):\\n return self._hit(\\\"GET\\\", *args, **kwargs)\",\n \"def get(self, *args, **kwargs) -> Any:\\n return self.raw_data.get(*args, **kwargs)\",\n \"def get(self, *args, **kwargs):\",\n \"def get(self, request, **resources):\\r\\n\\r\\n instance = resources.get(self._meta.name)\\r\\n if not instance is None:\\r\\n return instance\\r\\n\\r\\n return self.paginate(\\r\\n request, self.get_collection(request, **resources))\",\n \"def get_rest_data_source(uri):\\n def players_from_rest():\\n response = requests.get(uri)\\n response.raise_for_status()\\n return parse_players_json(response.text)\\n return players_from_rest\",\n \"async def get(self, path, params=None, json_data=None):\\n response = await self.request('GET', path, params, json_data)\\n return response\",\n \"def request_endpoints(self):\\n\\n endpoints_url = self.std[\\\"api\\\"]\\n endpoints_paramd = {\\n \\\"access_token\\\": self.std[\\\"access_token\\\"]\\n }\\n\\n endpoints_response = requests.get(url=endpoints_url, params=endpoints_paramd)\\n print endpoints_response\\n self.endpointd = endpoints_response.json()[0]\",\n \"def getResource(self, authenticationToken, guid, withData, withRecognition, withAttributes, withAlternateData):\\r\\n pass\",\n \"def get(self, start=None, limit=None):\\r\\n params = base.get_params(None, locals())\\r\\n return http.Request('GET', self.get_url(), params), parsers.parse_json\",\n \"def get_data_by_uuid(request, uuid, hours):\\n\\tif request.method == 'GET':\\n\\t\\treadings = get_data_by_uuid_helper(uuid, hours)\\n\\t\\treturn Response(readings)\",\n \"def GetAllResourcesSample():\\n client = CreateClient()\\n # Unlike client.GetResources, this returns a list of resources\\n for resource in client.GetAllResources():\\n PrintResource(resource)\",\n \"async def get(self, **context):\\n return {}\",\n \"def get(self, *args, **kwargs):\\n url = urljoin(self.instance(), args[0])\\n return self._requests_call(util.requests_get, url, *args[1:], **kwargs)\",\n \"def index():\\n return make_json_response(ENDPOINT_LIST)\",\n \"def get(self):\\r\\n request = http.Request('GET', self.get_url())\\r\\n\\r\\n return request, parsers.parse_json\",\n \"def get(self):\\r\\n request = http.Request('GET', self.get_url())\\r\\n\\r\\n return request, parsers.parse_json\",\n \"def get(self):\\r\\n request = http.Request('GET', self.get_url())\\r\\n\\r\\n return request, parsers.parse_json\",\n \"def get(self):\\r\\n request = http.Request('GET', self.get_url())\\r\\n\\r\\n return request, parsers.parse_json\",\n \"def get(self):\\r\\n return get_all()\",\n \"def _get_all_data(self, resource):\\n response = self._get_raising('{}{}?per_page=100&page=1'.format(\\n self.GH_API_ENDPOINT, resource\\n ))\\n yield from response.json()\\n while 'next' in response.links:\\n response = self._get_raising(response.links['next']['url'])\\n yield from response.json()\",\n \"def getResourceDef(url, user, pWd, resourceName):\\n \\n print(\\\"getting resource for catalog:-\\\" + url + \\\" resource=\\\" + resourceName +\\n ' user=' + user)\\n apiURL = url + '/access/1/catalog/resources/' + resourceName\\n # print(\\\"\\\\turl=\\\" + apiURL)\\n header = {\\\"Accept\\\": \\\"application/json\\\"} \\n tResp = requests.get(apiURL, params={}, headers=header, auth=HTTPBasicAuth(user,pWd))\\n print(\\\"\\\\tresponse=\\\" + str(tResp.status_code))\\n if tResp.status_code == 200:\\n # valid - return the jsom\\n return tResp.status_code, json.loads(tResp.text)\\n else:\\n # not valid\\n return tResp.status_code, None\",\n \"def _get(self):\\n return self.request(method=\\\"get\\\", path=self.router.fields)\",\n \"def get(self, *args, **kwargs):\\n pass\",\n \"def get(self, *args, **kwargs):\\n pass\",\n \"def process_resource_listing_api(self, resources, listing_api, context):\\n pass\",\n \"def get(cls, client, name=\\\"\\\", option_=\\\"\\\") :\\n\\t\\ttry :\\n\\t\\t\\tif not name :\\n\\t\\t\\t\\tobj = l3param()\\n\\t\\t\\t\\tresponse = obj.get_resources(client, option_)\\n\\t\\t\\treturn response\\n\\t\\texcept Exception as e :\\n\\t\\t\\traise e\",\n \"def get(self, embed=None, fields=None):\\r\\n params = base.get_params(None, locals())\\r\\n\\r\\n return http.Request('GET', self.get_url(), params), parsers.parse_json\",\n \"def get(self, format=None, page=None, per_page=None):\\r\\n url = self.get_url()\\r\\n params = base.get_params(('page', 'per_page'), locals())\\r\\n headers = resource.mimetype_accept(format)\\r\\n\\r\\n return http.Request('GET', url, params, headers), parsers.parse_json\",\n \"def get(self, Muted=None, Page=None, PageSize=None, AfterSid=None):\\r\\n params = resource.get_params(None, locals())\\r\\n request = http.Request('GET', self.get_url(), params)\\r\\n\\r\\n return request, parsers.parse_json\",\n \"def get(self, *args):\",\n \"def get(self, api_path, *args, **kwargs):\\n\\n\\t\\treturn self._do_operation(u'get', api_path, *args, **kwargs)\",\n \"def get_all_data():\\n return jsonify(service.get_all_data())\",\n \"def get(self, path: str) -> Response:\\n endpoint_ = checkEndpoint(\\\"GET\\\", path)\\n if not endpoint_[\\\"method\\\"]:\\n # If endpoint and Get method not supported in the API\\n abort(endpoint_[\\\"status\\\"])\\n return item_collection_get_response(path)\",\n \"def _get(self, path, params=None):\\n return self._api.get_json(path, headers={\\\"Hawkular-Tenant\\\": self.tenant_id}, params=params)\",\n \"def resources(self, query):\\n return _MockResponse()\",\n \"def resource_by_id(resource_type, resource_id, methods=[\\\"GET\\\"]):\\n token = validate_auth()\\n url = f\\\"{current_app.config.get('MAP_API')}{resource_type}/{resource_id}\\\"\\n resp = requests.get(url, auth=BearerAuth(token))\\n try:\\n resp.raise_for_status()\\n except requests.exceptions.HTTPError as err:\\n abort(err.response.status_code, err)\\n\\n return jsonify(resp.json())\",\n \"def get_data(self):\",\n \"def get(self, *args, **kwargs):\\n self.request(\\\"get\\\", *args, **kwargs)\",\n \"def getAll(self):\\n result_get = GetRest(function = self.function).performRequest()\\n return result_get\",\n \"def get_resources(genome_build, fasta_ref, data):\\n config = tz.get_in([\\\"config\\\", CONFIG_KEY], data)\\n find_fn = _find_file(config)\\n def normalize(f):\\n return _get_id_fname(f)[-1]\\n return sret.get_resources(genome_build, fasta_ref, config,\\n data, _open_remote, _list(config), find_fn, normalize)\",\n \"def get(log, session, args):\\n url = \\\"{}datasets/{}\\\".format(\\n http.get_api_url(args.url, args.project),\\n args.id)\\n log.debug('GET: {}'.format(url))\\n response_json = http.get(session, url)\\n log.print_json(response_json, \\\"dataset\\\", \\\"get\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7040653","0.7014533","0.6972194","0.6868909","0.6711269","0.67088366","0.6694223","0.6652421","0.65987545","0.6597155","0.6576477","0.6572885","0.65307814","0.6527663","0.6498717","0.6484466","0.64421904","0.64192057","0.63806015","0.63806015","0.63806015","0.63806015","0.63806015","0.63404465","0.634041","0.63244736","0.63162327","0.6315349","0.63125116","0.63095367","0.62898207","0.62898207","0.6270105","0.6263308","0.6260993","0.6241089","0.6229589","0.62243724","0.62228745","0.62014276","0.6190981","0.6175432","0.6169815","0.6157241","0.61440367","0.61310714","0.6126089","0.6111376","0.6110776","0.60908294","0.60900164","0.6089801","0.60857785","0.60846335","0.6081765","0.6078532","0.6076053","0.6060969","0.6055173","0.6053119","0.60488534","0.6045393","0.6034385","0.6031441","0.60314035","0.6027085","0.60203844","0.60096425","0.60088027","0.6005958","0.6000206","0.5995594","0.5993712","0.59908074","0.59869915","0.59869915","0.59869915","0.59869915","0.5983409","0.5978004","0.59772706","0.59753376","0.5975232","0.5975232","0.5970855","0.59611374","0.5961012","0.5948385","0.5946955","0.5942093","0.5935907","0.59342885","0.5932361","0.5929217","0.59288013","0.5919266","0.591631","0.5916145","0.5914592","0.59103477","0.5907958"],"string":"[\n \"0.7040653\",\n \"0.7014533\",\n \"0.6972194\",\n \"0.6868909\",\n \"0.6711269\",\n \"0.67088366\",\n \"0.6694223\",\n \"0.6652421\",\n \"0.65987545\",\n \"0.6597155\",\n \"0.6576477\",\n \"0.6572885\",\n \"0.65307814\",\n \"0.6527663\",\n \"0.6498717\",\n \"0.6484466\",\n \"0.64421904\",\n \"0.64192057\",\n \"0.63806015\",\n \"0.63806015\",\n \"0.63806015\",\n \"0.63806015\",\n \"0.63806015\",\n \"0.63404465\",\n \"0.634041\",\n \"0.63244736\",\n \"0.63162327\",\n \"0.6315349\",\n \"0.63125116\",\n \"0.63095367\",\n \"0.62898207\",\n \"0.62898207\",\n \"0.6270105\",\n \"0.6263308\",\n \"0.6260993\",\n \"0.6241089\",\n \"0.6229589\",\n \"0.62243724\",\n \"0.62228745\",\n \"0.62014276\",\n \"0.6190981\",\n \"0.6175432\",\n \"0.6169815\",\n \"0.6157241\",\n \"0.61440367\",\n \"0.61310714\",\n \"0.6126089\",\n \"0.6111376\",\n \"0.6110776\",\n \"0.60908294\",\n \"0.60900164\",\n \"0.6089801\",\n \"0.60857785\",\n \"0.60846335\",\n \"0.6081765\",\n \"0.6078532\",\n \"0.6076053\",\n \"0.6060969\",\n \"0.6055173\",\n \"0.6053119\",\n \"0.60488534\",\n \"0.6045393\",\n \"0.6034385\",\n \"0.6031441\",\n \"0.60314035\",\n \"0.6027085\",\n \"0.60203844\",\n \"0.60096425\",\n \"0.60088027\",\n \"0.6005958\",\n \"0.6000206\",\n \"0.5995594\",\n \"0.5993712\",\n \"0.59908074\",\n \"0.59869915\",\n \"0.59869915\",\n \"0.59869915\",\n \"0.59869915\",\n \"0.5983409\",\n \"0.5978004\",\n \"0.59772706\",\n \"0.59753376\",\n \"0.5975232\",\n \"0.5975232\",\n \"0.5970855\",\n \"0.59611374\",\n \"0.5961012\",\n \"0.5948385\",\n \"0.5946955\",\n \"0.5942093\",\n \"0.5935907\",\n \"0.59342885\",\n \"0.5932361\",\n \"0.5929217\",\n \"0.59288013\",\n \"0.5919266\",\n \"0.591631\",\n \"0.5916145\",\n \"0.5914592\",\n \"0.59103477\",\n \"0.5907958\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":7294,"cells":{"query":{"kind":"string","value":"get data from projected bill endpoint"},"document":{"kind":"string","value":"async def __getFromProjectedBill(self, account, premise, currentBillDate) -> dict:\n data = {}\n\n try:\n async with async_timeout.timeout(TIMEOUT):\n response = await self.session.get(\n URL_RESOURCES_PROJECTED_BILL.format(\n account=account,\n premise=premise,\n lastBillDate=currentBillDate.strftime(\"%m%d%Y\"),\n )\n )\n\n if response.status == 200:\n projectedBillData = (await response.json())[\"data\"]\n\n billToDate = float(projectedBillData[\"billToDate\"])\n projectedBill = float(projectedBillData[\"projectedBill\"])\n dailyAvg = float(projectedBillData[\"dailyAvg\"])\n avgHighTemp = int(projectedBillData[\"avgHighTemp\"])\n\n data[\"bill_to_date\"] = billToDate\n data[\"projected_bill\"] = projectedBill\n data[\"daily_avg\"] = dailyAvg\n data[\"avg_high_temp\"] = avgHighTemp\n\n except Exception as e:\n _LOGGER.error(e)\n\n return data"},"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":["async def __getBBL_async(self, account, projectedBillData) -> dict:\n _LOGGER.info(\"Getting budget billing data\")\n data = {}\n\n try:\n async with async_timeout.timeout(TIMEOUT):\n response = await self.session.get(\n URL_BUDGET_BILLING_PREMISE_DETAILS.format(account=account)\n )\n if response.status == 200:\n r = (await response.json())[\"data\"]\n dataList = r[\"graphData\"]\n\n # startIndex = len(dataList) - 1\n\n billingCharge = 0\n budgetBillDeferBalance = r[\"defAmt\"]\n\n projectedBill = projectedBillData[\"projected_bill\"]\n asOfDays = projectedBillData[\"as_of_days\"]\n\n for det in dataList:\n billingCharge += det[\"actuallBillAmt\"]\n\n calc1 = (projectedBill + billingCharge) / 12\n calc2 = (1 / 12) * (budgetBillDeferBalance)\n\n projectedBudgetBill = round(calc1 + calc2, 2)\n bbDailyAvg = round(projectedBudgetBill / 30, 2)\n bbAsOfDateAmt = round(projectedBudgetBill / 30 * asOfDays, 2)\n\n data[\"budget_billing_daily_avg\"] = bbDailyAvg\n data[\"budget_billing_bill_to_date\"] = bbAsOfDateAmt\n\n data[\"budget_billing_projected_bill\"] = float(projectedBudgetBill)\n\n async with async_timeout.timeout(TIMEOUT):\n response = await self.session.get(\n URL_BUDGET_BILLING_GRAPH.format(account=account)\n )\n if response.status == 200:\n r = (await response.json())[\"data\"]\n data[\"bill_to_date\"] = float(r[\"eleAmt\"])\n data[\"defered_amount\"] = float(r[\"defAmt\"])\n except Exception as e:\n _LOGGER.error(e)\n\n return data","def get_data(self):","def get_data():\n pass","def get_data():\n return","def fetch_data(self):","def get_bill_details(request):\n\n print request\n\n context = request['context']\n print context\n try:\n telephone_number = first_entity_value(request['entities'], 'phone_number')\n with open(os.path.join(sys.path[0], \"app/wit/static/users.json\"), \"r\") as data_file:\n data = json.load(data_file)\n customer_billing = data[telephone_number]['last_month_billing']\n print customer_billing\n\n customer_type = data[telephone_number]['type_customer']\n if customer_type == 'postpaid':\n\n reply = \"Our Initial Investigation shows that you're a \" + data[telephone_number]['type_customer'] + \" Customer and currently using \" + data[telephone_number]['plan_details'] + \" plan type.\"\n if customer_billing['roaming'] == 'True':\n reply += \"You had used your cellphone while on roaming for which you were charged extra.\"\n elif customer_billing['data_exhaust'] == 'True':\n reply += \"You had used your data network after your allocated limit was exhausted. You were charged for these services\"\n elif customer_billing['subscribed'] == 'True':\n reply += \"You had subscribed to some promotional services for which you were charged in extra.\"\n else:\n reply = \"Our Initial Investigation shows that you're a \" + data[telephone_number]['type_customer'] + \". We believe that this might be a mistake from our side and would like you to speak to our customer care executives separately.\"\n\n\n except:\n telephone_number = None\n reply = \"Your number is not subscribed with Airtel. Please contact your network operator for your query\"\n\n\n print reply\n\n context['bill_details'] = reply\n\n return context","def get_data(endpoint_name, arg=None,\n project_name=None, fields=None, size=get_setting_value('DEFAULT_SIZE'), page=0,\n data_category=None, query_args={}, verify=False, *args, **kwargs):\n endpoint = get_setting_value('GDC_API_ENDPOINT').format(endpoint=endpoint_name)\n if arg:\n endpoint = endpoint+'/{}'.format(arg)\n else:\n ## prep extra-params, including `from` param, as dict\n extra_params = {}\n if page>0:\n from_param = helpers.compute_start_given_page(page=page, size=size)\n extra_params.update({\n 'from': from_param,\n })\n if fields:\n extra_params.update({'fields': ','.join(helpers.convert_to_list(fields))})\n if dict(**kwargs):\n ## TODO check on whether this handles redundant param spec \n ## correctly\n extra_params.update(dict(**kwargs))\n params = _params.construct_parameters(project_name=project_name,\n size=size,\n data_category=data_category,\n query_args=query_args,\n verify=verify,\n **extra_params\n )\n # requests URL-encodes automatically\n log.info('submitting request for {endpoint} with params {params}'.format(endpoint=endpoint, params=params))\n response = requests_get(endpoint, params=params)\n log.info('url requested was: {}'.format(response.url))\n response.raise_for_status()\n return response","def get(self, args):\n return Payment.query.offset(args['offset']).limit(args['limit'])","def get_data():\n pass","def get_data():\n pass","def get_data():\n pass","def get_data(self):\n pass","def get_data(self):\n pass","def get():\n\n # \\todo List of available data, fetched and processed\n\n return jsonify({'valid_resources': ['balance', 'balance_usd', 'trade_history', 'balance_norm_price_history', 'open_orders']})","def get_data(self, exportformat: str, oidrange: list):\r\n querystr = f\"?where=objectid+>%3D+{oidrange[0]}+AND+objectid+<%3D+{oidrange[1]}&text=&objectIds=&time=&geometry=&geometryType=esriGeometryEnvelope&inSR=&spatialRel=esriSpatialRelIntersects&relationParam=&outFields=*&returnGeometry=true&returnTrueCurves=false&maxAllowableOffset=&geometryPrecision=&outSR=&returnIdsOnly=false&returnCountOnly=false&orderByFields=&groupByFieldsForStatistics=&outStatistics=&returnZ=false&returnM=false&gdbVersion=&returnDistinctValues=false&resultOffset=&resultRecordCount=&queryByDistance=&returnExtentsOnly=false&datumTransformation=¶meterValues=&rangeValues=&f={exportformat}\"\r\n req = requests.get(self.endpointurl + querystr)\r\n return req.json()","def get_data(self):\r\n pass","def plan_get(request):\n company = auth_api_key(request)\n plan = get_and_check_plan(request, company)\n return plan","def _get_data(self):\n raise NotImplementedError()","def get(self):\n # req = requests.get(\"\")\n # data = req.json()\n # print(data)\n query = Event.query.all()\n event_first_bill_pay(data=query, event_type=\"bill payment\")\n threading.Thread(target=event_notify_user, args=(\"Notify User\", query,)).start()\n threading.Thread(target=event_post_feedback, args=(\"Post Feeback\",)).start()\n return query","def get(self, http, req_dict):\n\n\t\t# Turn account numbers into integers and remove duplicates\n\t\taccount_numbers = self.get_account_numbers( req_dict['account_numbers[]'] )\n\n\t\t# A primary did is a Physical line, with OFN disabled (e.g. not a softphone),\n\t\t# which is connected to a primary rate plan\n\n\t\tprimary_did_sql = \"\"\"\n\t\t\tselect distinct did.account_number,\n\t\t\t did.phone_number\n\t\t\t from did_numbers did\n\n\t\t\t join DID_BILLING_ITEM dbi\n\t\t\t on dbi.DID_NUMBER_ID = did.DID_NUMBER_ID\n\t\t\t and dbi.ACCOUNT_NUMBER = did.ACCOUNT_NUMBER\n\t\t\t and dbi.STATUS = 'A'\n\n\t\t\t join AP_REPORT.ITEM_MASTER_LU im\n\t\t\t on im.ITEM_CODE = dbi.SERVICE_ITEM_CODE\n\t\t\t and im.ITEM_TYPE = 'RATE_PLAN'\n\t\t\t and im.USE_CLASS = 'PRIMARY'\n\n\t\t\t where (did.date_end is null or did.date_end > SYSDATE + 90)\n\t\t\t and did.did_type_id = 'PHY'\n\t\t\t and did.ofn_enabled = 'N'\n\t\t\t and did.account_number in %s\n\t\t\t\"\"\" % self.account_sql_list\n\n\t\taccount_sql = \"\"\"\n\t\t\tselect\n\t\t\ta.ACCOUNT_NAME,\n\t\t\ta.STATUS,\n\t\t\tto_char(a.DATE_CREATED, 'yyyy-mm-dd hh24:mi:ss'),\n\t\t\ta.ACCOUNT_NUMBER,\n\t\t\tlower(au.USER_NAME),\n\t\t\tau.EMAIL_ADDRESS,\n\t\t\ta.PARTNER_ID,\n\t\t\tast.ACCOUNT_STATUS_TYPE,\n\t\t\tto_char(a.DATE_START, 'yyyy-mm-dd hh24:mi:ss'),\n\t\t\tto_char(a.DATE_END, 'yyyy-mm-dd hh24:mi:ss'),\n\t\t\tto_char(a.BILL_CYCLE_DATE_START, 'yyyy-mm-dd hh24:mi:ss'),\n\t\t\tto_char(a.BILL_CYCLE_DATE_END, 'yyyy-mm-dd hh24:mi:ss'),\n\t\t\tau.FIRST_NAME,\n\t\t\tau.LAST_NAME,\n\t\t\tat.ACCOUNT_TYPE,\n\t\t\tau.CONTACT_TELEPHONE,\n\t\t\ttz.TIMEZONE_ID,\n\t\t\ttz.TIMEZONE_NAME\n\t\t\tfrom\n\t\t\tACCOUNT a,\n\t\t\tACCOUNT_STATUS_TYPE ast,\n\t\t\tACCOUNT_TYPE at,\n\t\t\tACCOUNT_USER au,\n\t\t\tTIMEZONE tz\n\t\t\twhere a.ACCOUNT_NUMBER in %s\n\t\t\tand au.ACCESS_LEVEL = 'acctadmin'\n\t\t\tand ast.ACCOUNT_STATUS_TYPE_ID = a.STATUS\n\t\t\tand a.ACCOUNT_TYPE_ID = at.ACCOUNT_TYPE_ID\n\t\t\tand a.ACCOUNT_NUMBER = au.ACCOUNT_NUMBER\n\t\t\tand a.TIMEZONE_NUM = tz.TIMEZONE_NUM\n\t\t\torder by a.ACCOUNT_NUMBER\n\t\t\t\"\"\" % self.account_sql_list\n\n\t\tstatus_dates_sql = \"\"\"\n\t\t\tselect\n\t\t\tACCOUNT_NUMBER,\n\t\t\tto_char(COMPLETED_DATE, 'yyyy-mm-dd hh24:mi:ss'),\n\t\t\tACCOUNT_STATUS_TYPE_ID\n\t\t\tfrom account_status\n\t\t\tWHERE CURRENT_FLAG = 'Y'\n\t\t\tAND ACCOUNT_NUMBER in %s\n\t\t\t\"\"\" % self.account_sql_list\n\n\t\tlower_limit = 0\n\n\t\tret_obj = AccountResults()\n\n\t\twhile lower_limit < len(account_numbers):\n\t\t\t# Take self.account_sql_list_size (e.g. 10) account numbers at a time.\n\n\t\t\tparams = {}\n\t\t\tfor idx in xrange(0, self.account_sql_list_size):\n\t\t\t\tkey = \"account_number\" + str(idx + 1)\n\t\t\t\tif (lower_limit + idx) >= len(account_numbers):\n\t\t\t\t\tparams[key] = None\n\t\t\t\telse:\n\t\t\t\t\tparams[key] = account_numbers[lower_limit + idx]\n\n\t\t\tlower_limit += self.account_sql_list_size\n\n\t\t\t# Find the primary dids for these account numbers seperately,\n\t\t\t# because the query is crazy.\n\n\t\t\tauth_file = 'ps_oracle_sqlr'\n\n\t\t\tcurs = self.execute_query(auth_file, primary_did_sql, params)\n\t\t\trows = curs.fetchall()\n\t\t\tcurs.close()\n\n\t\t\tprimary_dids = self.get_primary_dids(rows)\n\n\t\t\t# Find Status Updated Dates and Account Status\n\n\t\t\tcurs = self.execute_query(auth_file, status_dates_sql, params)\n\t\t\trows = curs.fetchall()\n\t\t\tcurs.close()\n\n\t\t\tstatus_dates = self.get_status_dates(rows)\n\n\t\t\taccount_status = self.get_status(rows)\n\n\t\t\t# Find the rest of the data.\n\n\t\t\tcurs = self.execute_query(auth_file, account_sql, params)\n\t\t\trows = curs.fetchall()\n\t\t\tcurs.close()\n\n\t\t\tif curs.rowcount < 1:\n\t\t\t\traise RestDatabaseNotFound(\"None of the accounts were found.\")\n\n\t\t\tfor row in rows:\n\t\t\t\taccount = Account()\n\t\t\t\taccount.account_name = row[0]\n\t\t\t\taccount.status_code = row[1]\n\t\t\t\taccount.date_created = row[2]\n\t\t\t\tif account.date_created is not None:\n\t\t\t\t\taccount.date_created = account.date_created + ' +0000'\n\t\t\t\taccount.account_number = row[3]\n\t\t\t\t# Get the Account Status from the Account_Status Table from VDV.\n\t\t\t\tif account_status.has_key(account.account_number):\n\t\t\t\t\taccount.status_code = account_status.get(account.account_number)\n\t\t\t\telse:\n\t\t\t\t\taccount.status_code = row[1]\n\t\t\t\t\t# Log the account number as not having an active status in the account_status table\n\t\t\t\t\tself.log.debug(\"Account does not have an Active Status in the accout_status table. Account Number:\"+ account.account_number)\n\t\t\t\taccount.username = row[4]\n\t\t\t\taccount.email = row[5]\n\t\t\t\taccount.partner = row[6]\n\t\t\t\taccount.status = row[7]\n\t\t\t\taccount.account_start_date = row[8]\n\t\t\t\tif account.account_start_date is not None:\n\t\t\t\t\taccount.account_start_date = account.account_start_date + ' +0000'\n\t\t\t\taccount.account_end_date = row[9]\n\t\t\t\tif account.account_end_date is not None:\n\t\t\t\t\taccount.account_end_date = account.account_end_date + ' +0000'\n\t\t\t\taccount.bill_cycle_start_date = row[10]\n\t\t\t\tif account.bill_cycle_start_date is not None:\n\t\t\t\t\taccount.bill_cycle_start_date = account.bill_cycle_start_date + ' +0000'\n\t\t\t\taccount.bill_cycle_end_date = row[11]\n\t\t\t\tif account.bill_cycle_end_date is not None:\n\t\t\t\t\taccount.bill_cycle_end_date = account.bill_cycle_end_date + ' +0000'\n\t\t\t\taccount.first_name = row[12]\n\t\t\t\taccount.last_name = row[13]\n\t\t\t\taccount.account_type = row[14]\n\t\t\t\taccount.contact_telephone = row[15]\n\t\t\t\taccount.time_zone = row[16]\n\t\t\t\taccount.time_zone_name = row[17]\n\t\t\t\taccount.primary_did_numbers.did = primary_dids.get(account.account_number, [])\n\t\t\t\taccount.status_updated_date = status_dates.get(account.account_number)\n\n\t\t\t\tself.db_free()\n\n\t\t\t\tret_obj.account_info.append(account)\n\n\t\treturn ret_obj.dumps(SERVICE_ATTRIBUTES)","def getStockData():\n pass","def fetchGeoData():\n if request.method ==\"POST\":\n result = {}\n if request.get_json():\n post_requests = request.get_json()\n print(post_requests)\n result = db.getmapdata(post_requests['attr']) \n return result","def local_bonds_prices():\n url1 = \"https://api.invertironline.com/token\"\n\n data = {\n \"username\": usuario,\n \"password\": password,\n \"grant_type\": \"password\" \n }\n response = requests.post(url1, data=data)\n if response.status_code == 200:\n content = response.text\n access_key = token_key(content)\n\n url2 = f'https://api.invertironline.com/api/v2/Cotizaciones/Bonos/Merval/argentina'\n datos = requests.get(url2, headers={\n 'Authorization': 'Bearer '+access_key\n })\n datos = json.loads(datos.text)\n datos = datos['titulos']\n datos = clean_assets(datos)\n return datos","def get_data( obj, prm, lev, date, timelevel=0 ):\n \n parameter = obj( name = prm, level = lev, dataDate = date )[ timelevel ]\n print( parameter.dataDate )\n \n #-----Checking grit type----------------------------------------------\n if parameter.gridType == \"sh\":\n lat, lon, data = sh( parameter.values )\n elif parameter.gridType == \"reduced_gg\":\n lat, lon = parameter.latlons() #very easy implementastion with a gg\n lon = lon - 180. #else it only draws on half the map\n data = parameter.values\n elif parameter.gridType == \"regular_gg\":\n lat, lon = parameter.latlons() #very easy implementastion with a gg\n lon = lon - 180. #else it only draws on half the map\n data = parameter.values\n else: \n print ( parameter.gridType )\n \n return lat, lon, data","def plan_list_get(request):\n return list_by_company_guid(request, PlanModel)","def get(self):\n return {'bills': [bill.json() for bill in BillModel.find_all()]}","def _fetch_data(self):\n pass","def _get_dapall_from_api(self):\n\n url = marvin.config.urlmap['api']['dapall']['url']\n\n url_full = url.format(name=self.plateifu,\n bintype=self.bintype.name,\n template=self.template.name)\n\n try:\n response = self._toolInteraction(url_full)\n except Exception as ee:\n raise MarvinError('found a problem while getting DAPall: {0}'.format(str(ee)))\n\n if response.results['error'] is not None:\n raise MarvinError('found a problem while getting DAPall: {}'\n .format(str(response.results['error'])))\n\n data = response.getData()\n\n return data['dapall_data']","def get(self, request):\n if 'brokerage' in request.GET:\n portfolios = Portfolio.objects.filter(bdc_user=self.request.user, brokerage=request.GET['brokerage'])\n else:\n portfolios = Portfolio.objects.filter(bdc_user=self.request.user)\n orders = Order.objects.filter(portfolio__in=portfolios).order_by('-date')\n return Response(OrderSerializer(orders, many=True).data)","def handle(self):\n self.validate()\n if self.errors:\n raise InvalidDataException(self.errors)\n\n phone_number = self.data.get('phone_number')\n month = self.data.get('month')\n year = self.data.get('year')\n\n # if a period was not informed, get the current last one\n if not month and not year:\n year, month = last_period()\n\n bill_data = Bill.data_by_number_period(phone_number, month, year)\n return bill_data","def get_data_from_endpoint(self, from_, to_, endpoint):\n endpoint = self.make_endpoint(endpoint)\n from_, to_ = str(from_), str(to_)\n payload = {\n 'auth': self.auth_token,\n 'id': self.monitor_id,\n 'start': from_,\n 'end': to_,\n 'extendLimit': 'true',\n 'fullContents': 'true'\n }\n\n r = self.session.get(endpoint, params=payload)\n ratelimit_remaining = r.headers['X-RateLimit-Remaining']\n #print ('Remaining Ratelimit = ' + str(ratelimit_remaining))\n\n # If the header is empty or 0 then wait for a ratelimit refresh.\n if (not ratelimit_remaining) or (float(ratelimit_remaining) < 1):\n #print('Waiting for ratelimit refresh...')\n sleep(self.ratelimit_refresh)\n\n return r","def get_data(self, state=None, request=None):\n raise NotImplementedError","def fetch(self, grid):\n with self.session as s:\n # Recursively handle either a grid or a single bound\n if type(grid[0]) is list:\n with click.progressbar(grid, label='Fetching journal') as g:\n for bound in g:\n self.fetch(bound)\n elif type(grid[0]) is tuple:\n # Construct the web request from the coordinates\n poly = ''.join(['{};{};'.format(point[0], point[1]) for point in grid])\n payload = {\n 'qt': 'spatial',\n 'pts': poly,\n 'rad': 0,\n 'rights': 'B'\n }\n url = 'https://alta.registries.gov.ab.ca/SpinII/SearchTitlePrint.aspx'\n\n sleep(3)\n r = s.get(url, params=payload)\n soup = BeautifulSoup(r.content, 'html.parser')\n\n # Extract the table and load into a DataFrame\n try:\n table = soup.find('table', class_='bodyText')\n df = pd.read_html(str(table), index_col=0, header=0, parse_dates=False)[0]\n df['Registration Date'] = pd.to_datetime(df['Registration Date'], format='%d/%m/%Y')\n df['Change/Cancel Date'] = pd.to_datetime(df['Change/Cancel Date'], format='%d/%m/%Y')\n\n self.data.append(df)\n except:\n pass","def getDataContaining(self, address: ghidra.program.model.address.Address) -> ghidra.program.model.listing.Data:\n ...","def get(self):\n args = parser_hms.parse_args()\n if args['amount'] == 'all':\n return GenericGet().get_data(args,1,False)\n elif args['amount'] == 'nearest':\n return GenericGet().get_data(args,1,True)","def get(self, request, p_name, conn_name):\n project = Project.objects.get(name=p_name)\n connector = project.connector_set.filter(name=conn_name)\n serializer = ConnectorSerializer(connector[0], many=False)\n # Not modifying this as it works in tandem with the Thingworx app.\n return Response(serializer.data)","def calculate_demo(self, request, parent_lookup_client, pk, format=None):\n\n retirement_plan = self.get_object()\n tickers = Ticker.objects.filter(~Q(state=Ticker.State.CLOSED.value))\n portfolio = []\n projection = []\n for idx, ticker in enumerate(tickers[:10]):\n percent = 0\n if idx <= 9:\n # 10% each for first 10 tickers\n percent = 10\n portfolio.append([ticker.id, percent])\n # grab 50 evenly spaced time points between dob and current time\n today = timezone.now().date()\n last_day = retirement_plan.client.date_of_birth + relativedelta(years=retirement_plan.selected_life_expectancy)\n day_interval = (last_day - today) / 49\n income_start = 20000\n assets_start = 100000\n for i in range(50):\n income = income_start + (i * 50)\n assets = assets_start + (i * 1000)\n dt = today + i * day_interval\n projection.append([d2ed(dt), assets, income])\n return Response({'portfolio': portfolio, 'projection': projection})","def object_get(self, request):\n _view = _object_view(self, request)\n queried = ObjectPostings(self.cdb_object_id, request.params.mixed()).query()\n postings = [request.view(obj) for obj in queried[0]]\n\n _view.update({\n \"postings\": postings,\n \"result_complete\": queried[1]\n })\n return _view","def get_data(self, request, url):\n data = request.get(endpoint=url)\n return data[0], data[1]","def get(self):\n args = parser_degree.parse_args()\n if args['amount'] == 'all':\n return GenericGet().get_data(args,0,False)\n elif args['amount'] == 'nearest':\n return GenericGet().get_data(args,0,True)","def get_pronto_data():\n download_if_needed(\"https://s3.amazonaws.com/pronto-data/open_data_year_one.zip\",\n \"open_data_year_one.zip\")","def get(self, bill_id):\n try:\n bill = BillModel.find_by_id(bill_id)\n except:\n return {\"message\": \"An error occurred finding the item.\"}, 500 # Internal server error\n\n if bill:\n return bill.json()\n return {'message': 'Bill not found'}, 404","def _get_floorplans(self, url):\n \n try:\n jdict = self._load_json(url)\n floorplans_groups = jdict['props']['homeDetails']['floorPlans']['floorPlanGroups']\n address_data = list(self._get_address(jdict))\n rental_data = []\n \n # different floorplans, e.g. studio, 1 bedroom 1 bathroom etc.\n for floorplans in floorplans_groups:\n plans = floorplans['plans']\n for section in plans:\n # this is the header \n section_data = self._get_section_data(section)\n rental_data.append(address_data+section_data+[url])\n units = section['units']\n # these are all the units under that header \n for unit in units:\n unit_data = self._get_section_data(unit)\n rental_data.append(address_data+unit_data+[url])\n return rental_data\n except:\n return None","def ori_data_fbi(request):\n http = urllib3.PoolManager()\n\n\n #base_url=fbi_url(request)\n logging.Logger(base_url)\n print('I am inside the main function')\n # New request url\n request_url = base_url\n logging.Logger(request_url)\n\n\n payload = http.request('GET',\n request_url,\n headers={\n 'Content-Type': 'application/json',\n 'x-api-key': creds\n },\n fields={\n 'API_KEY':creds\n }\n )\n\n #*** only changing it for testing ***\n #return request_url\n # print(f'the type of payload is\\n {type(payload.data)}')\n print(payload.data)\n return load_into_bq(payload.data)\n #return payload.data","def get(request, pk=None):\n calls = Price.objects.filter(pk=int(pk))\n serializer = PriceSerializer(calls, many=True)\n return Response(serializer.data, status=status.HTTP_200_OK)","def get_data_from_web():\n pass","def data():\n return volumes_fetchers.get_json_data()","def test_companies_company_id_data_bill_credit_notes_get(self):\n pass","def _get_batch(self):\n url = self._base_url + urlConfig.URLS['Project'] + '/' + self._project_id + '/batch'\n response = apiCall.get(self._get_token(), url,self._proxy, {}, 10)\n logging.debug(response)\n return response","def getDataAt(self, address: ghidra.program.model.address.Address) -> ghidra.program.model.listing.Data:\n ...","async def get_all_record():\n # X_new = item.to_df()\n # item_str = item.to_string()\n # project_code = int(item_str[item_str.find('=')+1:])\n pg = PostgreSQL()\n return_json = pg.fetch_all_records()\n return return_json","def connect_data_api(self, endpoint):\n\n url = 'https://api.gdax.com' + endpoint\n res = requests.get(url)\n\n if res.status_code == 200:\n return res.json()\n else:\n raise ValueError(res.content)","def get_data(self):\n raise NotImplementedError(\"Not implemented!\")","def get():","def get():","def bcp_get(self, **kwargs):\n pass","def _get_consumption(self, url, start, end, aggregation):\n start = self._to_milliseconds(start)\n end = self._to_milliseconds(end)\n\n headers = {\"Authorization\": \"Bearer {}\".format(self.access_token)}\n params = {\n \"aggregation\": aggregation,\n \"from\": start,\n \"to\": end\n }\n r = requests.get(url, headers=headers, params=params)\n r.raise_for_status()\n return r.json()","def get(self):\n return_status = None\n result = {}\n try:\n log.debug(\"Summary info : \")\n #get the payload to influx DB\n url = \"http://localhost:8086/query\"\n querystring = {\"pretty\": \"true\", \"db\": \"IOT\",\n \"q\": sql }\n response = requests.request(\"GET\", url, params=querystring)\n r_d=json.loads(response.text)\n result_d=[]\n for rec in r_d['results'][0]['series']:\n for element in rec['values']:\n temp_d={}\n temp_d.update(rec['tags'])\n temp_d.update(dict(zip(rec['columns'],element)))\n result_d.append(temp_d)\n result['status'] = 1\n result['message']=result_d\n return_status = 200\n except ValueError as e:\n result = {}\n log.exception('Value Exception while fetching aggregate data')\n result['status'] = 0\n return_status = 400\n result['message'] = e.args[0]\n except :\n result = {}\n log.exception('Exception while aggregating the data')\n return_status = 500\n result['status'] = 0\n result['message'] = 'Internal Error has occurred while fetching aggregate data'\n finally:\n resp = Response(json.dumps(result), status=return_status, mimetype=\"application/json\")\n return resp","def get(self):\n return self.get_data()","def get_data(self, url):\n return self.get(url).get('data', [])","def get(cls, plan_id):\n return cls().requests.get(f\"plan/{plan_id}\")","def get_invoice(payload):\n response = requests.post(url, data=payload)\n return response.json()","def get(self, request):\n source = request.GET.get(\"source\", \"BLR\")\n destination = request.GET.get(\"destination\", \"DEL\")\n dateofdeparture = request.GET.get(\"date_of_departure\", \"20191027\")\n resp = get_flights(source, destination, dateofdeparture)\n return Response(resp)","def get_estimate(start_lat, start_lon, end_lat, end_lon, token):\n endpoint = \"https://api.uber.com/v1/estimates/price\"\n params = {\n 'start_latitude': start_lat,\n 'start_longitude': start_lon,\n 'end_latitude': end_lat,\n 'end_longitude': end_lon,\n 'server_token': token\n }\n r = requests.get(endpoint, params=params)\n r.raise_for_status()\n return r.json().pop('prices', [])","def get_raw_mercadopago_info():\n mercadopago_client_id = os.getenv('MERCADOPAGO_CLIENT_ID')\n mercadopago_client_secret = os.getenv('MERCADOPAGO_CLIENT_SECRET')\n\n mp = MP(mercadopago_client_id, mercadopago_client_secret)\n logger.debug('Connecting with mercadopago')\n\n filters = {'status': 'approved'}\n offset = 0\n results = []\n while True:\n response = mp.search_payment(filters, limit=LIMIT, offset=offset)\n assert response['status'] == 200\n logger.debug(\n 'Getting response from mercadopago, paging %s', response['response']['paging'])\n results.extend(response['response']['results'])\n if len(response['response']['results']) < LIMIT:\n break\n offset += LIMIT\n\n logger.info('Got response from mercadopago, %d items', len(results))\n return results","def get_amount():\n conn = None\n try:\n params = config()\n conn = psycopg2.connect(**params)\n cur = conn.cursor()\n\n #tas\n raw={}\n raw['plan']={}\n raw['actual']={}\n\n cur.execute(\"SELECT slc.*,plc.amount as amount_plan,ppm.amount as price \\\n ,to_char((slc.amount*ppm.amount)/aco.amount_actual_coal,'999.999') as cost_actual \\\n , to_char((plc.amount*ppm.amount)/aco.amount_actual_coal,'999.999') as cost_plan \\\n ,aco.amount_actual_coal \\\n FROM vw_tta_cps_sum_land_clearing_now AS slc \\\n LEFT JOIN vw_tta_cps_price_per_month AS ppm \\\n ON slc.int_month=ppm.month \\\n AND slc.year_id=ppm.year_id \\\n LEFT JOIN vw_tta_cps_plan_land_clearing AS plc \\\n ON slc.periode_month_id=plc.periode_month_id \\\n AND slc.land_clearing_location_id=plc.land_clearing_location_id \\\n LEFT JOIN vw_tta_cps_sr_all_per_month_plan_actual as aco \\\n ON aco.int_month=slc.int_month \\\n WHERE ppm.jenis_price=10 \\\n AND aco.plan_id=1\")\n rowcount=cur.rowcount\n print(\"The number of row: \", rowcount)\n row = cur.fetchone()\n counter=0\n item={}\n\n if rowcount>0:\n f=open('../../data_cost_per_ton.csv','w')\n f.write('AREA,PLAN,ACTUAL\\n')\n while row is not None:\n #print(row)\n raw[\"plan\"]=row[11]\n raw[\"actual\"]=row[10]\n f.write(str('RAW')+','+str(raw[\"plan\"])+','+str(raw[\"actual\"])+\"\\n\")\n\n row = cur.fetchone()\n\n if rowcount>0:\n f.close()\n cur.close()\n\n print(str(datetime.datetime.now())+' '+str(rowcount)+' row updated')\n except (Exception, psycopg2.DatabaseError) as error:\n print(str(datetime.datetime.now())+' '+str(error))\n finally:\n if conn is not None:\n conn.close()","def get_details(self):","def get_data(self):\n data_obj = VerticaGetter()\n if self.context_name == 'PARTS':\n param_list = [self.start_date,self.end_date,self.param_name]\n param_list = [str(elem) for elem in param_list]\n res = data_obj.get_visitor_analysis(param_list)\n else:\n res = data_obj.get_visitor_analysis()\n return res","def listings_data():\n\n stmt = db.session.query(nyc).statement\n df = pd.read_sql_query(stmt, db.session.bind)\n df[\"latitude\"] = pd.to_numeric(df[\"latitude\"])\n df[\"longitude\"] = pd.to_numeric(df[\"longitude\"])\n df[\"accommodates\"] = pd.to_numeric(df[\"accommodates\"])\n\n data = df.to_dict(orient='index')\n # Create a dictionary entry for each row of metadata information\n # data = {}\n # for result in results:\n #\n # data[\"ID\"] = result[0]\n # data[\"LISTING_URL\"] = result[1]\n # data[\"NAME\"] = result[2]\n # data[\"HOST_ID\"] = result[3]\n # data[\"NEIGHBORHOOD\"] = result[4]\n # data[\"NEIGHBORHOOD_GROUP\"] = result[5]\n # data[\"CITY\"] = result[6]\n # data[\"ZIPCODE\"] = result[7]\n # data[\"LAT\"] = float(result[8])\n # data[\"LON\"] = float(result[9])\n #\n # print(data)\n\n return jsonify(data)","def getPanchayatsAccurateData(request):\n if request.method == 'GET':\n panchayat=request.GET.get('panchayat', '')\n ptid=request.GET.get('ptid', '')\n block = request.GET.get('block', '')\n bid = request.GET.get('bid', '')\n district = request.GET.get('district', '')\n state = request.GET.get('state', '')\n limit=request.GET.get('limit', '')\n if limit == '':\n limit=500\n else:\n limit=int(limit)\n #PTID we need to make it exact. Finyaer make it current finyear\n panchayats = PanchayatStat.objects.filter(panchayat__name__icontains = panchayat, panchayat__id__icontains = ptid, panchayat__block__id__icontains = bid, panchayat__block__name__icontains=block, panchayat__block__district__name__icontains = district, panchayat__block__district__state__name__icontains = state, workDaysAccuracyIndex__gte = 90, finyear = '17')\n\n\n panchayats = panchayats[:limit]\n serializer = PanchayatStatSerializer(panchayats, many=True)\n return JsonResponse(serializer.data, safe=False)","def get_data(rics: list, fields: list):\n data, err = ek.get_data(rics, fields)\n if err:\n print(err)\n return data","def get_monthly_prism_ppt_data(year,month, plotPPTBounds):\n \"\"\" It is in the form of grid \"\"\"\n \n if(month<10):\n prism_file_path = \"PRISM_ppt_stable_4kmM3_\"+str(year)+\"0\"+str(month)+\"_bil.bil\"\n else:\n prism_file_path = \"PRISM_ppt_stable_4kmM3_\"+str(year)+str(month)+\"_bil.bil\" \n \n ppt_data = read_prism_bil(join(cf.root, cf.prism_dir, prism_file_path))\n \n hdr_dict = read_prism_hdr(join(cf.root, cf.prism_dir, prism_file_path).replace('.bil', '.hdr'))\n \n hdr_dict[\"ULXMAP\"] = float(hdr_dict[\"ULXMAP\"])\n hdr_dict[\"ULYMAP\"] = float(hdr_dict[\"ULYMAP\"])\n hdr_dict['NROWS'] = int(hdr_dict['NROWS'])\n hdr_dict['NCOLS'] = int(hdr_dict['NCOLS'])\n hdr_dict['XDIM'] = float(hdr_dict['XDIM'])\n hdr_dict['YDIM'] = float(hdr_dict['YDIM'])\n \n p1 = (hdr_dict[\"ULXMAP\"] - (hdr_dict['XDIM']/2), \n hdr_dict[\"ULYMAP\"] + (hdr_dict['YDIM']/2))\n\n p2 = (p1[0] + (hdr_dict['NCOLS']*hdr_dict['XDIM']),\n p1[1])\n\n p3 = (p2[0],\n p2[1] - (hdr_dict['NROWS']*hdr_dict['YDIM']))\n\n p4 = (p1[0],\n p3[1])\n \n lon_point_list = (p1[0], p2[0], p3[0], p4[0])\n lat_point_list = (p1[1], p2[1], p3[1], p4[1])\n \n ppt_bounds = Polygon(zip(lon_point_list, lat_point_list))\n \n if(plotPPTBounds):\n crs = {'init': 'epsg:4326'}\n m = folium.Map(zoom_start=10, tiles='cartodbpositron')\n polygon = gpd.GeoDataFrame(index=[0], crs=crs, geometry=[ppt_bounds]) \n \n folium.GeoJson(polygon).add_to(m)\n folium.LatLngPopup().add_to(m)\n m.save(\"Prism Bounds.html\")\n\n return ppt_bounds, ppt_data, hdr_dict","def query_api(location):\n #bearer_token = obtain_bearer_token(API_HOST, TOKEN_PATH)\n bearer_token ='SHdrjUqMJXqXBKUc7bGIplM8y6tnbwZbXXDbWPCd9wWMP8tX9PdJrC5MZHwJRhb7jMtLjXxT-hsWjNf2OkdiDWd30HsS84AVI5iRnrpxkak3HbWXAdUKvraQ_wgXWXYx'\n response = transaction_search(bearer_token,location)\n response = response.get('businesses')\n return response","def _offset_call(self, url, params) -> Dict:\n response = self._get(url, params=params)\n raise_on_error(response)\n return response.json()","def precipitation():\n # Calculate the date 1 year ago from the last data point in the database\n #Create our session (link) from Python to the DB\n session = Session(engine)\n\n # Use query from notebook. Get the last date in database, then calc a year before \n last_date = session.query(func.max(Measurement.date)).first() \n year_ago = dt.date(2017, 8, 23) - dt.timedelta(days=365)\n # filter to one year ago \n twelve_months_precip = session.query(Measurement.date, Measurement.prcp).filter(Measurement.date >= year_ago).all()\n\n session.close()\n\n # create a list for results to jsonify \n\n list_data = []\n for months in twelve_months_precip:\n data = {}\n data[\"date\"] = months[0]\n data[\"prcp\"] = months[1]\n list_data.append(data)\n\n # jsonify the results \n\n return jsonify(list_data)","def getPTData(*args):\n return args[0].Data.PTData.pt_data","def GetGeData(self, *args, **kwargs):\n pass","async def get_record(item: Item):\n X_new = item.to_df()\n item_str = item.to_string()\n project_code = int(item_str[item_str.find('=')+1:])\n pg = PostgreSQL()\n return_json = pg.fetch_query_given_project(project_code)\n return return_json","def getReport(request):\n\n\t#parameters needed for different REST API's\n\tparams = {\n\t\t'rid':-1,\n\t\t'year':-1,\n\t\t'con_num':-1,\n\t\t'assign_num':-1,\n\t\t'item_num':-1,\n\t\t'wtype': -1,\n\t\t'payno': -1,\n\t\t'snap': 0, #default is 0 for snapshots (for now)\n\t\t'issue_date': -1,\n\t}\n\n\t#loop over the parameters and set them if they appear in the api url\n\tfor p in params:\n\t\tif p in request.GET:\n\t\t\tparams[p] = request.GET[p]\n\n\n\t#get the request session and load data\n\ts = requests.Session()\n\tif not isinstance(rgen.ReportGenerator.get_url(params), dict):\n\t\tresponse = s.get(rgen.ReportGenerator.get_url(params))\n\n\t\t#set the iterator and the content\n\t\tit = json.loads(response.content)\n\t\tcontent = json.loads(response.content)\n\t\t\n\t\t#while a next page exists, parse the api\n\t\tpageNum = 1\n\t\twhile \"next\" in it:\n\t\t\tresponse = s.get(rgen.ReportGenerator.get_url(params) + '?page=' + str(pageNum))\n\t\t\tit = json.loads(response.content)\n\t\t\tcontent[\"items\"].extend(it[\"items\"])\n\t\t\tpageNum += 1\n\n\telse:\n\t\t#if the url is a list\n\t\tcontent = {}\n\t\tfor part in rgen.ReportGenerator.get_url(params):\n\t\t\tresponse = s.get(rgen.ReportGenerator.get_url(params)[part])\n\t\t\tit = json.loads(response.content)\n\t\t\t#content = {\"part1\":{\"items\":[]}, \"part2\":{\"items\":[]}, \"part3\":{\"items\":[]}}\n\t\t\t\n\t\t\tcontent[part] = {}\n\t\t\tcontent[part][\"items\"] = []\n\t\t\tcontent[part][\"items\"].extend(it[\"items\"])\n\n\t\t\tpageNum = 1\n\t\t\twhile \"next\" in it:\n\t\t\t\tresponse = s.get(rgen.ReportGenerator.get_url(params)[part] + '?page=' + str(pageNum))\n\t\t\t\tit = json.loads(response.content)\n\t\t\t\tcontent[part][\"items\"].extend(it[\"items\"])\n\t\t\t\tpageNum += 1\n\t\n\t#set the file object to be returned as a download\n\tfile = HttpResponse(rgen.ReportGenerator.formExcel(content, params), content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')\n\tif params[\"rid\"] == '70':\n\t\tfile['Content-Disposition'] = 'attachment; filename=' + rgen.r_dict[params[\"rid\"]][1] + ' No.' + params['issue_date'] + '.xlsx'\n\telse:\n\t\tfile['Content-Disposition'] = 'attachment; filename=' + rgen.r_dict[params[\"rid\"]][1] + '.xlsx'\n\ts.close()\n\treturn file","def _get(self, path, params=None):\n return self._api.get_json(path, headers={\"Hawkular-Tenant\": self.tenant_id}, params=params)","def get_data(self, lat=53.3498, lon=-6.2603):\n r = requests.get(\n f\"https://api.openweathermap.org/data/2.5/onecall?lat={lat}&lon={lon}&appid=92fb08f48a98e0f39b990060352ffebe\")\n return r.text","def getData(self, local_cache):","def get_floor_plan(port_id):\n url = 'https://api.archisketch.com/v1/public/projects/'\n response = requests.get(url + port_id + '/detail')\n response = response.json()['project']\n floor_plan = response['floorplans'][0]\n return floor_plan","def get(self, request, unit_id):\n start_date = get_start_date(request)\n end_date = get_end_date(request)\n readings = MeterReading.objects.filter(\n unit=unit_id,\n date__gte=start_date,\n date__lte=end_date,\n reading_type='GAS'\n )\n serializer = MeterReadingSerializer(readings, many=True)\n return Response(serializer.data)","def fetch_data(self):\n\n data_dict = {\n 'price': self.get_current_price(),\n }\n\n return self.save_data(data_dict)","def data():\n columns = request.form.getlist('columns')\n regions = request.form.getlist('fieldsArr')\n #print(regions)\n #for the visualization step, a copy of the 'RAW' regions.\n raw_regions = regions\n\n regions = regions[0].split(',')\n\n #catch if region is empty, should not be if the client hasn't modified\n #client side code\n reg_len = len(regions)\n if reg_len == 1:\n regions = ['AUS_CODE_2016,036']\n raw_regions = 'AUS_CODE_2016,036'\n #regions are split into a list and columns are a list, time to enfore\n # limits! up to 100 columns by 1000 cells max!\n if len(columns) > 10:\n columns = columns[:10]\n\n #extra 1 for the regions code yet to be extracted\n if len(regions) > 1001:\n regions = regions[:1001]\n\n area = regions[0]\n\n #check for no slected data itme and return a total pop count\n col_len = len(columns)\n if col_len == 0:\n columns.append('Tot_P_P')\n\n # bigly work,\n r_data = query_proc.table_query(regions, columns)\n\n columns.insert(0, area)\n columns.insert(0, \"Census 2016 Name\")\n\n return render_template('data.html',\n title='Data from the map',\n data=r_data,\n columns=columns,\n raw_regions=raw_regions)","def get(self, data):\n pass","def mapping(self):\n return self.request('_mapping', pylastica.request.Request.GET).data","def call(self, endpoint: str = \"\", query: dict = dict(), method: str = \"GET\",\n unit: bool = True) -> dict:\n query.update({'apikey': self.api_key, 'lat': self.coords[0], 'lon': self.coords[1]})\n if unit:\n query['unit_system'] = self.unit_system\n resp = requests.request(\n url=self.base_url + endpoint,\n method=method,\n params=query\n )\n if not resp.ok:\n raise e.ClimaAPIError(resp)\n return resp.json()","def get_data(radius: int, user_zip_code: str, state_dict: dict,\n provider_filter: list) -> list:\n # zip_map_dict = create_zip_dict()\n active_set = active_providers(state_dict['metadata']['provider_brands'])\n in_range_lst = create_in_range_lst(state_dict['features'],\n user_zip_code, radius,\n active_set, False, provider_filter)\n return create_message_list(in_range_lst, user_zip_code)","def index(self):\n args = index_reqparse.parse_args()\n args.api_key = \"8l3xbEmsQMq7AG7mXoSy3IuJAqehmWGRC754Otx7\"\n\n url = 'http://api.data.gov/gsa/fbopen/v0/opps?%s' % urlencode(query=args)\n\n return json.loads(urlopen(url=url).read())","def get_entity_data(self, instance_id = None):\n # Typically, this url is better, becuase we can insert parameters into url in a proper way\n # original url is 'https://api.ci.ai.dynamics.com/v1/instances/{instanceId}/data/{relativePath}[?forceSearch][&proxy]'\n # but we don't need optional parameters, so we delete them from full url\n url_original = 'https://api.ci.ai.dynamics.com/v1/instances/{instanceId}/data/{relativePath}'\n # it seems {} only part of python sting format, so we only use string.format(value1, value2,..) to replace it \n url_parse = url_original.format(instanceId = self.INSTANCEID, relativePath = self.RELATIVEPATH)\n # it seems sometimes url with parameters not working, so we provide a fulfuiled url \n url_full = 'https://api.ci.ai.dynamics.com/v1/instances/c910b061-1008-4397-95f6-4e7b443b924a/data/RetailDemoData_RetailSystem_Contacts'\n \n # send get request with \n response = requests.get(url_parse, headers=self.HEADERS)\n # r2 = requests.get(url_full, headers=self.HEADERS)\n print(response)\n # for record in r3.json():\n # print(json.dumps(record))\n # according to json file structore, our data contain in ['value']\n # response.json()['value']\n # for row in r3.json()['value']:\n # print(json.dumps(row))\n # we can try to storage data into a local directory,\n # these only work for local python script, not on AZURE runbook\n # with open('03_data/32_entity.json', 'w') as outfile:\n # json.dump(r3.json()['value'], outfile)\n\n return response.json()['value']","def get(self, base_url, observable, limit, credentials):\n\n url = url_join(base_url, self.filter(observable)) + f'&$top={limit}'\n\n response = get_data(url, credentials)\n\n return [\n self.sighting(observable, x) for x in response.get('value', [])\n ]","def get(self):\n\n bill = {\n 'product': {\n 'name': self.order.product.name,\n 'price': self.order.product.price\n },\n 'order_date_of_creation': self.order.date_of_creation,\n 'bill_date_of_creation': timezone.now(),\n 'discounts': [],\n 'total': self.order.product.price\n }\n\n return self.add_discount(bill)","def _get_data(self, url: str)->dict:\n data = None\n resp = self._get(url)\n if resp:\n data = resp.json()['data']\n return data","def apicall():\r\n# try:\r\n print request.get_json()\r\n test_json = request.get_json()\r\n logger.info(\"input json object loaded\")\r\n logger.info(test_json)\r\n k=MetaData(test_json)\r\n int_res=k.getData()\r\n print '------------------------------'\r\n print int_res\r\n return jsonify(int_res)","def get_data(ts_code: int, begin: str, end: str) -> List:\n\n url = (\n \"http://api.bcb.gov.br/dados/serie/bcdata.sgs.{}\"\n \"/dados?formato=json&dataInicial={}&dataFinal={}\"\n )\n request_url = url.format(ts_code, begin, end)\n response = requests.get(request_url)\n return response.json()","def main():\n #bearer_token = obtain_bearer_token(API_HOST, TOKEN_PATH)\n bearer_token ='SHdrjUqMJXqXBKUc7bGIplM8y6tnbwZbXXDbWPCd9wWMP8tX9PdJrC5MZHwJRhb7jMtLjXxT-hsWjNf2OkdiDWd30HsS84AVI5iRnrpxkak3HbWXAdUKvraQ_wgXWXYx'\n response = transaction_search(bearer_token, '1910 Entrepreneur Dr, Raleigh, NC 27518')\n response = response.get('businesses')\n print(json.dumps(response, indent=4))","def get(self, *args, **kwargs) -> Any:\n return self.raw_data.get(*args, **kwargs)","def get_claim_bill(\n _db: Session = db, *, start: datetime = None, end: datetime = None,\n store_internal_id: int = None, owner_id: int = None,\n kind: models.ClaimKind = None, calculation: CalcType = \"avg\"\n):\n query = crud.claim.get_query(_db)\n if start and end:\n query = query.filter(models.Claim.created_at.between(start, end))\n if store_internal_id:\n query = query.filter(models.Claim.store_internal_id == store_internal_id)\n if owner_id:\n query = query.filter(models.Claim.owner_id == owner_id)\n if kind:\n query = query.filter(models.Claim.kind == kind)\n bill = query.with_entities(getattr(func, calculation)(models.Claim.bill).label(\"_bill\")).first()\n bill_round = round(bill[0], 2) if bill[0] is not None else 0.00\n return bill_round"],"string":"[\n \"async def __getBBL_async(self, account, projectedBillData) -> dict:\\n _LOGGER.info(\\\"Getting budget billing data\\\")\\n data = {}\\n\\n try:\\n async with async_timeout.timeout(TIMEOUT):\\n response = await self.session.get(\\n URL_BUDGET_BILLING_PREMISE_DETAILS.format(account=account)\\n )\\n if response.status == 200:\\n r = (await response.json())[\\\"data\\\"]\\n dataList = r[\\\"graphData\\\"]\\n\\n # startIndex = len(dataList) - 1\\n\\n billingCharge = 0\\n budgetBillDeferBalance = r[\\\"defAmt\\\"]\\n\\n projectedBill = projectedBillData[\\\"projected_bill\\\"]\\n asOfDays = projectedBillData[\\\"as_of_days\\\"]\\n\\n for det in dataList:\\n billingCharge += det[\\\"actuallBillAmt\\\"]\\n\\n calc1 = (projectedBill + billingCharge) / 12\\n calc2 = (1 / 12) * (budgetBillDeferBalance)\\n\\n projectedBudgetBill = round(calc1 + calc2, 2)\\n bbDailyAvg = round(projectedBudgetBill / 30, 2)\\n bbAsOfDateAmt = round(projectedBudgetBill / 30 * asOfDays, 2)\\n\\n data[\\\"budget_billing_daily_avg\\\"] = bbDailyAvg\\n data[\\\"budget_billing_bill_to_date\\\"] = bbAsOfDateAmt\\n\\n data[\\\"budget_billing_projected_bill\\\"] = float(projectedBudgetBill)\\n\\n async with async_timeout.timeout(TIMEOUT):\\n response = await self.session.get(\\n URL_BUDGET_BILLING_GRAPH.format(account=account)\\n )\\n if response.status == 200:\\n r = (await response.json())[\\\"data\\\"]\\n data[\\\"bill_to_date\\\"] = float(r[\\\"eleAmt\\\"])\\n data[\\\"defered_amount\\\"] = float(r[\\\"defAmt\\\"])\\n except Exception as e:\\n _LOGGER.error(e)\\n\\n return data\",\n \"def get_data(self):\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n return\",\n \"def fetch_data(self):\",\n \"def get_bill_details(request):\\n\\n print request\\n\\n context = request['context']\\n print context\\n try:\\n telephone_number = first_entity_value(request['entities'], 'phone_number')\\n with open(os.path.join(sys.path[0], \\\"app/wit/static/users.json\\\"), \\\"r\\\") as data_file:\\n data = json.load(data_file)\\n customer_billing = data[telephone_number]['last_month_billing']\\n print customer_billing\\n\\n customer_type = data[telephone_number]['type_customer']\\n if customer_type == 'postpaid':\\n\\n reply = \\\"Our Initial Investigation shows that you're a \\\" + data[telephone_number]['type_customer'] + \\\" Customer and currently using \\\" + data[telephone_number]['plan_details'] + \\\" plan type.\\\"\\n if customer_billing['roaming'] == 'True':\\n reply += \\\"You had used your cellphone while on roaming for which you were charged extra.\\\"\\n elif customer_billing['data_exhaust'] == 'True':\\n reply += \\\"You had used your data network after your allocated limit was exhausted. You were charged for these services\\\"\\n elif customer_billing['subscribed'] == 'True':\\n reply += \\\"You had subscribed to some promotional services for which you were charged in extra.\\\"\\n else:\\n reply = \\\"Our Initial Investigation shows that you're a \\\" + data[telephone_number]['type_customer'] + \\\". We believe that this might be a mistake from our side and would like you to speak to our customer care executives separately.\\\"\\n\\n\\n except:\\n telephone_number = None\\n reply = \\\"Your number is not subscribed with Airtel. Please contact your network operator for your query\\\"\\n\\n\\n print reply\\n\\n context['bill_details'] = reply\\n\\n return context\",\n \"def get_data(endpoint_name, arg=None,\\n project_name=None, fields=None, size=get_setting_value('DEFAULT_SIZE'), page=0,\\n data_category=None, query_args={}, verify=False, *args, **kwargs):\\n endpoint = get_setting_value('GDC_API_ENDPOINT').format(endpoint=endpoint_name)\\n if arg:\\n endpoint = endpoint+'/{}'.format(arg)\\n else:\\n ## prep extra-params, including `from` param, as dict\\n extra_params = {}\\n if page>0:\\n from_param = helpers.compute_start_given_page(page=page, size=size)\\n extra_params.update({\\n 'from': from_param,\\n })\\n if fields:\\n extra_params.update({'fields': ','.join(helpers.convert_to_list(fields))})\\n if dict(**kwargs):\\n ## TODO check on whether this handles redundant param spec \\n ## correctly\\n extra_params.update(dict(**kwargs))\\n params = _params.construct_parameters(project_name=project_name,\\n size=size,\\n data_category=data_category,\\n query_args=query_args,\\n verify=verify,\\n **extra_params\\n )\\n # requests URL-encodes automatically\\n log.info('submitting request for {endpoint} with params {params}'.format(endpoint=endpoint, params=params))\\n response = requests_get(endpoint, params=params)\\n log.info('url requested was: {}'.format(response.url))\\n response.raise_for_status()\\n return response\",\n \"def get(self, args):\\n return Payment.query.offset(args['offset']).limit(args['limit'])\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def get_data(self):\\n pass\",\n \"def get_data(self):\\n pass\",\n \"def get():\\n\\n # \\\\todo List of available data, fetched and processed\\n\\n return jsonify({'valid_resources': ['balance', 'balance_usd', 'trade_history', 'balance_norm_price_history', 'open_orders']})\",\n \"def get_data(self, exportformat: str, oidrange: list):\\r\\n querystr = f\\\"?where=objectid+>%3D+{oidrange[0]}+AND+objectid+<%3D+{oidrange[1]}&text=&objectIds=&time=&geometry=&geometryType=esriGeometryEnvelope&inSR=&spatialRel=esriSpatialRelIntersects&relationParam=&outFields=*&returnGeometry=true&returnTrueCurves=false&maxAllowableOffset=&geometryPrecision=&outSR=&returnIdsOnly=false&returnCountOnly=false&orderByFields=&groupByFieldsForStatistics=&outStatistics=&returnZ=false&returnM=false&gdbVersion=&returnDistinctValues=false&resultOffset=&resultRecordCount=&queryByDistance=&returnExtentsOnly=false&datumTransformation=¶meterValues=&rangeValues=&f={exportformat}\\\"\\r\\n req = requests.get(self.endpointurl + querystr)\\r\\n return req.json()\",\n \"def get_data(self):\\r\\n pass\",\n \"def plan_get(request):\\n company = auth_api_key(request)\\n plan = get_and_check_plan(request, company)\\n return plan\",\n \"def _get_data(self):\\n raise NotImplementedError()\",\n \"def get(self):\\n # req = requests.get(\\\"\\\")\\n # data = req.json()\\n # print(data)\\n query = Event.query.all()\\n event_first_bill_pay(data=query, event_type=\\\"bill payment\\\")\\n threading.Thread(target=event_notify_user, args=(\\\"Notify User\\\", query,)).start()\\n threading.Thread(target=event_post_feedback, args=(\\\"Post Feeback\\\",)).start()\\n return query\",\n \"def get(self, http, req_dict):\\n\\n\\t\\t# Turn account numbers into integers and remove duplicates\\n\\t\\taccount_numbers = self.get_account_numbers( req_dict['account_numbers[]'] )\\n\\n\\t\\t# A primary did is a Physical line, with OFN disabled (e.g. not a softphone),\\n\\t\\t# which is connected to a primary rate plan\\n\\n\\t\\tprimary_did_sql = \\\"\\\"\\\"\\n\\t\\t\\tselect distinct did.account_number,\\n\\t\\t\\t did.phone_number\\n\\t\\t\\t from did_numbers did\\n\\n\\t\\t\\t join DID_BILLING_ITEM dbi\\n\\t\\t\\t on dbi.DID_NUMBER_ID = did.DID_NUMBER_ID\\n\\t\\t\\t and dbi.ACCOUNT_NUMBER = did.ACCOUNT_NUMBER\\n\\t\\t\\t and dbi.STATUS = 'A'\\n\\n\\t\\t\\t join AP_REPORT.ITEM_MASTER_LU im\\n\\t\\t\\t on im.ITEM_CODE = dbi.SERVICE_ITEM_CODE\\n\\t\\t\\t and im.ITEM_TYPE = 'RATE_PLAN'\\n\\t\\t\\t and im.USE_CLASS = 'PRIMARY'\\n\\n\\t\\t\\t where (did.date_end is null or did.date_end > SYSDATE + 90)\\n\\t\\t\\t and did.did_type_id = 'PHY'\\n\\t\\t\\t and did.ofn_enabled = 'N'\\n\\t\\t\\t and did.account_number in %s\\n\\t\\t\\t\\\"\\\"\\\" % self.account_sql_list\\n\\n\\t\\taccount_sql = \\\"\\\"\\\"\\n\\t\\t\\tselect\\n\\t\\t\\ta.ACCOUNT_NAME,\\n\\t\\t\\ta.STATUS,\\n\\t\\t\\tto_char(a.DATE_CREATED, 'yyyy-mm-dd hh24:mi:ss'),\\n\\t\\t\\ta.ACCOUNT_NUMBER,\\n\\t\\t\\tlower(au.USER_NAME),\\n\\t\\t\\tau.EMAIL_ADDRESS,\\n\\t\\t\\ta.PARTNER_ID,\\n\\t\\t\\tast.ACCOUNT_STATUS_TYPE,\\n\\t\\t\\tto_char(a.DATE_START, 'yyyy-mm-dd hh24:mi:ss'),\\n\\t\\t\\tto_char(a.DATE_END, 'yyyy-mm-dd hh24:mi:ss'),\\n\\t\\t\\tto_char(a.BILL_CYCLE_DATE_START, 'yyyy-mm-dd hh24:mi:ss'),\\n\\t\\t\\tto_char(a.BILL_CYCLE_DATE_END, 'yyyy-mm-dd hh24:mi:ss'),\\n\\t\\t\\tau.FIRST_NAME,\\n\\t\\t\\tau.LAST_NAME,\\n\\t\\t\\tat.ACCOUNT_TYPE,\\n\\t\\t\\tau.CONTACT_TELEPHONE,\\n\\t\\t\\ttz.TIMEZONE_ID,\\n\\t\\t\\ttz.TIMEZONE_NAME\\n\\t\\t\\tfrom\\n\\t\\t\\tACCOUNT a,\\n\\t\\t\\tACCOUNT_STATUS_TYPE ast,\\n\\t\\t\\tACCOUNT_TYPE at,\\n\\t\\t\\tACCOUNT_USER au,\\n\\t\\t\\tTIMEZONE tz\\n\\t\\t\\twhere a.ACCOUNT_NUMBER in %s\\n\\t\\t\\tand au.ACCESS_LEVEL = 'acctadmin'\\n\\t\\t\\tand ast.ACCOUNT_STATUS_TYPE_ID = a.STATUS\\n\\t\\t\\tand a.ACCOUNT_TYPE_ID = at.ACCOUNT_TYPE_ID\\n\\t\\t\\tand a.ACCOUNT_NUMBER = au.ACCOUNT_NUMBER\\n\\t\\t\\tand a.TIMEZONE_NUM = tz.TIMEZONE_NUM\\n\\t\\t\\torder by a.ACCOUNT_NUMBER\\n\\t\\t\\t\\\"\\\"\\\" % self.account_sql_list\\n\\n\\t\\tstatus_dates_sql = \\\"\\\"\\\"\\n\\t\\t\\tselect\\n\\t\\t\\tACCOUNT_NUMBER,\\n\\t\\t\\tto_char(COMPLETED_DATE, 'yyyy-mm-dd hh24:mi:ss'),\\n\\t\\t\\tACCOUNT_STATUS_TYPE_ID\\n\\t\\t\\tfrom account_status\\n\\t\\t\\tWHERE CURRENT_FLAG = 'Y'\\n\\t\\t\\tAND ACCOUNT_NUMBER in %s\\n\\t\\t\\t\\\"\\\"\\\" % self.account_sql_list\\n\\n\\t\\tlower_limit = 0\\n\\n\\t\\tret_obj = AccountResults()\\n\\n\\t\\twhile lower_limit < len(account_numbers):\\n\\t\\t\\t# Take self.account_sql_list_size (e.g. 10) account numbers at a time.\\n\\n\\t\\t\\tparams = {}\\n\\t\\t\\tfor idx in xrange(0, self.account_sql_list_size):\\n\\t\\t\\t\\tkey = \\\"account_number\\\" + str(idx + 1)\\n\\t\\t\\t\\tif (lower_limit + idx) >= len(account_numbers):\\n\\t\\t\\t\\t\\tparams[key] = None\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tparams[key] = account_numbers[lower_limit + idx]\\n\\n\\t\\t\\tlower_limit += self.account_sql_list_size\\n\\n\\t\\t\\t# Find the primary dids for these account numbers seperately,\\n\\t\\t\\t# because the query is crazy.\\n\\n\\t\\t\\tauth_file = 'ps_oracle_sqlr'\\n\\n\\t\\t\\tcurs = self.execute_query(auth_file, primary_did_sql, params)\\n\\t\\t\\trows = curs.fetchall()\\n\\t\\t\\tcurs.close()\\n\\n\\t\\t\\tprimary_dids = self.get_primary_dids(rows)\\n\\n\\t\\t\\t# Find Status Updated Dates and Account Status\\n\\n\\t\\t\\tcurs = self.execute_query(auth_file, status_dates_sql, params)\\n\\t\\t\\trows = curs.fetchall()\\n\\t\\t\\tcurs.close()\\n\\n\\t\\t\\tstatus_dates = self.get_status_dates(rows)\\n\\n\\t\\t\\taccount_status = self.get_status(rows)\\n\\n\\t\\t\\t# Find the rest of the data.\\n\\n\\t\\t\\tcurs = self.execute_query(auth_file, account_sql, params)\\n\\t\\t\\trows = curs.fetchall()\\n\\t\\t\\tcurs.close()\\n\\n\\t\\t\\tif curs.rowcount < 1:\\n\\t\\t\\t\\traise RestDatabaseNotFound(\\\"None of the accounts were found.\\\")\\n\\n\\t\\t\\tfor row in rows:\\n\\t\\t\\t\\taccount = Account()\\n\\t\\t\\t\\taccount.account_name = row[0]\\n\\t\\t\\t\\taccount.status_code = row[1]\\n\\t\\t\\t\\taccount.date_created = row[2]\\n\\t\\t\\t\\tif account.date_created is not None:\\n\\t\\t\\t\\t\\taccount.date_created = account.date_created + ' +0000'\\n\\t\\t\\t\\taccount.account_number = row[3]\\n\\t\\t\\t\\t# Get the Account Status from the Account_Status Table from VDV.\\n\\t\\t\\t\\tif account_status.has_key(account.account_number):\\n\\t\\t\\t\\t\\taccount.status_code = account_status.get(account.account_number)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\taccount.status_code = row[1]\\n\\t\\t\\t\\t\\t# Log the account number as not having an active status in the account_status table\\n\\t\\t\\t\\t\\tself.log.debug(\\\"Account does not have an Active Status in the accout_status table. Account Number:\\\"+ account.account_number)\\n\\t\\t\\t\\taccount.username = row[4]\\n\\t\\t\\t\\taccount.email = row[5]\\n\\t\\t\\t\\taccount.partner = row[6]\\n\\t\\t\\t\\taccount.status = row[7]\\n\\t\\t\\t\\taccount.account_start_date = row[8]\\n\\t\\t\\t\\tif account.account_start_date is not None:\\n\\t\\t\\t\\t\\taccount.account_start_date = account.account_start_date + ' +0000'\\n\\t\\t\\t\\taccount.account_end_date = row[9]\\n\\t\\t\\t\\tif account.account_end_date is not None:\\n\\t\\t\\t\\t\\taccount.account_end_date = account.account_end_date + ' +0000'\\n\\t\\t\\t\\taccount.bill_cycle_start_date = row[10]\\n\\t\\t\\t\\tif account.bill_cycle_start_date is not None:\\n\\t\\t\\t\\t\\taccount.bill_cycle_start_date = account.bill_cycle_start_date + ' +0000'\\n\\t\\t\\t\\taccount.bill_cycle_end_date = row[11]\\n\\t\\t\\t\\tif account.bill_cycle_end_date is not None:\\n\\t\\t\\t\\t\\taccount.bill_cycle_end_date = account.bill_cycle_end_date + ' +0000'\\n\\t\\t\\t\\taccount.first_name = row[12]\\n\\t\\t\\t\\taccount.last_name = row[13]\\n\\t\\t\\t\\taccount.account_type = row[14]\\n\\t\\t\\t\\taccount.contact_telephone = row[15]\\n\\t\\t\\t\\taccount.time_zone = row[16]\\n\\t\\t\\t\\taccount.time_zone_name = row[17]\\n\\t\\t\\t\\taccount.primary_did_numbers.did = primary_dids.get(account.account_number, [])\\n\\t\\t\\t\\taccount.status_updated_date = status_dates.get(account.account_number)\\n\\n\\t\\t\\t\\tself.db_free()\\n\\n\\t\\t\\t\\tret_obj.account_info.append(account)\\n\\n\\t\\treturn ret_obj.dumps(SERVICE_ATTRIBUTES)\",\n \"def getStockData():\\n pass\",\n \"def fetchGeoData():\\n if request.method ==\\\"POST\\\":\\n result = {}\\n if request.get_json():\\n post_requests = request.get_json()\\n print(post_requests)\\n result = db.getmapdata(post_requests['attr']) \\n return result\",\n \"def local_bonds_prices():\\n url1 = \\\"https://api.invertironline.com/token\\\"\\n\\n data = {\\n \\\"username\\\": usuario,\\n \\\"password\\\": password,\\n \\\"grant_type\\\": \\\"password\\\" \\n }\\n response = requests.post(url1, data=data)\\n if response.status_code == 200:\\n content = response.text\\n access_key = token_key(content)\\n\\n url2 = f'https://api.invertironline.com/api/v2/Cotizaciones/Bonos/Merval/argentina'\\n datos = requests.get(url2, headers={\\n 'Authorization': 'Bearer '+access_key\\n })\\n datos = json.loads(datos.text)\\n datos = datos['titulos']\\n datos = clean_assets(datos)\\n return datos\",\n \"def get_data( obj, prm, lev, date, timelevel=0 ):\\n \\n parameter = obj( name = prm, level = lev, dataDate = date )[ timelevel ]\\n print( parameter.dataDate )\\n \\n #-----Checking grit type----------------------------------------------\\n if parameter.gridType == \\\"sh\\\":\\n lat, lon, data = sh( parameter.values )\\n elif parameter.gridType == \\\"reduced_gg\\\":\\n lat, lon = parameter.latlons() #very easy implementastion with a gg\\n lon = lon - 180. #else it only draws on half the map\\n data = parameter.values\\n elif parameter.gridType == \\\"regular_gg\\\":\\n lat, lon = parameter.latlons() #very easy implementastion with a gg\\n lon = lon - 180. #else it only draws on half the map\\n data = parameter.values\\n else: \\n print ( parameter.gridType )\\n \\n return lat, lon, data\",\n \"def plan_list_get(request):\\n return list_by_company_guid(request, PlanModel)\",\n \"def get(self):\\n return {'bills': [bill.json() for bill in BillModel.find_all()]}\",\n \"def _fetch_data(self):\\n pass\",\n \"def _get_dapall_from_api(self):\\n\\n url = marvin.config.urlmap['api']['dapall']['url']\\n\\n url_full = url.format(name=self.plateifu,\\n bintype=self.bintype.name,\\n template=self.template.name)\\n\\n try:\\n response = self._toolInteraction(url_full)\\n except Exception as ee:\\n raise MarvinError('found a problem while getting DAPall: {0}'.format(str(ee)))\\n\\n if response.results['error'] is not None:\\n raise MarvinError('found a problem while getting DAPall: {}'\\n .format(str(response.results['error'])))\\n\\n data = response.getData()\\n\\n return data['dapall_data']\",\n \"def get(self, request):\\n if 'brokerage' in request.GET:\\n portfolios = Portfolio.objects.filter(bdc_user=self.request.user, brokerage=request.GET['brokerage'])\\n else:\\n portfolios = Portfolio.objects.filter(bdc_user=self.request.user)\\n orders = Order.objects.filter(portfolio__in=portfolios).order_by('-date')\\n return Response(OrderSerializer(orders, many=True).data)\",\n \"def handle(self):\\n self.validate()\\n if self.errors:\\n raise InvalidDataException(self.errors)\\n\\n phone_number = self.data.get('phone_number')\\n month = self.data.get('month')\\n year = self.data.get('year')\\n\\n # if a period was not informed, get the current last one\\n if not month and not year:\\n year, month = last_period()\\n\\n bill_data = Bill.data_by_number_period(phone_number, month, year)\\n return bill_data\",\n \"def get_data_from_endpoint(self, from_, to_, endpoint):\\n endpoint = self.make_endpoint(endpoint)\\n from_, to_ = str(from_), str(to_)\\n payload = {\\n 'auth': self.auth_token,\\n 'id': self.monitor_id,\\n 'start': from_,\\n 'end': to_,\\n 'extendLimit': 'true',\\n 'fullContents': 'true'\\n }\\n\\n r = self.session.get(endpoint, params=payload)\\n ratelimit_remaining = r.headers['X-RateLimit-Remaining']\\n #print ('Remaining Ratelimit = ' + str(ratelimit_remaining))\\n\\n # If the header is empty or 0 then wait for a ratelimit refresh.\\n if (not ratelimit_remaining) or (float(ratelimit_remaining) < 1):\\n #print('Waiting for ratelimit refresh...')\\n sleep(self.ratelimit_refresh)\\n\\n return r\",\n \"def get_data(self, state=None, request=None):\\n raise NotImplementedError\",\n \"def fetch(self, grid):\\n with self.session as s:\\n # Recursively handle either a grid or a single bound\\n if type(grid[0]) is list:\\n with click.progressbar(grid, label='Fetching journal') as g:\\n for bound in g:\\n self.fetch(bound)\\n elif type(grid[0]) is tuple:\\n # Construct the web request from the coordinates\\n poly = ''.join(['{};{};'.format(point[0], point[1]) for point in grid])\\n payload = {\\n 'qt': 'spatial',\\n 'pts': poly,\\n 'rad': 0,\\n 'rights': 'B'\\n }\\n url = 'https://alta.registries.gov.ab.ca/SpinII/SearchTitlePrint.aspx'\\n\\n sleep(3)\\n r = s.get(url, params=payload)\\n soup = BeautifulSoup(r.content, 'html.parser')\\n\\n # Extract the table and load into a DataFrame\\n try:\\n table = soup.find('table', class_='bodyText')\\n df = pd.read_html(str(table), index_col=0, header=0, parse_dates=False)[0]\\n df['Registration Date'] = pd.to_datetime(df['Registration Date'], format='%d/%m/%Y')\\n df['Change/Cancel Date'] = pd.to_datetime(df['Change/Cancel Date'], format='%d/%m/%Y')\\n\\n self.data.append(df)\\n except:\\n pass\",\n \"def getDataContaining(self, address: ghidra.program.model.address.Address) -> ghidra.program.model.listing.Data:\\n ...\",\n \"def get(self):\\n args = parser_hms.parse_args()\\n if args['amount'] == 'all':\\n return GenericGet().get_data(args,1,False)\\n elif args['amount'] == 'nearest':\\n return GenericGet().get_data(args,1,True)\",\n \"def get(self, request, p_name, conn_name):\\n project = Project.objects.get(name=p_name)\\n connector = project.connector_set.filter(name=conn_name)\\n serializer = ConnectorSerializer(connector[0], many=False)\\n # Not modifying this as it works in tandem with the Thingworx app.\\n return Response(serializer.data)\",\n \"def calculate_demo(self, request, parent_lookup_client, pk, format=None):\\n\\n retirement_plan = self.get_object()\\n tickers = Ticker.objects.filter(~Q(state=Ticker.State.CLOSED.value))\\n portfolio = []\\n projection = []\\n for idx, ticker in enumerate(tickers[:10]):\\n percent = 0\\n if idx <= 9:\\n # 10% each for first 10 tickers\\n percent = 10\\n portfolio.append([ticker.id, percent])\\n # grab 50 evenly spaced time points between dob and current time\\n today = timezone.now().date()\\n last_day = retirement_plan.client.date_of_birth + relativedelta(years=retirement_plan.selected_life_expectancy)\\n day_interval = (last_day - today) / 49\\n income_start = 20000\\n assets_start = 100000\\n for i in range(50):\\n income = income_start + (i * 50)\\n assets = assets_start + (i * 1000)\\n dt = today + i * day_interval\\n projection.append([d2ed(dt), assets, income])\\n return Response({'portfolio': portfolio, 'projection': projection})\",\n \"def object_get(self, request):\\n _view = _object_view(self, request)\\n queried = ObjectPostings(self.cdb_object_id, request.params.mixed()).query()\\n postings = [request.view(obj) for obj in queried[0]]\\n\\n _view.update({\\n \\\"postings\\\": postings,\\n \\\"result_complete\\\": queried[1]\\n })\\n return _view\",\n \"def get_data(self, request, url):\\n data = request.get(endpoint=url)\\n return data[0], data[1]\",\n \"def get(self):\\n args = parser_degree.parse_args()\\n if args['amount'] == 'all':\\n return GenericGet().get_data(args,0,False)\\n elif args['amount'] == 'nearest':\\n return GenericGet().get_data(args,0,True)\",\n \"def get_pronto_data():\\n download_if_needed(\\\"https://s3.amazonaws.com/pronto-data/open_data_year_one.zip\\\",\\n \\\"open_data_year_one.zip\\\")\",\n \"def get(self, bill_id):\\n try:\\n bill = BillModel.find_by_id(bill_id)\\n except:\\n return {\\\"message\\\": \\\"An error occurred finding the item.\\\"}, 500 # Internal server error\\n\\n if bill:\\n return bill.json()\\n return {'message': 'Bill not found'}, 404\",\n \"def _get_floorplans(self, url):\\n \\n try:\\n jdict = self._load_json(url)\\n floorplans_groups = jdict['props']['homeDetails']['floorPlans']['floorPlanGroups']\\n address_data = list(self._get_address(jdict))\\n rental_data = []\\n \\n # different floorplans, e.g. studio, 1 bedroom 1 bathroom etc.\\n for floorplans in floorplans_groups:\\n plans = floorplans['plans']\\n for section in plans:\\n # this is the header \\n section_data = self._get_section_data(section)\\n rental_data.append(address_data+section_data+[url])\\n units = section['units']\\n # these are all the units under that header \\n for unit in units:\\n unit_data = self._get_section_data(unit)\\n rental_data.append(address_data+unit_data+[url])\\n return rental_data\\n except:\\n return None\",\n \"def ori_data_fbi(request):\\n http = urllib3.PoolManager()\\n\\n\\n #base_url=fbi_url(request)\\n logging.Logger(base_url)\\n print('I am inside the main function')\\n # New request url\\n request_url = base_url\\n logging.Logger(request_url)\\n\\n\\n payload = http.request('GET',\\n request_url,\\n headers={\\n 'Content-Type': 'application/json',\\n 'x-api-key': creds\\n },\\n fields={\\n 'API_KEY':creds\\n }\\n )\\n\\n #*** only changing it for testing ***\\n #return request_url\\n # print(f'the type of payload is\\\\n {type(payload.data)}')\\n print(payload.data)\\n return load_into_bq(payload.data)\\n #return payload.data\",\n \"def get(request, pk=None):\\n calls = Price.objects.filter(pk=int(pk))\\n serializer = PriceSerializer(calls, many=True)\\n return Response(serializer.data, status=status.HTTP_200_OK)\",\n \"def get_data_from_web():\\n pass\",\n \"def data():\\n return volumes_fetchers.get_json_data()\",\n \"def test_companies_company_id_data_bill_credit_notes_get(self):\\n pass\",\n \"def _get_batch(self):\\n url = self._base_url + urlConfig.URLS['Project'] + '/' + self._project_id + '/batch'\\n response = apiCall.get(self._get_token(), url,self._proxy, {}, 10)\\n logging.debug(response)\\n return response\",\n \"def getDataAt(self, address: ghidra.program.model.address.Address) -> ghidra.program.model.listing.Data:\\n ...\",\n \"async def get_all_record():\\n # X_new = item.to_df()\\n # item_str = item.to_string()\\n # project_code = int(item_str[item_str.find('=')+1:])\\n pg = PostgreSQL()\\n return_json = pg.fetch_all_records()\\n return return_json\",\n \"def connect_data_api(self, endpoint):\\n\\n url = 'https://api.gdax.com' + endpoint\\n res = requests.get(url)\\n\\n if res.status_code == 200:\\n return res.json()\\n else:\\n raise ValueError(res.content)\",\n \"def get_data(self):\\n raise NotImplementedError(\\\"Not implemented!\\\")\",\n \"def get():\",\n \"def get():\",\n \"def bcp_get(self, **kwargs):\\n pass\",\n \"def _get_consumption(self, url, start, end, aggregation):\\n start = self._to_milliseconds(start)\\n end = self._to_milliseconds(end)\\n\\n headers = {\\\"Authorization\\\": \\\"Bearer {}\\\".format(self.access_token)}\\n params = {\\n \\\"aggregation\\\": aggregation,\\n \\\"from\\\": start,\\n \\\"to\\\": end\\n }\\n r = requests.get(url, headers=headers, params=params)\\n r.raise_for_status()\\n return r.json()\",\n \"def get(self):\\n return_status = None\\n result = {}\\n try:\\n log.debug(\\\"Summary info : \\\")\\n #get the payload to influx DB\\n url = \\\"http://localhost:8086/query\\\"\\n querystring = {\\\"pretty\\\": \\\"true\\\", \\\"db\\\": \\\"IOT\\\",\\n \\\"q\\\": sql }\\n response = requests.request(\\\"GET\\\", url, params=querystring)\\n r_d=json.loads(response.text)\\n result_d=[]\\n for rec in r_d['results'][0]['series']:\\n for element in rec['values']:\\n temp_d={}\\n temp_d.update(rec['tags'])\\n temp_d.update(dict(zip(rec['columns'],element)))\\n result_d.append(temp_d)\\n result['status'] = 1\\n result['message']=result_d\\n return_status = 200\\n except ValueError as e:\\n result = {}\\n log.exception('Value Exception while fetching aggregate data')\\n result['status'] = 0\\n return_status = 400\\n result['message'] = e.args[0]\\n except :\\n result = {}\\n log.exception('Exception while aggregating the data')\\n return_status = 500\\n result['status'] = 0\\n result['message'] = 'Internal Error has occurred while fetching aggregate data'\\n finally:\\n resp = Response(json.dumps(result), status=return_status, mimetype=\\\"application/json\\\")\\n return resp\",\n \"def get(self):\\n return self.get_data()\",\n \"def get_data(self, url):\\n return self.get(url).get('data', [])\",\n \"def get(cls, plan_id):\\n return cls().requests.get(f\\\"plan/{plan_id}\\\")\",\n \"def get_invoice(payload):\\n response = requests.post(url, data=payload)\\n return response.json()\",\n \"def get(self, request):\\n source = request.GET.get(\\\"source\\\", \\\"BLR\\\")\\n destination = request.GET.get(\\\"destination\\\", \\\"DEL\\\")\\n dateofdeparture = request.GET.get(\\\"date_of_departure\\\", \\\"20191027\\\")\\n resp = get_flights(source, destination, dateofdeparture)\\n return Response(resp)\",\n \"def get_estimate(start_lat, start_lon, end_lat, end_lon, token):\\n endpoint = \\\"https://api.uber.com/v1/estimates/price\\\"\\n params = {\\n 'start_latitude': start_lat,\\n 'start_longitude': start_lon,\\n 'end_latitude': end_lat,\\n 'end_longitude': end_lon,\\n 'server_token': token\\n }\\n r = requests.get(endpoint, params=params)\\n r.raise_for_status()\\n return r.json().pop('prices', [])\",\n \"def get_raw_mercadopago_info():\\n mercadopago_client_id = os.getenv('MERCADOPAGO_CLIENT_ID')\\n mercadopago_client_secret = os.getenv('MERCADOPAGO_CLIENT_SECRET')\\n\\n mp = MP(mercadopago_client_id, mercadopago_client_secret)\\n logger.debug('Connecting with mercadopago')\\n\\n filters = {'status': 'approved'}\\n offset = 0\\n results = []\\n while True:\\n response = mp.search_payment(filters, limit=LIMIT, offset=offset)\\n assert response['status'] == 200\\n logger.debug(\\n 'Getting response from mercadopago, paging %s', response['response']['paging'])\\n results.extend(response['response']['results'])\\n if len(response['response']['results']) < LIMIT:\\n break\\n offset += LIMIT\\n\\n logger.info('Got response from mercadopago, %d items', len(results))\\n return results\",\n \"def get_amount():\\n conn = None\\n try:\\n params = config()\\n conn = psycopg2.connect(**params)\\n cur = conn.cursor()\\n\\n #tas\\n raw={}\\n raw['plan']={}\\n raw['actual']={}\\n\\n cur.execute(\\\"SELECT slc.*,plc.amount as amount_plan,ppm.amount as price \\\\\\n ,to_char((slc.amount*ppm.amount)/aco.amount_actual_coal,'999.999') as cost_actual \\\\\\n , to_char((plc.amount*ppm.amount)/aco.amount_actual_coal,'999.999') as cost_plan \\\\\\n ,aco.amount_actual_coal \\\\\\n FROM vw_tta_cps_sum_land_clearing_now AS slc \\\\\\n LEFT JOIN vw_tta_cps_price_per_month AS ppm \\\\\\n ON slc.int_month=ppm.month \\\\\\n AND slc.year_id=ppm.year_id \\\\\\n LEFT JOIN vw_tta_cps_plan_land_clearing AS plc \\\\\\n ON slc.periode_month_id=plc.periode_month_id \\\\\\n AND slc.land_clearing_location_id=plc.land_clearing_location_id \\\\\\n LEFT JOIN vw_tta_cps_sr_all_per_month_plan_actual as aco \\\\\\n ON aco.int_month=slc.int_month \\\\\\n WHERE ppm.jenis_price=10 \\\\\\n AND aco.plan_id=1\\\")\\n rowcount=cur.rowcount\\n print(\\\"The number of row: \\\", rowcount)\\n row = cur.fetchone()\\n counter=0\\n item={}\\n\\n if rowcount>0:\\n f=open('../../data_cost_per_ton.csv','w')\\n f.write('AREA,PLAN,ACTUAL\\\\n')\\n while row is not None:\\n #print(row)\\n raw[\\\"plan\\\"]=row[11]\\n raw[\\\"actual\\\"]=row[10]\\n f.write(str('RAW')+','+str(raw[\\\"plan\\\"])+','+str(raw[\\\"actual\\\"])+\\\"\\\\n\\\")\\n\\n row = cur.fetchone()\\n\\n if rowcount>0:\\n f.close()\\n cur.close()\\n\\n print(str(datetime.datetime.now())+' '+str(rowcount)+' row updated')\\n except (Exception, psycopg2.DatabaseError) as error:\\n print(str(datetime.datetime.now())+' '+str(error))\\n finally:\\n if conn is not None:\\n conn.close()\",\n \"def get_details(self):\",\n \"def get_data(self):\\n data_obj = VerticaGetter()\\n if self.context_name == 'PARTS':\\n param_list = [self.start_date,self.end_date,self.param_name]\\n param_list = [str(elem) for elem in param_list]\\n res = data_obj.get_visitor_analysis(param_list)\\n else:\\n res = data_obj.get_visitor_analysis()\\n return res\",\n \"def listings_data():\\n\\n stmt = db.session.query(nyc).statement\\n df = pd.read_sql_query(stmt, db.session.bind)\\n df[\\\"latitude\\\"] = pd.to_numeric(df[\\\"latitude\\\"])\\n df[\\\"longitude\\\"] = pd.to_numeric(df[\\\"longitude\\\"])\\n df[\\\"accommodates\\\"] = pd.to_numeric(df[\\\"accommodates\\\"])\\n\\n data = df.to_dict(orient='index')\\n # Create a dictionary entry for each row of metadata information\\n # data = {}\\n # for result in results:\\n #\\n # data[\\\"ID\\\"] = result[0]\\n # data[\\\"LISTING_URL\\\"] = result[1]\\n # data[\\\"NAME\\\"] = result[2]\\n # data[\\\"HOST_ID\\\"] = result[3]\\n # data[\\\"NEIGHBORHOOD\\\"] = result[4]\\n # data[\\\"NEIGHBORHOOD_GROUP\\\"] = result[5]\\n # data[\\\"CITY\\\"] = result[6]\\n # data[\\\"ZIPCODE\\\"] = result[7]\\n # data[\\\"LAT\\\"] = float(result[8])\\n # data[\\\"LON\\\"] = float(result[9])\\n #\\n # print(data)\\n\\n return jsonify(data)\",\n \"def getPanchayatsAccurateData(request):\\n if request.method == 'GET':\\n panchayat=request.GET.get('panchayat', '')\\n ptid=request.GET.get('ptid', '')\\n block = request.GET.get('block', '')\\n bid = request.GET.get('bid', '')\\n district = request.GET.get('district', '')\\n state = request.GET.get('state', '')\\n limit=request.GET.get('limit', '')\\n if limit == '':\\n limit=500\\n else:\\n limit=int(limit)\\n #PTID we need to make it exact. Finyaer make it current finyear\\n panchayats = PanchayatStat.objects.filter(panchayat__name__icontains = panchayat, panchayat__id__icontains = ptid, panchayat__block__id__icontains = bid, panchayat__block__name__icontains=block, panchayat__block__district__name__icontains = district, panchayat__block__district__state__name__icontains = state, workDaysAccuracyIndex__gte = 90, finyear = '17')\\n\\n\\n panchayats = panchayats[:limit]\\n serializer = PanchayatStatSerializer(panchayats, many=True)\\n return JsonResponse(serializer.data, safe=False)\",\n \"def get_data(rics: list, fields: list):\\n data, err = ek.get_data(rics, fields)\\n if err:\\n print(err)\\n return data\",\n \"def get_monthly_prism_ppt_data(year,month, plotPPTBounds):\\n \\\"\\\"\\\" It is in the form of grid \\\"\\\"\\\"\\n \\n if(month<10):\\n prism_file_path = \\\"PRISM_ppt_stable_4kmM3_\\\"+str(year)+\\\"0\\\"+str(month)+\\\"_bil.bil\\\"\\n else:\\n prism_file_path = \\\"PRISM_ppt_stable_4kmM3_\\\"+str(year)+str(month)+\\\"_bil.bil\\\" \\n \\n ppt_data = read_prism_bil(join(cf.root, cf.prism_dir, prism_file_path))\\n \\n hdr_dict = read_prism_hdr(join(cf.root, cf.prism_dir, prism_file_path).replace('.bil', '.hdr'))\\n \\n hdr_dict[\\\"ULXMAP\\\"] = float(hdr_dict[\\\"ULXMAP\\\"])\\n hdr_dict[\\\"ULYMAP\\\"] = float(hdr_dict[\\\"ULYMAP\\\"])\\n hdr_dict['NROWS'] = int(hdr_dict['NROWS'])\\n hdr_dict['NCOLS'] = int(hdr_dict['NCOLS'])\\n hdr_dict['XDIM'] = float(hdr_dict['XDIM'])\\n hdr_dict['YDIM'] = float(hdr_dict['YDIM'])\\n \\n p1 = (hdr_dict[\\\"ULXMAP\\\"] - (hdr_dict['XDIM']/2), \\n hdr_dict[\\\"ULYMAP\\\"] + (hdr_dict['YDIM']/2))\\n\\n p2 = (p1[0] + (hdr_dict['NCOLS']*hdr_dict['XDIM']),\\n p1[1])\\n\\n p3 = (p2[0],\\n p2[1] - (hdr_dict['NROWS']*hdr_dict['YDIM']))\\n\\n p4 = (p1[0],\\n p3[1])\\n \\n lon_point_list = (p1[0], p2[0], p3[0], p4[0])\\n lat_point_list = (p1[1], p2[1], p3[1], p4[1])\\n \\n ppt_bounds = Polygon(zip(lon_point_list, lat_point_list))\\n \\n if(plotPPTBounds):\\n crs = {'init': 'epsg:4326'}\\n m = folium.Map(zoom_start=10, tiles='cartodbpositron')\\n polygon = gpd.GeoDataFrame(index=[0], crs=crs, geometry=[ppt_bounds]) \\n \\n folium.GeoJson(polygon).add_to(m)\\n folium.LatLngPopup().add_to(m)\\n m.save(\\\"Prism Bounds.html\\\")\\n\\n return ppt_bounds, ppt_data, hdr_dict\",\n \"def query_api(location):\\n #bearer_token = obtain_bearer_token(API_HOST, TOKEN_PATH)\\n bearer_token ='SHdrjUqMJXqXBKUc7bGIplM8y6tnbwZbXXDbWPCd9wWMP8tX9PdJrC5MZHwJRhb7jMtLjXxT-hsWjNf2OkdiDWd30HsS84AVI5iRnrpxkak3HbWXAdUKvraQ_wgXWXYx'\\n response = transaction_search(bearer_token,location)\\n response = response.get('businesses')\\n return response\",\n \"def _offset_call(self, url, params) -> Dict:\\n response = self._get(url, params=params)\\n raise_on_error(response)\\n return response.json()\",\n \"def precipitation():\\n # Calculate the date 1 year ago from the last data point in the database\\n #Create our session (link) from Python to the DB\\n session = Session(engine)\\n\\n # Use query from notebook. Get the last date in database, then calc a year before \\n last_date = session.query(func.max(Measurement.date)).first() \\n year_ago = dt.date(2017, 8, 23) - dt.timedelta(days=365)\\n # filter to one year ago \\n twelve_months_precip = session.query(Measurement.date, Measurement.prcp).filter(Measurement.date >= year_ago).all()\\n\\n session.close()\\n\\n # create a list for results to jsonify \\n\\n list_data = []\\n for months in twelve_months_precip:\\n data = {}\\n data[\\\"date\\\"] = months[0]\\n data[\\\"prcp\\\"] = months[1]\\n list_data.append(data)\\n\\n # jsonify the results \\n\\n return jsonify(list_data)\",\n \"def getPTData(*args):\\n return args[0].Data.PTData.pt_data\",\n \"def GetGeData(self, *args, **kwargs):\\n pass\",\n \"async def get_record(item: Item):\\n X_new = item.to_df()\\n item_str = item.to_string()\\n project_code = int(item_str[item_str.find('=')+1:])\\n pg = PostgreSQL()\\n return_json = pg.fetch_query_given_project(project_code)\\n return return_json\",\n \"def getReport(request):\\n\\n\\t#parameters needed for different REST API's\\n\\tparams = {\\n\\t\\t'rid':-1,\\n\\t\\t'year':-1,\\n\\t\\t'con_num':-1,\\n\\t\\t'assign_num':-1,\\n\\t\\t'item_num':-1,\\n\\t\\t'wtype': -1,\\n\\t\\t'payno': -1,\\n\\t\\t'snap': 0, #default is 0 for snapshots (for now)\\n\\t\\t'issue_date': -1,\\n\\t}\\n\\n\\t#loop over the parameters and set them if they appear in the api url\\n\\tfor p in params:\\n\\t\\tif p in request.GET:\\n\\t\\t\\tparams[p] = request.GET[p]\\n\\n\\n\\t#get the request session and load data\\n\\ts = requests.Session()\\n\\tif not isinstance(rgen.ReportGenerator.get_url(params), dict):\\n\\t\\tresponse = s.get(rgen.ReportGenerator.get_url(params))\\n\\n\\t\\t#set the iterator and the content\\n\\t\\tit = json.loads(response.content)\\n\\t\\tcontent = json.loads(response.content)\\n\\t\\t\\n\\t\\t#while a next page exists, parse the api\\n\\t\\tpageNum = 1\\n\\t\\twhile \\\"next\\\" in it:\\n\\t\\t\\tresponse = s.get(rgen.ReportGenerator.get_url(params) + '?page=' + str(pageNum))\\n\\t\\t\\tit = json.loads(response.content)\\n\\t\\t\\tcontent[\\\"items\\\"].extend(it[\\\"items\\\"])\\n\\t\\t\\tpageNum += 1\\n\\n\\telse:\\n\\t\\t#if the url is a list\\n\\t\\tcontent = {}\\n\\t\\tfor part in rgen.ReportGenerator.get_url(params):\\n\\t\\t\\tresponse = s.get(rgen.ReportGenerator.get_url(params)[part])\\n\\t\\t\\tit = json.loads(response.content)\\n\\t\\t\\t#content = {\\\"part1\\\":{\\\"items\\\":[]}, \\\"part2\\\":{\\\"items\\\":[]}, \\\"part3\\\":{\\\"items\\\":[]}}\\n\\t\\t\\t\\n\\t\\t\\tcontent[part] = {}\\n\\t\\t\\tcontent[part][\\\"items\\\"] = []\\n\\t\\t\\tcontent[part][\\\"items\\\"].extend(it[\\\"items\\\"])\\n\\n\\t\\t\\tpageNum = 1\\n\\t\\t\\twhile \\\"next\\\" in it:\\n\\t\\t\\t\\tresponse = s.get(rgen.ReportGenerator.get_url(params)[part] + '?page=' + str(pageNum))\\n\\t\\t\\t\\tit = json.loads(response.content)\\n\\t\\t\\t\\tcontent[part][\\\"items\\\"].extend(it[\\\"items\\\"])\\n\\t\\t\\t\\tpageNum += 1\\n\\t\\n\\t#set the file object to be returned as a download\\n\\tfile = HttpResponse(rgen.ReportGenerator.formExcel(content, params), content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')\\n\\tif params[\\\"rid\\\"] == '70':\\n\\t\\tfile['Content-Disposition'] = 'attachment; filename=' + rgen.r_dict[params[\\\"rid\\\"]][1] + ' No.' + params['issue_date'] + '.xlsx'\\n\\telse:\\n\\t\\tfile['Content-Disposition'] = 'attachment; filename=' + rgen.r_dict[params[\\\"rid\\\"]][1] + '.xlsx'\\n\\ts.close()\\n\\treturn file\",\n \"def _get(self, path, params=None):\\n return self._api.get_json(path, headers={\\\"Hawkular-Tenant\\\": self.tenant_id}, params=params)\",\n \"def get_data(self, lat=53.3498, lon=-6.2603):\\n r = requests.get(\\n f\\\"https://api.openweathermap.org/data/2.5/onecall?lat={lat}&lon={lon}&appid=92fb08f48a98e0f39b990060352ffebe\\\")\\n return r.text\",\n \"def getData(self, local_cache):\",\n \"def get_floor_plan(port_id):\\n url = 'https://api.archisketch.com/v1/public/projects/'\\n response = requests.get(url + port_id + '/detail')\\n response = response.json()['project']\\n floor_plan = response['floorplans'][0]\\n return floor_plan\",\n \"def get(self, request, unit_id):\\n start_date = get_start_date(request)\\n end_date = get_end_date(request)\\n readings = MeterReading.objects.filter(\\n unit=unit_id,\\n date__gte=start_date,\\n date__lte=end_date,\\n reading_type='GAS'\\n )\\n serializer = MeterReadingSerializer(readings, many=True)\\n return Response(serializer.data)\",\n \"def fetch_data(self):\\n\\n data_dict = {\\n 'price': self.get_current_price(),\\n }\\n\\n return self.save_data(data_dict)\",\n \"def data():\\n columns = request.form.getlist('columns')\\n regions = request.form.getlist('fieldsArr')\\n #print(regions)\\n #for the visualization step, a copy of the 'RAW' regions.\\n raw_regions = regions\\n\\n regions = regions[0].split(',')\\n\\n #catch if region is empty, should not be if the client hasn't modified\\n #client side code\\n reg_len = len(regions)\\n if reg_len == 1:\\n regions = ['AUS_CODE_2016,036']\\n raw_regions = 'AUS_CODE_2016,036'\\n #regions are split into a list and columns are a list, time to enfore\\n # limits! up to 100 columns by 1000 cells max!\\n if len(columns) > 10:\\n columns = columns[:10]\\n\\n #extra 1 for the regions code yet to be extracted\\n if len(regions) > 1001:\\n regions = regions[:1001]\\n\\n area = regions[0]\\n\\n #check for no slected data itme and return a total pop count\\n col_len = len(columns)\\n if col_len == 0:\\n columns.append('Tot_P_P')\\n\\n # bigly work,\\n r_data = query_proc.table_query(regions, columns)\\n\\n columns.insert(0, area)\\n columns.insert(0, \\\"Census 2016 Name\\\")\\n\\n return render_template('data.html',\\n title='Data from the map',\\n data=r_data,\\n columns=columns,\\n raw_regions=raw_regions)\",\n \"def get(self, data):\\n pass\",\n \"def mapping(self):\\n return self.request('_mapping', pylastica.request.Request.GET).data\",\n \"def call(self, endpoint: str = \\\"\\\", query: dict = dict(), method: str = \\\"GET\\\",\\n unit: bool = True) -> dict:\\n query.update({'apikey': self.api_key, 'lat': self.coords[0], 'lon': self.coords[1]})\\n if unit:\\n query['unit_system'] = self.unit_system\\n resp = requests.request(\\n url=self.base_url + endpoint,\\n method=method,\\n params=query\\n )\\n if not resp.ok:\\n raise e.ClimaAPIError(resp)\\n return resp.json()\",\n \"def get_data(radius: int, user_zip_code: str, state_dict: dict,\\n provider_filter: list) -> list:\\n # zip_map_dict = create_zip_dict()\\n active_set = active_providers(state_dict['metadata']['provider_brands'])\\n in_range_lst = create_in_range_lst(state_dict['features'],\\n user_zip_code, radius,\\n active_set, False, provider_filter)\\n return create_message_list(in_range_lst, user_zip_code)\",\n \"def index(self):\\n args = index_reqparse.parse_args()\\n args.api_key = \\\"8l3xbEmsQMq7AG7mXoSy3IuJAqehmWGRC754Otx7\\\"\\n\\n url = 'http://api.data.gov/gsa/fbopen/v0/opps?%s' % urlencode(query=args)\\n\\n return json.loads(urlopen(url=url).read())\",\n \"def get_entity_data(self, instance_id = None):\\n # Typically, this url is better, becuase we can insert parameters into url in a proper way\\n # original url is 'https://api.ci.ai.dynamics.com/v1/instances/{instanceId}/data/{relativePath}[?forceSearch][&proxy]'\\n # but we don't need optional parameters, so we delete them from full url\\n url_original = 'https://api.ci.ai.dynamics.com/v1/instances/{instanceId}/data/{relativePath}'\\n # it seems {} only part of python sting format, so we only use string.format(value1, value2,..) to replace it \\n url_parse = url_original.format(instanceId = self.INSTANCEID, relativePath = self.RELATIVEPATH)\\n # it seems sometimes url with parameters not working, so we provide a fulfuiled url \\n url_full = 'https://api.ci.ai.dynamics.com/v1/instances/c910b061-1008-4397-95f6-4e7b443b924a/data/RetailDemoData_RetailSystem_Contacts'\\n \\n # send get request with \\n response = requests.get(url_parse, headers=self.HEADERS)\\n # r2 = requests.get(url_full, headers=self.HEADERS)\\n print(response)\\n # for record in r3.json():\\n # print(json.dumps(record))\\n # according to json file structore, our data contain in ['value']\\n # response.json()['value']\\n # for row in r3.json()['value']:\\n # print(json.dumps(row))\\n # we can try to storage data into a local directory,\\n # these only work for local python script, not on AZURE runbook\\n # with open('03_data/32_entity.json', 'w') as outfile:\\n # json.dump(r3.json()['value'], outfile)\\n\\n return response.json()['value']\",\n \"def get(self, base_url, observable, limit, credentials):\\n\\n url = url_join(base_url, self.filter(observable)) + f'&$top={limit}'\\n\\n response = get_data(url, credentials)\\n\\n return [\\n self.sighting(observable, x) for x in response.get('value', [])\\n ]\",\n \"def get(self):\\n\\n bill = {\\n 'product': {\\n 'name': self.order.product.name,\\n 'price': self.order.product.price\\n },\\n 'order_date_of_creation': self.order.date_of_creation,\\n 'bill_date_of_creation': timezone.now(),\\n 'discounts': [],\\n 'total': self.order.product.price\\n }\\n\\n return self.add_discount(bill)\",\n \"def _get_data(self, url: str)->dict:\\n data = None\\n resp = self._get(url)\\n if resp:\\n data = resp.json()['data']\\n return data\",\n \"def apicall():\\r\\n# try:\\r\\n print request.get_json()\\r\\n test_json = request.get_json()\\r\\n logger.info(\\\"input json object loaded\\\")\\r\\n logger.info(test_json)\\r\\n k=MetaData(test_json)\\r\\n int_res=k.getData()\\r\\n print '------------------------------'\\r\\n print int_res\\r\\n return jsonify(int_res)\",\n \"def get_data(ts_code: int, begin: str, end: str) -> List:\\n\\n url = (\\n \\\"http://api.bcb.gov.br/dados/serie/bcdata.sgs.{}\\\"\\n \\\"/dados?formato=json&dataInicial={}&dataFinal={}\\\"\\n )\\n request_url = url.format(ts_code, begin, end)\\n response = requests.get(request_url)\\n return response.json()\",\n \"def main():\\n #bearer_token = obtain_bearer_token(API_HOST, TOKEN_PATH)\\n bearer_token ='SHdrjUqMJXqXBKUc7bGIplM8y6tnbwZbXXDbWPCd9wWMP8tX9PdJrC5MZHwJRhb7jMtLjXxT-hsWjNf2OkdiDWd30HsS84AVI5iRnrpxkak3HbWXAdUKvraQ_wgXWXYx'\\n response = transaction_search(bearer_token, '1910 Entrepreneur Dr, Raleigh, NC 27518')\\n response = response.get('businesses')\\n print(json.dumps(response, indent=4))\",\n \"def get(self, *args, **kwargs) -> Any:\\n return self.raw_data.get(*args, **kwargs)\",\n \"def get_claim_bill(\\n _db: Session = db, *, start: datetime = None, end: datetime = None,\\n store_internal_id: int = None, owner_id: int = None,\\n kind: models.ClaimKind = None, calculation: CalcType = \\\"avg\\\"\\n):\\n query = crud.claim.get_query(_db)\\n if start and end:\\n query = query.filter(models.Claim.created_at.between(start, end))\\n if store_internal_id:\\n query = query.filter(models.Claim.store_internal_id == store_internal_id)\\n if owner_id:\\n query = query.filter(models.Claim.owner_id == owner_id)\\n if kind:\\n query = query.filter(models.Claim.kind == kind)\\n bill = query.with_entities(getattr(func, calculation)(models.Claim.bill).label(\\\"_bill\\\")).first()\\n bill_round = round(bill[0], 2) if bill[0] is not None else 0.00\\n return bill_round\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6360357","0.6014319","0.59525716","0.5819394","0.5776328","0.57017654","0.5693053","0.56899124","0.5679887","0.5679887","0.5679887","0.56725025","0.56725025","0.5663544","0.5658554","0.5646016","0.56169564","0.5605687","0.5596649","0.5570589","0.5530671","0.55145097","0.5502198","0.5497323","0.548008","0.5475051","0.54735523","0.545327","0.54267776","0.5414057","0.53767276","0.537473","0.53490686","0.5327744","0.53263485","0.5318045","0.5315238","0.53121483","0.5309047","0.5302879","0.52997714","0.5293017","0.52893126","0.5284566","0.52675885","0.5267583","0.5244594","0.52374876","0.5236168","0.52358997","0.52304167","0.5227862","0.5225517","0.5224484","0.5224484","0.5219283","0.52080905","0.51961976","0.5192172","0.51918435","0.5190948","0.5183728","0.51824766","0.5179246","0.5161987","0.51476425","0.51469666","0.51445967","0.51399916","0.51346385","0.51323247","0.51308113","0.51221496","0.51155484","0.51108056","0.51085526","0.5107533","0.5098758","0.50983804","0.5093868","0.50929487","0.50915706","0.509095","0.5089983","0.5085026","0.5081053","0.5080668","0.50795496","0.50769264","0.5075166","0.50711375","0.5068888","0.5068731","0.5064039","0.50628066","0.5060558","0.5053803","0.5052109","0.5051208","0.50510263"],"string":"[\n \"0.6360357\",\n \"0.6014319\",\n \"0.59525716\",\n \"0.5819394\",\n \"0.5776328\",\n \"0.57017654\",\n \"0.5693053\",\n \"0.56899124\",\n \"0.5679887\",\n \"0.5679887\",\n \"0.5679887\",\n \"0.56725025\",\n \"0.56725025\",\n \"0.5663544\",\n \"0.5658554\",\n \"0.5646016\",\n \"0.56169564\",\n \"0.5605687\",\n \"0.5596649\",\n \"0.5570589\",\n \"0.5530671\",\n \"0.55145097\",\n \"0.5502198\",\n \"0.5497323\",\n \"0.548008\",\n \"0.5475051\",\n \"0.54735523\",\n \"0.545327\",\n \"0.54267776\",\n \"0.5414057\",\n \"0.53767276\",\n \"0.537473\",\n \"0.53490686\",\n \"0.5327744\",\n \"0.53263485\",\n \"0.5318045\",\n \"0.5315238\",\n \"0.53121483\",\n \"0.5309047\",\n \"0.5302879\",\n \"0.52997714\",\n \"0.5293017\",\n \"0.52893126\",\n \"0.5284566\",\n \"0.52675885\",\n \"0.5267583\",\n \"0.5244594\",\n \"0.52374876\",\n \"0.5236168\",\n \"0.52358997\",\n \"0.52304167\",\n \"0.5227862\",\n \"0.5225517\",\n \"0.5224484\",\n \"0.5224484\",\n \"0.5219283\",\n \"0.52080905\",\n \"0.51961976\",\n \"0.5192172\",\n \"0.51918435\",\n \"0.5190948\",\n \"0.5183728\",\n \"0.51824766\",\n \"0.5179246\",\n \"0.5161987\",\n \"0.51476425\",\n \"0.51469666\",\n \"0.51445967\",\n \"0.51399916\",\n \"0.51346385\",\n \"0.51323247\",\n \"0.51308113\",\n \"0.51221496\",\n \"0.51155484\",\n \"0.51108056\",\n \"0.51085526\",\n \"0.5107533\",\n \"0.5098758\",\n \"0.50983804\",\n \"0.5093868\",\n \"0.50929487\",\n \"0.50915706\",\n \"0.509095\",\n \"0.5089983\",\n \"0.5085026\",\n \"0.5081053\",\n \"0.5080668\",\n \"0.50795496\",\n \"0.50769264\",\n \"0.5075166\",\n \"0.50711375\",\n \"0.5068888\",\n \"0.5068731\",\n \"0.5064039\",\n \"0.50628066\",\n \"0.5060558\",\n \"0.5053803\",\n \"0.5052109\",\n \"0.5051208\",\n \"0.50510263\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.59895027"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":7295,"cells":{"query":{"kind":"string","value":"Get budget billing data"},"document":{"kind":"string","value":"async def __getBBL_async(self, account, projectedBillData) -> dict:\n _LOGGER.info(\"Getting budget billing data\")\n data = {}\n\n try:\n async with async_timeout.timeout(TIMEOUT):\n response = await self.session.get(\n URL_BUDGET_BILLING_PREMISE_DETAILS.format(account=account)\n )\n if response.status == 200:\n r = (await response.json())[\"data\"]\n dataList = r[\"graphData\"]\n\n # startIndex = len(dataList) - 1\n\n billingCharge = 0\n budgetBillDeferBalance = r[\"defAmt\"]\n\n projectedBill = projectedBillData[\"projected_bill\"]\n asOfDays = projectedBillData[\"as_of_days\"]\n\n for det in dataList:\n billingCharge += det[\"actuallBillAmt\"]\n\n calc1 = (projectedBill + billingCharge) / 12\n calc2 = (1 / 12) * (budgetBillDeferBalance)\n\n projectedBudgetBill = round(calc1 + calc2, 2)\n bbDailyAvg = round(projectedBudgetBill / 30, 2)\n bbAsOfDateAmt = round(projectedBudgetBill / 30 * asOfDays, 2)\n\n data[\"budget_billing_daily_avg\"] = bbDailyAvg\n data[\"budget_billing_bill_to_date\"] = bbAsOfDateAmt\n\n data[\"budget_billing_projected_bill\"] = float(projectedBudgetBill)\n\n async with async_timeout.timeout(TIMEOUT):\n response = await self.session.get(\n URL_BUDGET_BILLING_GRAPH.format(account=account)\n )\n if response.status == 200:\n r = (await response.json())[\"data\"]\n data[\"bill_to_date\"] = float(r[\"eleAmt\"])\n data[\"defered_amount\"] = float(r[\"defAmt\"])\n except Exception as e:\n _LOGGER.error(e)\n\n return data"},"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 GetCampaignBudget(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def budget(self):\n return self._budget","def billing_info(self):\r\n return BillingInfo(self)","def view_budgets(self) -> None:\n Menu.prompt_view_budgets()\n for budget in self.user.budget_manager:\n print(f\"{budget}\\n\")","def get_budgets(self) -> list:\n return self.budget_manager.get_budgets()","def get_budgets(self) -> list:\n return list(self.budgets.values())","def billing(self):\n return self._billing","def billing_info(self):\n return self._billing_info","def get_budget(self, category: BudgetCategory) -> Budget:\n return self.budgets.get(category, None)","def get_spend_by_campaign_custom(self, budget_id, aw_account_id):\n try:\n budget = Budget.objects.get(id=budget_id)\n google_ads_account = DependentAccount.objects.get(id=aw_account_id)\n except (Budget.DoesNotExist, DependentAccount.DoesNotExist):\n return\n\n client = get_client()\n client.client_customer_id = google_ads_account.dependent_account_id\n\n aw_campaigns = budget.aw_campaigns.filter(account=google_ads_account)\n aw_campaign_ids = list(set([aw_campaign.campaign_id for aw_campaign in aw_campaigns]))\n\n report_downloader = client.GetReportDownloader(version=settings.API_VERSION)\n\n campaign_report_selector = {\n 'fields': ['Cost', 'CampaignId', 'CampaignStatus', 'CampaignName', 'Labels', 'Impressions'],\n 'predicates': [\n {\n 'field': 'Cost',\n 'operator': 'GREATER_THAN',\n 'values': '0'\n },\n {\n 'field': 'CampaignId',\n 'operator': 'IN',\n 'values': aw_campaign_ids\n }\n ]\n }\n\n campaign_report_query = {\n 'reportName': 'CAMPAIGN_PERFORMANCE_REPORT',\n 'dateRangeType': 'CUSTOM_DATE',\n 'reportType': 'CAMPAIGN_PERFORMANCE_REPORT',\n 'downloadFormat': 'CSV',\n 'selector': campaign_report_selector\n }\n\n start_date = budget.start_date\n end_date = budget.end_date\n\n campaign_report_selector['dateRange'] = {\n 'min': start_date.strftime('%Y%m%d'),\n 'max': end_date.strftime('%Y%m%d')\n }\n\n campaign_report = Reporting.parse_report_csv_new(report_downloader.DownloadReportAsString(campaign_report_query))\n for campaign_row in campaign_report:\n print(campaign_row)\n campaign_id = campaign_row['campaign_id']\n campaign, created = Campaign.objects.get_or_create(campaign_id=campaign_id, account=google_ads_account)\n campaign.campaign_name = campaign_row['campaign']\n campaign.save()\n campaign_spend_object, created = CampaignSpendDateRange.objects.get_or_create(campaign=campaign,\n start_date=start_date,\n end_date=end_date)\n\n campaign_spend_object.spend = int(campaign_row['cost']) / 1000000\n campaign_spend_object.save()\n\n yest_campaign_report_selector = {\n 'fields': ['Cost', 'CampaignId', 'CampaignStatus', 'CampaignName', 'Labels', 'Impressions'],\n 'predicates': [\n {\n 'field': 'Cost',\n 'operator': 'GREATER_THAN',\n 'values': '0'\n },\n {\n 'field': 'CampaignId',\n 'operator': 'IN',\n 'values': aw_campaign_ids\n }\n ]\n }\n\n yest_campaign_report_query = {\n 'reportName': 'CAMPAIGN_PERFORMANCE_REPORT',\n 'dateRangeType': 'CUSTOM_DATE',\n 'reportType': 'CAMPAIGN_PERFORMANCE_REPORT',\n 'downloadFormat': 'CSV',\n 'selector': yest_campaign_report_selector\n }\n\n start_date = budget.start_date\n yest_end_date = datetime.datetime.now() - datetime.timedelta(1)\n\n yest_campaign_report_selector['dateRange'] = {\n 'min': start_date.strftime('%Y%m%d'),\n 'max': yest_end_date.strftime('%Y%m%d')\n }\n\n campaign_report = Reporting.parse_report_csv_new(\n report_downloader.DownloadReportAsString(yest_campaign_report_query))\n for campaign_row in campaign_report:\n campaign_id = campaign_row['campaign_id']\n campaign, created = Campaign.objects.get_or_create(campaign_id=campaign_id, account=google_ads_account)\n campaign.campaign_name = campaign_row['campaign']\n campaign.save()\n campaign_spend_object, created = CampaignSpendDateRange.objects.get_or_create(campaign=campaign,\n start_date=start_date,\n end_date=end_date)\n\n campaign_spend_object.spend_until_yesterday = int(campaign_row['cost']) / 1000000\n campaign_spend_object.save()\n\n # try:\n # campaign_report = \\\n # Reporting.parse_report_csv_new(report_downloader.DownloadReportAsString(yest_campaign_report_query))[0]\n # except IndexError:\n # return\n #\n # campaign_spend_object, created = CampaignSpendDateRange.objects.get_or_create(campaign=campaign,\n # start_date=budget.start_date,\n # end_date=budget.end_date)\n #\n # campaign_spend_object.spend_until_yesterday = int(campaign_report['cost']) / 1000000\n # campaign_spend_object.save()\n\n return 'get_spend_by_campaign_custom'","def get_expenses(budget):\n return sum(expense['bgt'] for expense in budget['spend'])","def get(self):\n\n bill = {\n 'product': {\n 'name': self.order.product.name,\n 'price': self.order.product.price\n },\n 'order_date_of_creation': self.order.date_of_creation,\n 'bill_date_of_creation': timezone.now(),\n 'discounts': [],\n 'total': self.order.product.price\n }\n\n return self.add_discount(bill)","def budget_name(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"budget_name\")","async def future_budget(budget: Budget):\n\n # Get the JSON object from the request body and cast it to a dictionary\n input_dict = budget.to_dict()\n bank_account_id = input_dict['bank_account_id']\n monthly_savings_goal = input_dict['monthly_savings_goal']\n\n transactions = load_user_data(bank_account_id)\n\n # instantiate the user\n user = User(transactions)\n\n # predict budget using time series model\n pred_bud = user.predict_budget()\n\n # if a fatal error was encountered while generating the budget,\n # return no budget along with the warning list\n if user.warning == 2:\n return json.dumps([None, user.warning_list])\n\n # modify budget based on savings goal\n modified_budget = user.budget_modifier(\n pred_bud, monthly_savings_goal=monthly_savings_goal)\n\n # if a fatal error was encountered while modifying the budget,\n # return no budget along with the warning list\n if user.warning == 2:\n return json.dumps([None, user.warning_list])\n\n # if a non-fatal warning was encountered in predict_budget() or\n # budget_modifier(), return the budget along with the warning list\n elif user.warning == 1:\n return json.dumps([modified_budget, user.warning_list])\n\n return modified_budget","def get_debt_state(member, limit_year, limit_month):\n if member.first_payment_year is None:\n # never paid! using registration date to start with\n yearmonths_paid = set()\n year_to_check = member.registration_date.year\n month_to_check = member.registration_date.month\n else:\n # build a set for the year/month of paid quotas\n quotas = Quota.objects.filter(member=member).all()\n yearmonths_paid = {(q.year, q.month) for q in quotas}\n\n year_to_check = member.first_payment_year\n month_to_check = member.first_payment_month\n\n # verify the limit is after member started paying\n if year_to_check == limit_year:\n if month_to_check > limit_month:\n return []\n elif year_to_check > limit_year:\n return []\n\n # build a set of all the year/month the member should have paid up to (including) the limit\n should_have_paid = set()\n while True:\n should_have_paid.add((year_to_check, month_to_check))\n year_to_check, month_to_check = increment_year_month(year_to_check, month_to_check)\n if year_to_check == limit_year:\n if month_to_check > limit_month:\n break\n elif year_to_check > limit_year:\n break\n\n return sorted(should_have_paid - yearmonths_paid)","def plan_get(request):\n company = auth_api_key(request)\n plan = get_and_check_plan(request, company)\n return plan","def budget_name(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"budget_name\")","def get_budgets(budg_path, exp_path, dates=None):\n exp_budg = data_help.read_jsonFile(budg_path)\n exp_data = data_help.read_jsonFile(exp_path)\n if dates == None:\n dates = [util.get_current_month()]\n for date in dates:\n exp_budg_keys = exp_budg.keys()\n if date not in exp_budg_keys: # check for current month to find exp categories\n print(\n f\"I have detected some data with for the month {date} that has no budget set.\")\n print(\n \"Please set the budget for this month.. or delete the data and run the program again.\")\n if len(exp_budg) != 0:\n user_in = util.get_user_input_for_chars(\n \"Would you like to the whole thing (w) or create new (n)? \", ['w', 'n'])\n\n if user_in == 'w':\n key = util.select_dict_key_using_integer(\n exp_budg, \"Please select a budget to copy: \", print_children=True, print_vals=False, \n print_child_vals=True)\n exp_budg[date] = exp_budg[key]\n elif user_in == 'n':\n exp_budg[date] = declare_new_budget(date, exp_data)\n else:\n exp_budg[date] = declare_new_budget(date, exp_data)\n\n print(f\"Your budget is now saved for {date}.\")\n\n else:\n print(f\"Your monthly budget for {date} is: \")\n\n util.print_simple_dict(exp_budg[date], print_vals=True)\n\n data_help.write_to_jsonFile(budg_path, exp_budg)\n return","def get_budget(self, names=None, zones=None, net=False, pivot=False):\n recarray = _get_budget(\n self._budget, self._zonenamedict, names=names, zones=zones, net=net\n )\n\n if pivot:\n recarray = _pivot_recarray(recarray)\n\n return recarray","def get_period_budgets(cls, now):\n limits_dict = {}\n strategies = cls.objects_visible.filter(is_distributed_evenly=True)\n strategies = cls.running(strategies)\n\n for strategy in strategies:\n limits_dict[strategy.public_id] = strategy.period_budget(now)\n\n log.info('[SPENDINGS] Period budgets calculated (currency): {0}'.format(limits_dict))\n\n # Cast to budget precision used in Redis\n return {strategy: cast_CPM_to_dbbid(cast_currency_to_CPM(budget)) for strategy, budget in limits_dict.items()}","def get_budget_from_api(type_of_thing: int, qty: int):\n payload = {\"multiplier\": qty}\n if type_of_thing == 1:\n payload[\"commodity\"] = \"tomatoes\"\n elif type_of_thing == 2:\n payload[\"commodity\"] = \"broiler-chickens\"\n else:\n return None\n\n cache_key = f\"{type_of_thing}-{qty}\"\n\n val_from_cache = cache.get(cache_key)\n if val_from_cache:\n return val_from_cache\n\n json_payload = json.dumps(payload)\n\n r = requests.post(BUDGET_API_URL, json_payload)\n\n if r.status_code == 200:\n result = r.json()['data']\n cache.set(\n cache_key,\n result,\n BUDGET_CACHE_DURATION\n )\n return result\n\n return None","def get_debt(self):\n sum_import = self.invoice_set.filter(\n expiration_date__lte=date.today(),\n paid=False,\n debited=False,\n canceled=False,\n uncollectible=False,\n ).aggregate(Sum(\"amount\"))\n return sum_import.get(\"amount__sum\", None)","def get_order_limit_data():\n\n chargeDB = ChargeDBHelper()\n order_limit_list = []\n\n rxcui_bundles = chargeDB.get_all_charge_bundles()\n clinic_count = clinic_cnt_for_days(chargeDB.get_days_spanned())\n for bundle in rxcui_bundles:\n order_limit_list.append(to_order_limit_row(bundle, clinic_count))\n\n\n\n chargeDB.close()\n return order_limit_list","def get_billing_data_by_priority(self):\n result = {}\n product = self.get_first_product_by_priority()\n if product:\n sp = self.subscriptionproduct_set.filter(product=product).first()\n if sp.address:\n result = {\n \"route\": sp.route_id,\n \"order\": sp.order,\n \"address\": sp.address.address_1 or sp.subscription.contact.email,\n \"state\": sp.address.state,\n \"city\": sp.address.city,\n \"name\": self.get_billing_name(),\n }\n if not result:\n if getattr(settings, \"FORCE_DUMMY_MISSING_BILLING_DATA\", False):\n result = {}\n return result","async def __getFromProjectedBill(self, account, premise, currentBillDate) -> dict:\n data = {}\n\n try:\n async with async_timeout.timeout(TIMEOUT):\n response = await self.session.get(\n URL_RESOURCES_PROJECTED_BILL.format(\n account=account,\n premise=premise,\n lastBillDate=currentBillDate.strftime(\"%m%d%Y\"),\n )\n )\n\n if response.status == 200:\n projectedBillData = (await response.json())[\"data\"]\n\n billToDate = float(projectedBillData[\"billToDate\"])\n projectedBill = float(projectedBillData[\"projectedBill\"])\n dailyAvg = float(projectedBillData[\"dailyAvg\"])\n avgHighTemp = int(projectedBillData[\"avgHighTemp\"])\n\n data[\"bill_to_date\"] = billToDate\n data[\"projected_bill\"] = projectedBill\n data[\"daily_avg\"] = dailyAvg\n data[\"avg_high_temp\"] = avgHighTemp\n\n except Exception as e:\n _LOGGER.error(e)\n\n return data","def GetAllCostByAmountBandFromDB(lowerLimit, upperLimit):\n\n logs.logger.debug(\"Start to get back all Cost object from database\\\n based on amount band.\")\n try:\n searchedCostByAmountBandFromDB = session.query(\n Cost.Cost).filter(Cost.Cost.amount >= lowerLimit, Cost.Cost.amount <= upperLimit).all()\n logs.logger.info(\n \"Get back all Cost object from database based on amount band.\")\n return [item for item in searchedCostByAmountBandFromDB]\n except Exception as e:\n logs.logger.error(e, exc_info=True)","def budget(self):\n\n budget = (_House.closing_cost*self.vars['after_repair_value']) - self.vars['purchase_price'] - self.vars['profit'] - _House.broker_fee\n return float(round(budget, 2))","def getBudget(movieInfo):\n if \"budget\" in movieInfo:\n return int(movieInfo[\"budget\"])\n else:\n raise AttributeError(\"%s instance has no attribute budget\" % movieInfo)","def budget_balance(self):\n budget_balance = round(self.budget() - self.total_spent(), 2)\n budget_balance_degree = round( (9000 * self.total_spent()) / (self.budget()), 4) #convert to degrees and round to four decimal places\n return (budget_balance, budget_balance_degree)","def get(self):\n return {'bills': [bill.json() for bill in BillModel.find_all()]}","def action_budget_create(self, cr, uid, ids, context=None):\n payment_term_obj = self.pool.get('account.payment.term')\n for porder in self.browse(cr, uid, ids, context=context):\n period = self.pool.get('account.period').find(cr,uid,porder.date_order, context = context)[0] \n result = []\n confirmation_dict={\n 'reference': porder.name,\n 'period_id': period,\n 'partner_id':porder.partner_id.id,\n 'amount': porder.amount_total,\n 'note':'',\n 'date':porder.date_order,\n 'type':'purchase'}\n\n for line in porder.order_line:\n confirmation_ids=[]\n account_id = self._choose_account_from_po_line(cr, uid, line, context=context)\n notes = _(\"Purchase Approval: %s \\nDescription: %s.\\nDate: %s \\nProducts: %s \") % (porder.name , porder.notes , porder.date_order , line.name )\n\n result= payment_term_obj.compute(cr, \n uid, porder.payment_term_id.id, line.price_subtotal,porder.date_order or False, context=context)\n for r in result:\n confirmation_dict.update(\n {'date':r[0],\n 'amount':r[1],\n 'note':notes,\n 'name':'/',\n 'general_account_id': account_id,\n 'account_analytic_id': line.account_analytic_id.id or False,\n })\n confirmation_id = self.pool.get('account.budget.confirmation').create(cr, uid, confirmation_dict)\n confirmation_ids.append(confirmation_id)\n line.write({'confirmation_ids':[(6, 0, confirmation_ids)] ,'state': 'waiting_budget'})\n self.write(cr, uid, ids, {'state': 'waiting_budget'})\n return True","def budget_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"budget_name\")","def billing_period(self) -> Optional[str]:\n return pulumi.get(self, \"billing_period\")","async def __getDataFromBalance(self, account) -> dict:\n _LOGGER.info(\"Getting appliance usage data\")\n\n data = {}\n\n URL_BALANCE = API_HOST + \"/api/resources/account/{account}/balance?count=-1\"\n\n try:\n async with async_timeout.timeout(TIMEOUT):\n response = await self.session.get(URL_BALANCE.format(account=account))\n if response.status == 200:\n data = (await response.json())[\"data\"]\n\n indice = [i for i, x in enumerate(data) if x[\"details\"] == \"DEBT\"][\n 0\n ]\n\n deb = data[indice][\"amount\"]\n\n except Exception as e:\n _LOGGER.error(e)\n\n return {\"balance_data\": data}","def get_pl_balances(self):\n\n\t\tdimension_fields = ['t1.cost_center']\n\n\t\tself.accounting_dimensions = get_accounting_dimensions()\n\t\tfor dimension in self.accounting_dimensions:\n\t\t\tdimension_fields.append('t1.{0}'.format(dimension))\n\n\t\treturn frappe.db.sql(\"\"\"\n\t\t\tselect\n\t\t\t\tt1.account, t2.account_currency, {dimension_fields},\n\t\t\t\tsum(t1.debit_in_account_currency) - sum(t1.credit_in_account_currency) as bal_in_account_currency,\n\t\t\t\tsum(t1.debit) - sum(t1.credit) as bal_in_company_currency\n\t\t\tfrom `tabGL Entry` t1, `tabAccount` t2\n\t\t\twhere t1.is_cancelled = 0 and t1.account = t2.name and t2.report_type = 'Profit and Loss'\n\t\t\tand t2.docstatus < 2 and t2.company = %s\n\t\t\tand t1.posting_date between %s and %s\n\t\t\tgroup by t1.account, {dimension_fields}\n\t\t\"\"\".format(dimension_fields = ', '.join(dimension_fields)), (self.company, self.get(\"year_start_date\"), self.posting_date), as_dict=1)","def get_display_price_data(self, source, commitment):\n overage, included = self.get_price_data(source, commitment)\n if self.name == settings.BILLING_DEFAULT_PLAN_NAME:\n included = OFFICIAL_BUILDER_LIMITS[source]\n return overage, included","def get_budget_fixture(thing_being_farmed: int):\n if thing_being_farmed == 1:\n path = os.path.join(BASE_DIR, 'fixtures', 'tomato-budget.json')\n elif thing_being_farmed == 2:\n path = os.path.join(BASE_DIR, 'fixtures', 'broiler-budget.json')\n else:\n return None\n\n with open(path, 'r') as budget_fixture:\n budget = json.load(budget_fixture)\n\n return budget","def billing_account(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"billing_account\")","def billing_account(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"billing_account\")","def billing_account(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"billing_account\")","def get_bill_details(request):\n\n print request\n\n context = request['context']\n print context\n try:\n telephone_number = first_entity_value(request['entities'], 'phone_number')\n with open(os.path.join(sys.path[0], \"app/wit/static/users.json\"), \"r\") as data_file:\n data = json.load(data_file)\n customer_billing = data[telephone_number]['last_month_billing']\n print customer_billing\n\n customer_type = data[telephone_number]['type_customer']\n if customer_type == 'postpaid':\n\n reply = \"Our Initial Investigation shows that you're a \" + data[telephone_number]['type_customer'] + \" Customer and currently using \" + data[telephone_number]['plan_details'] + \" plan type.\"\n if customer_billing['roaming'] == 'True':\n reply += \"You had used your cellphone while on roaming for which you were charged extra.\"\n elif customer_billing['data_exhaust'] == 'True':\n reply += \"You had used your data network after your allocated limit was exhausted. You were charged for these services\"\n elif customer_billing['subscribed'] == 'True':\n reply += \"You had subscribed to some promotional services for which you were charged in extra.\"\n else:\n reply = \"Our Initial Investigation shows that you're a \" + data[telephone_number]['type_customer'] + \". We believe that this might be a mistake from our side and would like you to speak to our customer care executives separately.\"\n\n\n except:\n telephone_number = None\n reply = \"Your number is not subscribed with Airtel. Please contact your network operator for your query\"\n\n\n print reply\n\n context['bill_details'] = reply\n\n return context","def get(resource_name: str,\n id: pulumi.Input[str],\n opts: Optional[pulumi.ResourceOptions] = None,\n all_updates_rule: Optional[pulumi.Input[pulumi.InputType['BudgetAllUpdatesRuleArgs']]] = None,\n amount: Optional[pulumi.Input[pulumi.InputType['BudgetAmountArgs']]] = None,\n billing_account: Optional[pulumi.Input[str]] = None,\n budget_filter: Optional[pulumi.Input[pulumi.InputType['BudgetBudgetFilterArgs']]] = None,\n display_name: Optional[pulumi.Input[str]] = None,\n name: Optional[pulumi.Input[str]] = None,\n threshold_rules: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['BudgetThresholdRuleArgs']]]]] = None) -> 'Budget':\n opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))\n\n __props__ = _BudgetState.__new__(_BudgetState)\n\n __props__.__dict__[\"all_updates_rule\"] = all_updates_rule\n __props__.__dict__[\"amount\"] = amount\n __props__.__dict__[\"billing_account\"] = billing_account\n __props__.__dict__[\"budget_filter\"] = budget_filter\n __props__.__dict__[\"display_name\"] = display_name\n __props__.__dict__[\"name\"] = name\n __props__.__dict__[\"threshold_rules\"] = threshold_rules\n return Budget(resource_name, opts=opts, __props__=__props__)","def _fetch_bills(self, options):\n bill_count = options['max'] or fetch.DEFAULT_BILL_COUNT\n return fetch.bills(per_page=bill_count)","def create_budget(budget_category: BudgetCategory) -> Budget:\n amount = -1\n while amount <= 0:\n amount = float(input(f'Enter {budget_category.value} budget: '))\n if amount <= 0:\n print('Budget amount must be greater than 0! Please enter '\n 'again!')\n return Budget(budget_category, amount)","def get_claim_bill(\n _db: Session = db, *, start: datetime = None, end: datetime = None,\n store_internal_id: int = None, owner_id: int = None,\n kind: models.ClaimKind = None, calculation: CalcType = \"avg\"\n):\n query = crud.claim.get_query(_db)\n if start and end:\n query = query.filter(models.Claim.created_at.between(start, end))\n if store_internal_id:\n query = query.filter(models.Claim.store_internal_id == store_internal_id)\n if owner_id:\n query = query.filter(models.Claim.owner_id == owner_id)\n if kind:\n query = query.filter(models.Claim.kind == kind)\n bill = query.with_entities(getattr(func, calculation)(models.Claim.bill).label(\"_bill\")).first()\n bill_round = round(bill[0], 2) if bill[0] is not None else 0.00\n return bill_round","def declare_new_budget(date, exp_data):\n\n exp_list = exp_data[env.EXPENSE_DATA_KEY]\n local_budget = {}\n month_total = util.get_float_input(\n f\"Please input your total for the month ending {date}: \", force_pos=True)\n budg_remaining = month_total\n\n for i, exp in enumerate(exp_list):\n if i == len(exp_list) - 1:\n print(\"I got the last one for you :) MATH!\")\n budg_amnt = budg_remaining\n budg_remaining = 0\n\n elif budg_remaining == 0: # elif skips this condition if budget remaining is set above\n budg_amnt = 0\n local_budget[env.BUDGET_TOTAL_KEY] = month_total\n else:\n prompt = f\"Enter your budget for: [{exp}] - Total Budget Re. ${budg_remaining} - Exp's Re. [{len(exp_list) - i - 1}]: \"\n budg_amnt = prompt_for_budget_amnt(\n prompt, budg_remaining, exp_data)\n local_budget.update({exp: budg_amnt})\n budg_remaining = round(month_total - sum_budget(local_budget), 2)\n print(local_budget)\n return local_budget","def get(resource_name: str,\n id: pulumi.Input[str],\n opts: Optional[pulumi.ResourceOptions] = None,\n all_updates_rule: Optional[pulumi.Input[pulumi.InputType['BudgetAllUpdatesRuleArgs']]] = None,\n amount: Optional[pulumi.Input[pulumi.InputType['BudgetAmountArgs']]] = None,\n billing_account: Optional[pulumi.Input[str]] = None,\n budget_filter: Optional[pulumi.Input[pulumi.InputType['BudgetBudgetFilterArgs']]] = None,\n display_name: Optional[pulumi.Input[str]] = None,\n name: Optional[pulumi.Input[str]] = None,\n threshold_rules: Optional[pulumi.Input[List[pulumi.Input[pulumi.InputType['BudgetThresholdRuleArgs']]]]] = None) -> 'Budget':\n opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))\n\n __props__ = dict()\n\n __props__[\"all_updates_rule\"] = all_updates_rule\n __props__[\"amount\"] = amount\n __props__[\"billing_account\"] = billing_account\n __props__[\"budget_filter\"] = budget_filter\n __props__[\"display_name\"] = display_name\n __props__[\"name\"] = name\n __props__[\"threshold_rules\"] = threshold_rules\n return Budget(resource_name, opts=opts, __props__=__props__)","def get_bankcard_obj(self):\n kwargs = {\n 'card_number': self.cleaned_data['number'],\n 'expiry_date': self.cleaned_data['expiry_month'].strftime(\"%m/%y\"),\n 'ccv': self.cleaned_data['ccv_number'],\n }\n if self.cleaned_data['start_month']:\n kwargs['start_date'] = self.cleaned_data['start_month'].strftime(\"%m/%y\")\n return Bankcard(**kwargs)","def budget(config, tag):\n\tif tag in config[\"budget\"].keys():\n\t\tprint(tag)\n\telse:\n\t\tprint(config[\"budget\"].keys())","def get(self, args):\n return Payment.query.offset(args['offset']).limit(args['limit'])","def budgetFilter(budget):\n # Query the database for all the movies\n movies = Movies.query.order_by(db.asc(Movies.budget)).filter(Movies.budget>=budget).limit(100).all()\n\n # Serialize the list of movies from our data\n movies_schema = MoviesSchema(many=True)\n data = movies_schema.dump(movies)\n return data","def get_budget_by_name(self, budget_name):\n return next((budget for budget in self.budgets\n if budget.name.lower() == budget_name.lower()), None)","def month():\n \n # get month entered by user - if no month entered default to current month\n month = request.args.get(\"month\", datetime.now().strftime(\"%Y-%m\"))\n \n # get budget data for month as a dictionary\n data = budget_data(month)\n \n return json.dumps(data)","def handle(self):\n self.validate()\n if self.errors:\n raise InvalidDataException(self.errors)\n\n phone_number = self.data.get('phone_number')\n month = self.data.get('month')\n year = self.data.get('year')\n\n # if a period was not informed, get the current last one\n if not month and not year:\n year, month = last_period()\n\n bill_data = Bill.data_by_number_period(phone_number, month, year)\n return bill_data","def get_config(self, budget):\n\t\traise NotImplementedError('This function needs to be overwritten in %s.'%(self.__class__.__name__))","def _get_fwl_billing_item(self, firewall_id, dedicated=False):\r\n mask = ('mask[id,billingItem[id]]')\r\n if dedicated:\r\n fwl_svc = self.client['Network_Vlan_Firewall']\r\n else:\r\n fwl_svc = self.client['Network_Component_Firewall']\r\n return fwl_svc.getObject(id=firewall_id, mask=mask)","def get_transfer_bid(self):\n api_uri = self._uri_dict.get('getTransferBid')\n data = {}\n r_data = self._post(api_uri, data)\n return r_data","def get_bank(self):\n return self._bank","def get_spend_by_campaign_this_month(self, account_id):\n try:\n account = DependentAccount.objects.get(id=account_id)\n except DependentAccount.DoesNotExist:\n return\n\n client = get_client()\n client.client_customer_id = account.dependent_account_id\n\n report_downloader = client.GetReportDownloader(version=settings.API_VERSION)\n\n campaign_report_selector = {\n 'fields': ['Cost', 'CampaignId', 'CampaignStatus', 'CampaignName', 'Labels', 'Impressions'],\n 'predicates': [\n {\n 'field': 'Cost',\n 'operator': 'GREATER_THAN',\n 'values': '0'\n }\n ]\n }\n\n campaign_report_query = {\n 'reportName': 'CAMPAIGN_PERFORMANCE_REPORT',\n 'dateRangeType': 'THIS_MONTH',\n 'reportType': 'CAMPAIGN_PERFORMANCE_REPORT',\n 'downloadFormat': 'CSV',\n 'selector': campaign_report_selector\n }\n\n in_use_ids = []\n\n campaign_report = Reporting.parse_report_csv_new(report_downloader.DownloadReportAsString(campaign_report_query))\n for campaign_row in campaign_report:\n print(campaign_row)\n campaign_id = campaign_row['campaign_id']\n in_use_ids.append(campaign_row['campaign_id'])\n campaign, created = Campaign.objects.get_or_create(campaign_id=campaign_id, account=account)\n # Update campaign name\n campaign.campaign_name = campaign_row['campaign']\n # This is the cost for this month\n cost = int(campaign_row['cost']) / 1000000\n campaign.campaign_cost = cost\n campaign.save()\n print('Campaign: ' + str(campaign) + ' now has a spend this month of $' + str(campaign.campaign_cost))\n\n today = datetime.datetime.today()\n\n if today.day != 1:\n yesterday = datetime.datetime.now() - datetime.timedelta(1)\n first_day_of_month = datetime.datetime(yesterday.year, yesterday.month, 1)\n\n campaign_report_selector = {\n 'fields': ['Cost', 'CampaignId', 'CampaignStatus', 'CampaignName', 'Labels', 'Impressions'],\n 'predicates': [\n {\n 'field': 'Cost',\n 'operator': 'GREATER_THAN',\n 'values': '0'\n }\n ]\n }\n\n campaign_report_query = {\n 'reportName': 'CAMPAIGN_PERFORMANCE_REPORT',\n 'dateRangeType': 'CUSTOM_DATE',\n 'reportType': 'CAMPAIGN_PERFORMANCE_REPORT',\n 'downloadFormat': 'CSV',\n 'selector': campaign_report_selector\n }\n\n start_date = first_day_of_month\n end_date = yesterday\n\n campaign_report_selector['dateRange'] = {\n 'min': start_date.strftime('%Y%m%d'),\n 'max': end_date.strftime('%Y%m%d')\n }\n\n campaign_yest_report = Reporting.parse_report_csv_new(\n report_downloader.DownloadReportAsString(campaign_report_query))\n for campaign_row in campaign_yest_report:\n campaign_id = campaign_row['campaign_id']\n campaign, created = Campaign.objects.get_or_create(campaign_id=campaign_id, account=account)\n campaign.campaign_name = campaign_row['campaign']\n # This is the cost for this month until yesterday\n spend_until_yesterday = int(campaign_row['cost']) / 1000000\n campaign.spend_until_yesterday = spend_until_yesterday\n campaign.save()\n print(\n 'Campaign: ' + str(campaign) + ' has spend until yesterday of $' + str(campaign.spend_until_yesterday))\n\n return 'get_spend_by_campaign_this_month'","def test_companies_company_id_data_bill_credit_notes_get(self):\n pass","def billing_info_list(request):\n if request.method == 'GET':\n billing_infos = BillingInfo.objects.all()\n serializer = BillingInfoSerializer(billing_infos, many=True)\n return JSONResponse(serializer.data)\n\n elif request.method == 'POST':\n data = JSONParser().parse(request)\n serializer = BillingInfoSerializer(data=data)\n if serializer.is_valid():\n serializer.save()\n return JSONResponse(serializer.data, status=201)\n return JSONResponse(serializer.errors, status=400)","async def fetch_balance(self, params={}):\n await self.load_markets()\n request = {\n 'currency': 'all',\n }\n response = await self.privateGetUserMargin(self.extend(request, params))\n #\n # [\n # {\n # \"account\":1455728,\n # \"currency\":\"XBt\",\n # \"riskLimit\":1000000000000,\n # \"prevState\":\"\",\n # \"state\":\"\",\n # \"action\":\"\",\n # \"amount\":263542,\n # \"pendingCredit\":0,\n # \"pendingDebit\":0,\n # \"confirmedDebit\":0,\n # \"prevRealisedPnl\":0,\n # \"prevUnrealisedPnl\":0,\n # \"grossComm\":0,\n # \"grossOpenCost\":0,\n # \"grossOpenPremium\":0,\n # \"grossExecCost\":0,\n # \"grossMarkValue\":0,\n # \"riskValue\":0,\n # \"taxableMargin\":0,\n # \"initMargin\":0,\n # \"maintMargin\":0,\n # \"sessionMargin\":0,\n # \"targetExcessMargin\":0,\n # \"varMargin\":0,\n # \"realisedPnl\":0,\n # \"unrealisedPnl\":0,\n # \"indicativeTax\":0,\n # \"unrealisedProfit\":0,\n # \"syntheticMargin\":null,\n # \"walletBalance\":263542,\n # \"marginBalance\":263542,\n # \"marginBalancePcnt\":1,\n # \"marginLeverage\":0,\n # \"marginUsedPcnt\":0,\n # \"excessMargin\":263542,\n # \"excessMarginPcnt\":1,\n # \"availableMargin\":263542,\n # \"withdrawableMargin\":263542,\n # \"timestamp\":\"2020-08-03T12:01:01.246Z\",\n # \"grossLastValue\":0,\n # \"commission\":null\n # }\n # ]\n #\n return self.parse_balance(response)","def get_customer_balance_sheet(self):\n total = 0\n taxes = 0\n balances = 0\n un_paid_count = 0\n conflicts = 0\n unresolved_conflicts = 0\n projected_before_tax = 0\n\n invoice_list = Customer_Invoice.objects.all()\n count = len(invoice_list)\n for invoice in invoice_list:\n if invoice.invoice_quote.total_price_quoted:\n total += invoice.invoice_quote.total_price_quoted\n taxes += invoice.invoice_quote.tax_on_quote\n balances += invoice.get_balance_due()\n else:\n projected = invoice.get_cost()\n projected_before_tax += projected[1]\n if not invoice.paid_in_full:\n un_paid_count += 1\n for conflict in invoice.conflict.all():\n conflicts += 1\n if not conflict.conflict_resolution:\n unresolved_conflicts += 1\n profit = total - taxes\n\n return total, taxes, profit, balances, count, conflicts, unresolved_conflicts, projected_before_tax","def default_billing(self):\n return self._default_billing","def get_budget(\n self, f=None, names=None, zones=None, net=False, pivot=False\n ):\n aliases = None\n if self._zon is not None:\n aliases = self._zon.aliases\n\n if f is None and self._recarray is None:\n f = os.path.join(self._model_ws, f\"{self._name}.csv\")\n self._recarray = _read_zb_csv2(\n f, add_prefix=False, aliases=aliases\n )\n elif f is None:\n pass\n else:\n self._recarray = _read_zb_csv2(\n f, add_prefix=False, aliases=aliases\n )\n\n recarray = _get_budget(\n self._recarray,\n self._zon._zonenamedict,\n names=names,\n zones=zones,\n net=net,\n )\n\n if pivot:\n recarray = _pivot_recarray(recarray)\n\n return recarray","def get_billing_document(self):\n if self.rut:\n return self.rut\n elif self.billing_id_doc:\n return self.billing_id_doc\n else:\n return self.contact.id_document","def plan_list_get(request):\n return list_by_company_guid(request, PlanModel)","def get_transactions_for_budget(self, budget_name=None):\n if len(self.budgets) > 1 and budget_name is None:\n self._logger.error('There are multiple budgets and no budget name was provided')\n raise MultipleBudgets\n if budget_name is None:\n self._logger.debug('No budget name provided returning the only budget registered')\n budget = self.budgets[0]\n else:\n self._logger.debug('Trying to retrieve budget with name \"%s\"', budget_name)\n budget = next((budget for budget in self.budgets\n if budget.name.lower() == budget_name.lower()), None)\n if not budget:\n return []\n return [YnabServerTransaction(transaction, transaction.account)\n for transaction in budget.transactions]","def retrieve(self, request, *args, **kwargs):\n return super(BalanceBillsViewSet, self).retrieve(\n request,\n *args,\n **kwargs\n )","def billing_account(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"billing_account\")","def billing_account(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"billing_account\")","def test_companies_company_id_data_bank_accounts_account_id_transactions_get(self):\n pass","def GetAllCostByDateOfPaymentBandFromDB(startDate, endDate):\n\n logs.logger.debug(\n \"Start to get back all Cost object from database \"\n \"based on payment date band.\")\n try:\n searchedCostByDateOfPaymentBandFromDB = session.query(\n Cost.Cost).filter(Cost.Cost.dateOfPayment >= startDate, Cost.Cost.dateOfPayment <= endDate).all()\n logs.logger.info(\n \"Get back all Cost object from database \"\n \"based on payment date band.\")\n return [item for item in searchedCostByDateOfPaymentBandFromDB]\n except Exception as e:\n logs.logger.error(e, exc_info=True)","def balance(self):\n balance = {'A': 0, 'B': 0}\n account_balances = AccountBalance.objects.filter(\n organization_id=self.id,\n expiration_date=None\n ).order_by('-id')\n\n credit_class = CreditClass.objects.filter(credit_class=\"A\").first()\n for account_balance in account_balances:\n if account_balance.credit_class_id == credit_class.id:\n balance['A'] = account_balance.balance\n else:\n balance['B'] = account_balance.balance\n return balance","def test_retrieve_all_by_bank(self):\n swa = frontend.SupplyWinApi()\n query_dict = dict(\n dev=\"rrenaud\",\n targets=\"\",\n interaction=\"Bank\",\n unconditional=\"true\",\n )\n\n card_stats = swa.retrieve_data(query_dict)\n\n # Gets 288 entries back, because one for each of the 144\n # cards, plus the unconditioned version of each\n self.assertEquals(len(card_stats), 288)\n\n self.assertEquals(card_stats[0]['card_name'], 'Adventurer')\n\n json = swa.readable_json_card_stats(card_stats)\n self.assertEquals(json[0:14], '[{\"card_name\":')","def test_get_virtual_account_beneficiary(self):\n pass","def budget_filter(self) -> pulumi.Output['outputs.BudgetBudgetFilter']:\n return pulumi.get(self, \"budget_filter\")","def getBudgetBalance(self, budgetName):\r\n assert budgetName in self.budgets, \"Specified budget doesn't exist\"\r\n return \"%.2f\" % float(self.budgets[budgetName])","def billing_account(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"billing_account\")","def billing_account(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"billing_account\")","def fetch_balance(self, params={}):\n self.load_markets()\n response = self.privateGetAccountBalanceV2(params)\n #\n # {\n # \"AVAILABLE_NIS\": 0.0,\n # \"NIS\": 0.0,\n # \"LOCKED_NIS\": 0.0,\n # \"AVAILABLE_BTC\": 0.0,\n # \"BTC\": 0.0,\n # \"LOCKED_BTC\": 0.0,\n # \"AVAILABLE_ETH\": 0.0,\n # \"ETH\": 0.0,\n # \"LOCKED_ETH\": 0.0,\n # \"AVAILABLE_BCHSV\": 0.0,\n # \"BCHSV\": 0.0,\n # \"LOCKED_BCHSV\": 0.0,\n # \"AVAILABLE_BCHABC\": 0.0,\n # \"BCHABC\": 0.0,\n # \"LOCKED_BCHABC\": 0.0,\n # \"AVAILABLE_LTC\": 0.0,\n # \"LTC\": 0.0,\n # \"LOCKED_LTC\": 0.0,\n # \"AVAILABLE_ETC\": 0.0,\n # \"ETC\": 0.0,\n # \"LOCKED_ETC\": 0.0,\n # \"AVAILABLE_BTG\": 0.0,\n # \"BTG\": 0.0,\n # \"LOCKED_BTG\": 0.0,\n # \"AVAILABLE_GRIN\": 0.0,\n # \"GRIN\": 0.0,\n # \"LOCKED_GRIN\": 0.0,\n # \"Fees\": {\n # \"BtcNis\": {\"FeeMaker\": 1.0, \"FeeTaker\": 1.0},\n # \"EthNis\": {\"FeeMaker\": 1.0, \"FeeTaker\": 1.0},\n # \"BchabcNis\": {\"FeeMaker\": 1.0, \"FeeTaker\": 1.0},\n # \"LtcNis\": {\"FeeMaker\": 1.0, \"FeeTaker\": 1.0},\n # \"EtcNis\": {\"FeeMaker\": 1.0, \"FeeTaker\": 1.0},\n # \"BtgNis\": {\"FeeMaker\": 1.0, \"FeeTaker\": 1.0},\n # \"LtcBtc\": {\"FeeMaker\": 1.0, \"FeeTaker\": 1.0},\n # \"BchsvNis\": {\"FeeMaker\": 1.0, \"FeeTaker\": 1.0},\n # \"GrinNis\": {\"FeeMaker\": 1.0, \"FeeTaker\": 1.0}\n # }\n # }\n #\n return self.parse_balance(response)","def get():\n\n # \\todo List of available data, fetched and processed\n\n return jsonify({'valid_resources': ['balance', 'balance_usd', 'trade_history', 'balance_norm_price_history', 'open_orders']})","def get_campaign_cost(self, id):\n logger.info(\"Function call: get_campaign_cost: '{}'\".format(id, ))\n return self.__handle_error(\"Empty addressbook id\") if not id else self.__handle_result(self.__send_request('addressbooks/{}/cost'.format(id)))","def test_get_virtual_account_beneficiaries(self):\n pass","def get_amount():\n conn = None\n try:\n params = config()\n conn = psycopg2.connect(**params)\n cur = conn.cursor()\n\n #tas\n raw={}\n raw['plan']={}\n raw['actual']={}\n\n cur.execute(\"SELECT slc.*,plc.amount as amount_plan,ppm.amount as price \\\n ,to_char((slc.amount*ppm.amount)/aco.amount_actual_coal,'999.999') as cost_actual \\\n , to_char((plc.amount*ppm.amount)/aco.amount_actual_coal,'999.999') as cost_plan \\\n ,aco.amount_actual_coal \\\n FROM vw_tta_cps_sum_land_clearing_now AS slc \\\n LEFT JOIN vw_tta_cps_price_per_month AS ppm \\\n ON slc.int_month=ppm.month \\\n AND slc.year_id=ppm.year_id \\\n LEFT JOIN vw_tta_cps_plan_land_clearing AS plc \\\n ON slc.periode_month_id=plc.periode_month_id \\\n AND slc.land_clearing_location_id=plc.land_clearing_location_id \\\n LEFT JOIN vw_tta_cps_sr_all_per_month_plan_actual as aco \\\n ON aco.int_month=slc.int_month \\\n WHERE ppm.jenis_price=10 \\\n AND aco.plan_id=1\")\n rowcount=cur.rowcount\n print(\"The number of row: \", rowcount)\n row = cur.fetchone()\n counter=0\n item={}\n\n if rowcount>0:\n f=open('../../data_cost_per_ton.csv','w')\n f.write('AREA,PLAN,ACTUAL\\n')\n while row is not None:\n #print(row)\n raw[\"plan\"]=row[11]\n raw[\"actual\"]=row[10]\n f.write(str('RAW')+','+str(raw[\"plan\"])+','+str(raw[\"actual\"])+\"\\n\")\n\n row = cur.fetchone()\n\n if rowcount>0:\n f.close()\n cur.close()\n\n print(str(datetime.datetime.now())+' '+str(rowcount)+' row updated')\n except (Exception, psycopg2.DatabaseError) as error:\n print(str(datetime.datetime.now())+' '+str(error))\n finally:\n if conn is not None:\n conn.close()","def get_all_spend_by_campaign_custom(self):\n budgets = Budget.objects.filter(has_adwords=True, is_monthly=False)\n for budget in budgets:\n for aw_account in budget.account.adwords.all():\n if settings.DEBUG:\n get_spend_by_campaign_custom(budget.id, aw_account.id)\n else:\n get_spend_by_campaign_custom.delay(budget.id, aw_account.id)\n\n return 'get_all_spend_by_campaign_custom'","def sum_budget(monthly_budget: dict):\n sum = 0\n for k, v in monthly_budget.items():\n if v is not None and k != env.BUDGET_TOTAL_KEY:\n sum += v\n\n return sum","def get_entity_contracts():\n url = 'http://www.base.gov.pt/base2/rest/contratos?' \\\n 'adjudicatariaid=%d' % entity.base_id\n\n response = requests.get(url, headers={'Range': 'items=0-1000000'})\n return json.loads(response.text)","def FundingInfo(self, default=[{}]):\n tmp = self.data.get('metadata', {}).get('funding_info', default)\n return [HEP.FundingObject(i) for i in tmp]","def complete(self, cr, uid, ids, context={}):\n budget_pool = self.pool.get('account.budget')\n budget_line_pool = self.pool.get('account.budget.lines')\n for r in self.browse(cr, uid, ids, context=context):\n if r.type=='transfer' and not r.line_ids:\n raise osv.except_osv(_('Error!'),_('You cannot complete Transfer Operations without any Budget line.'))\n if r.budget_type=='cash':\n budget_ids = budget_pool.search(cr, uid,[('analytic_account_id', '=', r.analytic_account_id.id), \n ('period_id', '=', r.period_id.id)], context=context)\n budget_line_id = budget_line_pool.search(cr, uid,[('general_account_id', '=', r.account_id.id), \n ('account_budget_id', 'in', tuple(budget_ids))], context=context)\n if budget_line_id:\n line=budget_line_pool.browse(cr, uid, budget_line_id, context=context)[0]\n if line.planned_amount+line.total_operation < line.cash_total_operation + r.amount:\n raise orm.except_orm(_('Error!'),\n _(\"Cash budget (%s) can't be more than planned budget (%s)!\") % \\\n ( line.cash_total_operation+ r.amount,line.planned_amount+line.total_operation ,))\n if line.cash_residual_balance + r.amount <=0:\n raise orm.except_orm(_('Error!'),\n _(\"The amount you try to transfer (%s) is more than %s residual (%s)!\") % \\\n (r.amount, line.name, line.cash_residual_balance,))\n for e in r.line_ids:\n if line.planned_amount+line.total_operation < line.cash_total_operation - r.amount:\n raise orm.except_orm(_('Error!'),\n _(\"Cash budget (%s) can't be more than planned budget (%s)!\") % \\\n ( e.cash_total_operation- r.amount,line.planned_amount+line.total_operation ,))\n if e.line_id.cash_residual_balance - e.amount <=0:\n raise orm.except_orm(_('Error!'),\n _(\"The amount you try to transfer (%s) is more than %s residual (%s)!\") % \\\n (e.amount, e.line_id.name, e.line_id.cash_residual_balance,))\n return self.write(cr, uid, ids,{'state':'complete','name': r.name == '/' and \n self.pool.get('ir.sequence').get(cr, uid, 'account.budget.operation') or \n r.name, 'amount': r.type=='increase' and r.amount or sum([l.amount for l in r.line_ids])}, context=context)\n \n return super(account_budget_operation, self).complete(cr, uid, ids, context=context)","def get_business(api_key, business_id):\n\n business_path = BUSINESS_PATH + business_id\n\n\n return request(API_HOST, business_path, api_key)","def test_companies_company_id_data_tax_rates_get(self):\n pass","def bcp_get(self, **kwargs):\n pass","def get_pending_orders(self):\n\n r = requests.get(build_api_call(self.base_url, ACCOUNTID, 'pending', ''), auth=HTTPBasicAuth(KEY, SECRET))\n\n if r.status_code == 200:\n return r.json()\n else:\n return 'error'","def billing(self, account_id):\n from pureport_client.commands.accounts.billing import Command\n return Command(self.client, account_id)","def add_budget(self, budget: Budget) -> None:\n self.budgets[budget.category] = budget","def get_list() -> List[BankDetails]:\n from paynlsdk.client.transaction import Transaction\n return Transaction.get_banks().banks","def get_broilers_budget(chickens: int = 1):\n budget = get_budget_fixture(thing_being_farmed=2)\n\n for i, segment in enumerate(budget['segments']):\n for i2, activity in enumerate(segment['activities']):\n for i3, item in enumerate(activity['inputs']):\n new_price = chickens * item['price']\n item['estimated_price'] = new_price\n item['price'] = new_price\n\n return budget","def ListUserBillingCycles(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def payback_form_data(self):\n return {\n 'date': date.today(),\n 'who_from': 'Georgie',\n 'who_to': 'Tristan',\n 'amount': 50,\n 'currency': 'GBP',\n 'method': 'Bank_transfer'\n }"],"string":"[\n \"def GetCampaignBudget(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def budget(self):\\n return self._budget\",\n \"def billing_info(self):\\r\\n return BillingInfo(self)\",\n \"def view_budgets(self) -> None:\\n Menu.prompt_view_budgets()\\n for budget in self.user.budget_manager:\\n print(f\\\"{budget}\\\\n\\\")\",\n \"def get_budgets(self) -> list:\\n return self.budget_manager.get_budgets()\",\n \"def get_budgets(self) -> list:\\n return list(self.budgets.values())\",\n \"def billing(self):\\n return self._billing\",\n \"def billing_info(self):\\n return self._billing_info\",\n \"def get_budget(self, category: BudgetCategory) -> Budget:\\n return self.budgets.get(category, None)\",\n \"def get_spend_by_campaign_custom(self, budget_id, aw_account_id):\\n try:\\n budget = Budget.objects.get(id=budget_id)\\n google_ads_account = DependentAccount.objects.get(id=aw_account_id)\\n except (Budget.DoesNotExist, DependentAccount.DoesNotExist):\\n return\\n\\n client = get_client()\\n client.client_customer_id = google_ads_account.dependent_account_id\\n\\n aw_campaigns = budget.aw_campaigns.filter(account=google_ads_account)\\n aw_campaign_ids = list(set([aw_campaign.campaign_id for aw_campaign in aw_campaigns]))\\n\\n report_downloader = client.GetReportDownloader(version=settings.API_VERSION)\\n\\n campaign_report_selector = {\\n 'fields': ['Cost', 'CampaignId', 'CampaignStatus', 'CampaignName', 'Labels', 'Impressions'],\\n 'predicates': [\\n {\\n 'field': 'Cost',\\n 'operator': 'GREATER_THAN',\\n 'values': '0'\\n },\\n {\\n 'field': 'CampaignId',\\n 'operator': 'IN',\\n 'values': aw_campaign_ids\\n }\\n ]\\n }\\n\\n campaign_report_query = {\\n 'reportName': 'CAMPAIGN_PERFORMANCE_REPORT',\\n 'dateRangeType': 'CUSTOM_DATE',\\n 'reportType': 'CAMPAIGN_PERFORMANCE_REPORT',\\n 'downloadFormat': 'CSV',\\n 'selector': campaign_report_selector\\n }\\n\\n start_date = budget.start_date\\n end_date = budget.end_date\\n\\n campaign_report_selector['dateRange'] = {\\n 'min': start_date.strftime('%Y%m%d'),\\n 'max': end_date.strftime('%Y%m%d')\\n }\\n\\n campaign_report = Reporting.parse_report_csv_new(report_downloader.DownloadReportAsString(campaign_report_query))\\n for campaign_row in campaign_report:\\n print(campaign_row)\\n campaign_id = campaign_row['campaign_id']\\n campaign, created = Campaign.objects.get_or_create(campaign_id=campaign_id, account=google_ads_account)\\n campaign.campaign_name = campaign_row['campaign']\\n campaign.save()\\n campaign_spend_object, created = CampaignSpendDateRange.objects.get_or_create(campaign=campaign,\\n start_date=start_date,\\n end_date=end_date)\\n\\n campaign_spend_object.spend = int(campaign_row['cost']) / 1000000\\n campaign_spend_object.save()\\n\\n yest_campaign_report_selector = {\\n 'fields': ['Cost', 'CampaignId', 'CampaignStatus', 'CampaignName', 'Labels', 'Impressions'],\\n 'predicates': [\\n {\\n 'field': 'Cost',\\n 'operator': 'GREATER_THAN',\\n 'values': '0'\\n },\\n {\\n 'field': 'CampaignId',\\n 'operator': 'IN',\\n 'values': aw_campaign_ids\\n }\\n ]\\n }\\n\\n yest_campaign_report_query = {\\n 'reportName': 'CAMPAIGN_PERFORMANCE_REPORT',\\n 'dateRangeType': 'CUSTOM_DATE',\\n 'reportType': 'CAMPAIGN_PERFORMANCE_REPORT',\\n 'downloadFormat': 'CSV',\\n 'selector': yest_campaign_report_selector\\n }\\n\\n start_date = budget.start_date\\n yest_end_date = datetime.datetime.now() - datetime.timedelta(1)\\n\\n yest_campaign_report_selector['dateRange'] = {\\n 'min': start_date.strftime('%Y%m%d'),\\n 'max': yest_end_date.strftime('%Y%m%d')\\n }\\n\\n campaign_report = Reporting.parse_report_csv_new(\\n report_downloader.DownloadReportAsString(yest_campaign_report_query))\\n for campaign_row in campaign_report:\\n campaign_id = campaign_row['campaign_id']\\n campaign, created = Campaign.objects.get_or_create(campaign_id=campaign_id, account=google_ads_account)\\n campaign.campaign_name = campaign_row['campaign']\\n campaign.save()\\n campaign_spend_object, created = CampaignSpendDateRange.objects.get_or_create(campaign=campaign,\\n start_date=start_date,\\n end_date=end_date)\\n\\n campaign_spend_object.spend_until_yesterday = int(campaign_row['cost']) / 1000000\\n campaign_spend_object.save()\\n\\n # try:\\n # campaign_report = \\\\\\n # Reporting.parse_report_csv_new(report_downloader.DownloadReportAsString(yest_campaign_report_query))[0]\\n # except IndexError:\\n # return\\n #\\n # campaign_spend_object, created = CampaignSpendDateRange.objects.get_or_create(campaign=campaign,\\n # start_date=budget.start_date,\\n # end_date=budget.end_date)\\n #\\n # campaign_spend_object.spend_until_yesterday = int(campaign_report['cost']) / 1000000\\n # campaign_spend_object.save()\\n\\n return 'get_spend_by_campaign_custom'\",\n \"def get_expenses(budget):\\n return sum(expense['bgt'] for expense in budget['spend'])\",\n \"def get(self):\\n\\n bill = {\\n 'product': {\\n 'name': self.order.product.name,\\n 'price': self.order.product.price\\n },\\n 'order_date_of_creation': self.order.date_of_creation,\\n 'bill_date_of_creation': timezone.now(),\\n 'discounts': [],\\n 'total': self.order.product.price\\n }\\n\\n return self.add_discount(bill)\",\n \"def budget_name(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"budget_name\\\")\",\n \"async def future_budget(budget: Budget):\\n\\n # Get the JSON object from the request body and cast it to a dictionary\\n input_dict = budget.to_dict()\\n bank_account_id = input_dict['bank_account_id']\\n monthly_savings_goal = input_dict['monthly_savings_goal']\\n\\n transactions = load_user_data(bank_account_id)\\n\\n # instantiate the user\\n user = User(transactions)\\n\\n # predict budget using time series model\\n pred_bud = user.predict_budget()\\n\\n # if a fatal error was encountered while generating the budget,\\n # return no budget along with the warning list\\n if user.warning == 2:\\n return json.dumps([None, user.warning_list])\\n\\n # modify budget based on savings goal\\n modified_budget = user.budget_modifier(\\n pred_bud, monthly_savings_goal=monthly_savings_goal)\\n\\n # if a fatal error was encountered while modifying the budget,\\n # return no budget along with the warning list\\n if user.warning == 2:\\n return json.dumps([None, user.warning_list])\\n\\n # if a non-fatal warning was encountered in predict_budget() or\\n # budget_modifier(), return the budget along with the warning list\\n elif user.warning == 1:\\n return json.dumps([modified_budget, user.warning_list])\\n\\n return modified_budget\",\n \"def get_debt_state(member, limit_year, limit_month):\\n if member.first_payment_year is None:\\n # never paid! using registration date to start with\\n yearmonths_paid = set()\\n year_to_check = member.registration_date.year\\n month_to_check = member.registration_date.month\\n else:\\n # build a set for the year/month of paid quotas\\n quotas = Quota.objects.filter(member=member).all()\\n yearmonths_paid = {(q.year, q.month) for q in quotas}\\n\\n year_to_check = member.first_payment_year\\n month_to_check = member.first_payment_month\\n\\n # verify the limit is after member started paying\\n if year_to_check == limit_year:\\n if month_to_check > limit_month:\\n return []\\n elif year_to_check > limit_year:\\n return []\\n\\n # build a set of all the year/month the member should have paid up to (including) the limit\\n should_have_paid = set()\\n while True:\\n should_have_paid.add((year_to_check, month_to_check))\\n year_to_check, month_to_check = increment_year_month(year_to_check, month_to_check)\\n if year_to_check == limit_year:\\n if month_to_check > limit_month:\\n break\\n elif year_to_check > limit_year:\\n break\\n\\n return sorted(should_have_paid - yearmonths_paid)\",\n \"def plan_get(request):\\n company = auth_api_key(request)\\n plan = get_and_check_plan(request, company)\\n return plan\",\n \"def budget_name(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"budget_name\\\")\",\n \"def get_budgets(budg_path, exp_path, dates=None):\\n exp_budg = data_help.read_jsonFile(budg_path)\\n exp_data = data_help.read_jsonFile(exp_path)\\n if dates == None:\\n dates = [util.get_current_month()]\\n for date in dates:\\n exp_budg_keys = exp_budg.keys()\\n if date not in exp_budg_keys: # check for current month to find exp categories\\n print(\\n f\\\"I have detected some data with for the month {date} that has no budget set.\\\")\\n print(\\n \\\"Please set the budget for this month.. or delete the data and run the program again.\\\")\\n if len(exp_budg) != 0:\\n user_in = util.get_user_input_for_chars(\\n \\\"Would you like to the whole thing (w) or create new (n)? \\\", ['w', 'n'])\\n\\n if user_in == 'w':\\n key = util.select_dict_key_using_integer(\\n exp_budg, \\\"Please select a budget to copy: \\\", print_children=True, print_vals=False, \\n print_child_vals=True)\\n exp_budg[date] = exp_budg[key]\\n elif user_in == 'n':\\n exp_budg[date] = declare_new_budget(date, exp_data)\\n else:\\n exp_budg[date] = declare_new_budget(date, exp_data)\\n\\n print(f\\\"Your budget is now saved for {date}.\\\")\\n\\n else:\\n print(f\\\"Your monthly budget for {date} is: \\\")\\n\\n util.print_simple_dict(exp_budg[date], print_vals=True)\\n\\n data_help.write_to_jsonFile(budg_path, exp_budg)\\n return\",\n \"def get_budget(self, names=None, zones=None, net=False, pivot=False):\\n recarray = _get_budget(\\n self._budget, self._zonenamedict, names=names, zones=zones, net=net\\n )\\n\\n if pivot:\\n recarray = _pivot_recarray(recarray)\\n\\n return recarray\",\n \"def get_period_budgets(cls, now):\\n limits_dict = {}\\n strategies = cls.objects_visible.filter(is_distributed_evenly=True)\\n strategies = cls.running(strategies)\\n\\n for strategy in strategies:\\n limits_dict[strategy.public_id] = strategy.period_budget(now)\\n\\n log.info('[SPENDINGS] Period budgets calculated (currency): {0}'.format(limits_dict))\\n\\n # Cast to budget precision used in Redis\\n return {strategy: cast_CPM_to_dbbid(cast_currency_to_CPM(budget)) for strategy, budget in limits_dict.items()}\",\n \"def get_budget_from_api(type_of_thing: int, qty: int):\\n payload = {\\\"multiplier\\\": qty}\\n if type_of_thing == 1:\\n payload[\\\"commodity\\\"] = \\\"tomatoes\\\"\\n elif type_of_thing == 2:\\n payload[\\\"commodity\\\"] = \\\"broiler-chickens\\\"\\n else:\\n return None\\n\\n cache_key = f\\\"{type_of_thing}-{qty}\\\"\\n\\n val_from_cache = cache.get(cache_key)\\n if val_from_cache:\\n return val_from_cache\\n\\n json_payload = json.dumps(payload)\\n\\n r = requests.post(BUDGET_API_URL, json_payload)\\n\\n if r.status_code == 200:\\n result = r.json()['data']\\n cache.set(\\n cache_key,\\n result,\\n BUDGET_CACHE_DURATION\\n )\\n return result\\n\\n return None\",\n \"def get_debt(self):\\n sum_import = self.invoice_set.filter(\\n expiration_date__lte=date.today(),\\n paid=False,\\n debited=False,\\n canceled=False,\\n uncollectible=False,\\n ).aggregate(Sum(\\\"amount\\\"))\\n return sum_import.get(\\\"amount__sum\\\", None)\",\n \"def get_order_limit_data():\\n\\n chargeDB = ChargeDBHelper()\\n order_limit_list = []\\n\\n rxcui_bundles = chargeDB.get_all_charge_bundles()\\n clinic_count = clinic_cnt_for_days(chargeDB.get_days_spanned())\\n for bundle in rxcui_bundles:\\n order_limit_list.append(to_order_limit_row(bundle, clinic_count))\\n\\n\\n\\n chargeDB.close()\\n return order_limit_list\",\n \"def get_billing_data_by_priority(self):\\n result = {}\\n product = self.get_first_product_by_priority()\\n if product:\\n sp = self.subscriptionproduct_set.filter(product=product).first()\\n if sp.address:\\n result = {\\n \\\"route\\\": sp.route_id,\\n \\\"order\\\": sp.order,\\n \\\"address\\\": sp.address.address_1 or sp.subscription.contact.email,\\n \\\"state\\\": sp.address.state,\\n \\\"city\\\": sp.address.city,\\n \\\"name\\\": self.get_billing_name(),\\n }\\n if not result:\\n if getattr(settings, \\\"FORCE_DUMMY_MISSING_BILLING_DATA\\\", False):\\n result = {}\\n return result\",\n \"async def __getFromProjectedBill(self, account, premise, currentBillDate) -> dict:\\n data = {}\\n\\n try:\\n async with async_timeout.timeout(TIMEOUT):\\n response = await self.session.get(\\n URL_RESOURCES_PROJECTED_BILL.format(\\n account=account,\\n premise=premise,\\n lastBillDate=currentBillDate.strftime(\\\"%m%d%Y\\\"),\\n )\\n )\\n\\n if response.status == 200:\\n projectedBillData = (await response.json())[\\\"data\\\"]\\n\\n billToDate = float(projectedBillData[\\\"billToDate\\\"])\\n projectedBill = float(projectedBillData[\\\"projectedBill\\\"])\\n dailyAvg = float(projectedBillData[\\\"dailyAvg\\\"])\\n avgHighTemp = int(projectedBillData[\\\"avgHighTemp\\\"])\\n\\n data[\\\"bill_to_date\\\"] = billToDate\\n data[\\\"projected_bill\\\"] = projectedBill\\n data[\\\"daily_avg\\\"] = dailyAvg\\n data[\\\"avg_high_temp\\\"] = avgHighTemp\\n\\n except Exception as e:\\n _LOGGER.error(e)\\n\\n return data\",\n \"def GetAllCostByAmountBandFromDB(lowerLimit, upperLimit):\\n\\n logs.logger.debug(\\\"Start to get back all Cost object from database\\\\\\n based on amount band.\\\")\\n try:\\n searchedCostByAmountBandFromDB = session.query(\\n Cost.Cost).filter(Cost.Cost.amount >= lowerLimit, Cost.Cost.amount <= upperLimit).all()\\n logs.logger.info(\\n \\\"Get back all Cost object from database based on amount band.\\\")\\n return [item for item in searchedCostByAmountBandFromDB]\\n except Exception as e:\\n logs.logger.error(e, exc_info=True)\",\n \"def budget(self):\\n\\n budget = (_House.closing_cost*self.vars['after_repair_value']) - self.vars['purchase_price'] - self.vars['profit'] - _House.broker_fee\\n return float(round(budget, 2))\",\n \"def getBudget(movieInfo):\\n if \\\"budget\\\" in movieInfo:\\n return int(movieInfo[\\\"budget\\\"])\\n else:\\n raise AttributeError(\\\"%s instance has no attribute budget\\\" % movieInfo)\",\n \"def budget_balance(self):\\n budget_balance = round(self.budget() - self.total_spent(), 2)\\n budget_balance_degree = round( (9000 * self.total_spent()) / (self.budget()), 4) #convert to degrees and round to four decimal places\\n return (budget_balance, budget_balance_degree)\",\n \"def get(self):\\n return {'bills': [bill.json() for bill in BillModel.find_all()]}\",\n \"def action_budget_create(self, cr, uid, ids, context=None):\\n payment_term_obj = self.pool.get('account.payment.term')\\n for porder in self.browse(cr, uid, ids, context=context):\\n period = self.pool.get('account.period').find(cr,uid,porder.date_order, context = context)[0] \\n result = []\\n confirmation_dict={\\n 'reference': porder.name,\\n 'period_id': period,\\n 'partner_id':porder.partner_id.id,\\n 'amount': porder.amount_total,\\n 'note':'',\\n 'date':porder.date_order,\\n 'type':'purchase'}\\n\\n for line in porder.order_line:\\n confirmation_ids=[]\\n account_id = self._choose_account_from_po_line(cr, uid, line, context=context)\\n notes = _(\\\"Purchase Approval: %s \\\\nDescription: %s.\\\\nDate: %s \\\\nProducts: %s \\\") % (porder.name , porder.notes , porder.date_order , line.name )\\n\\n result= payment_term_obj.compute(cr, \\n uid, porder.payment_term_id.id, line.price_subtotal,porder.date_order or False, context=context)\\n for r in result:\\n confirmation_dict.update(\\n {'date':r[0],\\n 'amount':r[1],\\n 'note':notes,\\n 'name':'/',\\n 'general_account_id': account_id,\\n 'account_analytic_id': line.account_analytic_id.id or False,\\n })\\n confirmation_id = self.pool.get('account.budget.confirmation').create(cr, uid, confirmation_dict)\\n confirmation_ids.append(confirmation_id)\\n line.write({'confirmation_ids':[(6, 0, confirmation_ids)] ,'state': 'waiting_budget'})\\n self.write(cr, uid, ids, {'state': 'waiting_budget'})\\n return True\",\n \"def budget_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"budget_name\\\")\",\n \"def billing_period(self) -> Optional[str]:\\n return pulumi.get(self, \\\"billing_period\\\")\",\n \"async def __getDataFromBalance(self, account) -> dict:\\n _LOGGER.info(\\\"Getting appliance usage data\\\")\\n\\n data = {}\\n\\n URL_BALANCE = API_HOST + \\\"/api/resources/account/{account}/balance?count=-1\\\"\\n\\n try:\\n async with async_timeout.timeout(TIMEOUT):\\n response = await self.session.get(URL_BALANCE.format(account=account))\\n if response.status == 200:\\n data = (await response.json())[\\\"data\\\"]\\n\\n indice = [i for i, x in enumerate(data) if x[\\\"details\\\"] == \\\"DEBT\\\"][\\n 0\\n ]\\n\\n deb = data[indice][\\\"amount\\\"]\\n\\n except Exception as e:\\n _LOGGER.error(e)\\n\\n return {\\\"balance_data\\\": data}\",\n \"def get_pl_balances(self):\\n\\n\\t\\tdimension_fields = ['t1.cost_center']\\n\\n\\t\\tself.accounting_dimensions = get_accounting_dimensions()\\n\\t\\tfor dimension in self.accounting_dimensions:\\n\\t\\t\\tdimension_fields.append('t1.{0}'.format(dimension))\\n\\n\\t\\treturn frappe.db.sql(\\\"\\\"\\\"\\n\\t\\t\\tselect\\n\\t\\t\\t\\tt1.account, t2.account_currency, {dimension_fields},\\n\\t\\t\\t\\tsum(t1.debit_in_account_currency) - sum(t1.credit_in_account_currency) as bal_in_account_currency,\\n\\t\\t\\t\\tsum(t1.debit) - sum(t1.credit) as bal_in_company_currency\\n\\t\\t\\tfrom `tabGL Entry` t1, `tabAccount` t2\\n\\t\\t\\twhere t1.is_cancelled = 0 and t1.account = t2.name and t2.report_type = 'Profit and Loss'\\n\\t\\t\\tand t2.docstatus < 2 and t2.company = %s\\n\\t\\t\\tand t1.posting_date between %s and %s\\n\\t\\t\\tgroup by t1.account, {dimension_fields}\\n\\t\\t\\\"\\\"\\\".format(dimension_fields = ', '.join(dimension_fields)), (self.company, self.get(\\\"year_start_date\\\"), self.posting_date), as_dict=1)\",\n \"def get_display_price_data(self, source, commitment):\\n overage, included = self.get_price_data(source, commitment)\\n if self.name == settings.BILLING_DEFAULT_PLAN_NAME:\\n included = OFFICIAL_BUILDER_LIMITS[source]\\n return overage, included\",\n \"def get_budget_fixture(thing_being_farmed: int):\\n if thing_being_farmed == 1:\\n path = os.path.join(BASE_DIR, 'fixtures', 'tomato-budget.json')\\n elif thing_being_farmed == 2:\\n path = os.path.join(BASE_DIR, 'fixtures', 'broiler-budget.json')\\n else:\\n return None\\n\\n with open(path, 'r') as budget_fixture:\\n budget = json.load(budget_fixture)\\n\\n return budget\",\n \"def billing_account(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"billing_account\\\")\",\n \"def billing_account(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"billing_account\\\")\",\n \"def billing_account(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"billing_account\\\")\",\n \"def get_bill_details(request):\\n\\n print request\\n\\n context = request['context']\\n print context\\n try:\\n telephone_number = first_entity_value(request['entities'], 'phone_number')\\n with open(os.path.join(sys.path[0], \\\"app/wit/static/users.json\\\"), \\\"r\\\") as data_file:\\n data = json.load(data_file)\\n customer_billing = data[telephone_number]['last_month_billing']\\n print customer_billing\\n\\n customer_type = data[telephone_number]['type_customer']\\n if customer_type == 'postpaid':\\n\\n reply = \\\"Our Initial Investigation shows that you're a \\\" + data[telephone_number]['type_customer'] + \\\" Customer and currently using \\\" + data[telephone_number]['plan_details'] + \\\" plan type.\\\"\\n if customer_billing['roaming'] == 'True':\\n reply += \\\"You had used your cellphone while on roaming for which you were charged extra.\\\"\\n elif customer_billing['data_exhaust'] == 'True':\\n reply += \\\"You had used your data network after your allocated limit was exhausted. You were charged for these services\\\"\\n elif customer_billing['subscribed'] == 'True':\\n reply += \\\"You had subscribed to some promotional services for which you were charged in extra.\\\"\\n else:\\n reply = \\\"Our Initial Investigation shows that you're a \\\" + data[telephone_number]['type_customer'] + \\\". We believe that this might be a mistake from our side and would like you to speak to our customer care executives separately.\\\"\\n\\n\\n except:\\n telephone_number = None\\n reply = \\\"Your number is not subscribed with Airtel. Please contact your network operator for your query\\\"\\n\\n\\n print reply\\n\\n context['bill_details'] = reply\\n\\n return context\",\n \"def get(resource_name: str,\\n id: pulumi.Input[str],\\n opts: Optional[pulumi.ResourceOptions] = None,\\n all_updates_rule: Optional[pulumi.Input[pulumi.InputType['BudgetAllUpdatesRuleArgs']]] = None,\\n amount: Optional[pulumi.Input[pulumi.InputType['BudgetAmountArgs']]] = None,\\n billing_account: Optional[pulumi.Input[str]] = None,\\n budget_filter: Optional[pulumi.Input[pulumi.InputType['BudgetBudgetFilterArgs']]] = None,\\n display_name: Optional[pulumi.Input[str]] = None,\\n name: Optional[pulumi.Input[str]] = None,\\n threshold_rules: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['BudgetThresholdRuleArgs']]]]] = None) -> 'Budget':\\n opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))\\n\\n __props__ = _BudgetState.__new__(_BudgetState)\\n\\n __props__.__dict__[\\\"all_updates_rule\\\"] = all_updates_rule\\n __props__.__dict__[\\\"amount\\\"] = amount\\n __props__.__dict__[\\\"billing_account\\\"] = billing_account\\n __props__.__dict__[\\\"budget_filter\\\"] = budget_filter\\n __props__.__dict__[\\\"display_name\\\"] = display_name\\n __props__.__dict__[\\\"name\\\"] = name\\n __props__.__dict__[\\\"threshold_rules\\\"] = threshold_rules\\n return Budget(resource_name, opts=opts, __props__=__props__)\",\n \"def _fetch_bills(self, options):\\n bill_count = options['max'] or fetch.DEFAULT_BILL_COUNT\\n return fetch.bills(per_page=bill_count)\",\n \"def create_budget(budget_category: BudgetCategory) -> Budget:\\n amount = -1\\n while amount <= 0:\\n amount = float(input(f'Enter {budget_category.value} budget: '))\\n if amount <= 0:\\n print('Budget amount must be greater than 0! Please enter '\\n 'again!')\\n return Budget(budget_category, amount)\",\n \"def get_claim_bill(\\n _db: Session = db, *, start: datetime = None, end: datetime = None,\\n store_internal_id: int = None, owner_id: int = None,\\n kind: models.ClaimKind = None, calculation: CalcType = \\\"avg\\\"\\n):\\n query = crud.claim.get_query(_db)\\n if start and end:\\n query = query.filter(models.Claim.created_at.between(start, end))\\n if store_internal_id:\\n query = query.filter(models.Claim.store_internal_id == store_internal_id)\\n if owner_id:\\n query = query.filter(models.Claim.owner_id == owner_id)\\n if kind:\\n query = query.filter(models.Claim.kind == kind)\\n bill = query.with_entities(getattr(func, calculation)(models.Claim.bill).label(\\\"_bill\\\")).first()\\n bill_round = round(bill[0], 2) if bill[0] is not None else 0.00\\n return bill_round\",\n \"def declare_new_budget(date, exp_data):\\n\\n exp_list = exp_data[env.EXPENSE_DATA_KEY]\\n local_budget = {}\\n month_total = util.get_float_input(\\n f\\\"Please input your total for the month ending {date}: \\\", force_pos=True)\\n budg_remaining = month_total\\n\\n for i, exp in enumerate(exp_list):\\n if i == len(exp_list) - 1:\\n print(\\\"I got the last one for you :) MATH!\\\")\\n budg_amnt = budg_remaining\\n budg_remaining = 0\\n\\n elif budg_remaining == 0: # elif skips this condition if budget remaining is set above\\n budg_amnt = 0\\n local_budget[env.BUDGET_TOTAL_KEY] = month_total\\n else:\\n prompt = f\\\"Enter your budget for: [{exp}] - Total Budget Re. ${budg_remaining} - Exp's Re. [{len(exp_list) - i - 1}]: \\\"\\n budg_amnt = prompt_for_budget_amnt(\\n prompt, budg_remaining, exp_data)\\n local_budget.update({exp: budg_amnt})\\n budg_remaining = round(month_total - sum_budget(local_budget), 2)\\n print(local_budget)\\n return local_budget\",\n \"def get(resource_name: str,\\n id: pulumi.Input[str],\\n opts: Optional[pulumi.ResourceOptions] = None,\\n all_updates_rule: Optional[pulumi.Input[pulumi.InputType['BudgetAllUpdatesRuleArgs']]] = None,\\n amount: Optional[pulumi.Input[pulumi.InputType['BudgetAmountArgs']]] = None,\\n billing_account: Optional[pulumi.Input[str]] = None,\\n budget_filter: Optional[pulumi.Input[pulumi.InputType['BudgetBudgetFilterArgs']]] = None,\\n display_name: Optional[pulumi.Input[str]] = None,\\n name: Optional[pulumi.Input[str]] = None,\\n threshold_rules: Optional[pulumi.Input[List[pulumi.Input[pulumi.InputType['BudgetThresholdRuleArgs']]]]] = None) -> 'Budget':\\n opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))\\n\\n __props__ = dict()\\n\\n __props__[\\\"all_updates_rule\\\"] = all_updates_rule\\n __props__[\\\"amount\\\"] = amount\\n __props__[\\\"billing_account\\\"] = billing_account\\n __props__[\\\"budget_filter\\\"] = budget_filter\\n __props__[\\\"display_name\\\"] = display_name\\n __props__[\\\"name\\\"] = name\\n __props__[\\\"threshold_rules\\\"] = threshold_rules\\n return Budget(resource_name, opts=opts, __props__=__props__)\",\n \"def get_bankcard_obj(self):\\n kwargs = {\\n 'card_number': self.cleaned_data['number'],\\n 'expiry_date': self.cleaned_data['expiry_month'].strftime(\\\"%m/%y\\\"),\\n 'ccv': self.cleaned_data['ccv_number'],\\n }\\n if self.cleaned_data['start_month']:\\n kwargs['start_date'] = self.cleaned_data['start_month'].strftime(\\\"%m/%y\\\")\\n return Bankcard(**kwargs)\",\n \"def budget(config, tag):\\n\\tif tag in config[\\\"budget\\\"].keys():\\n\\t\\tprint(tag)\\n\\telse:\\n\\t\\tprint(config[\\\"budget\\\"].keys())\",\n \"def get(self, args):\\n return Payment.query.offset(args['offset']).limit(args['limit'])\",\n \"def budgetFilter(budget):\\n # Query the database for all the movies\\n movies = Movies.query.order_by(db.asc(Movies.budget)).filter(Movies.budget>=budget).limit(100).all()\\n\\n # Serialize the list of movies from our data\\n movies_schema = MoviesSchema(many=True)\\n data = movies_schema.dump(movies)\\n return data\",\n \"def get_budget_by_name(self, budget_name):\\n return next((budget for budget in self.budgets\\n if budget.name.lower() == budget_name.lower()), None)\",\n \"def month():\\n \\n # get month entered by user - if no month entered default to current month\\n month = request.args.get(\\\"month\\\", datetime.now().strftime(\\\"%Y-%m\\\"))\\n \\n # get budget data for month as a dictionary\\n data = budget_data(month)\\n \\n return json.dumps(data)\",\n \"def handle(self):\\n self.validate()\\n if self.errors:\\n raise InvalidDataException(self.errors)\\n\\n phone_number = self.data.get('phone_number')\\n month = self.data.get('month')\\n year = self.data.get('year')\\n\\n # if a period was not informed, get the current last one\\n if not month and not year:\\n year, month = last_period()\\n\\n bill_data = Bill.data_by_number_period(phone_number, month, year)\\n return bill_data\",\n \"def get_config(self, budget):\\n\\t\\traise NotImplementedError('This function needs to be overwritten in %s.'%(self.__class__.__name__))\",\n \"def _get_fwl_billing_item(self, firewall_id, dedicated=False):\\r\\n mask = ('mask[id,billingItem[id]]')\\r\\n if dedicated:\\r\\n fwl_svc = self.client['Network_Vlan_Firewall']\\r\\n else:\\r\\n fwl_svc = self.client['Network_Component_Firewall']\\r\\n return fwl_svc.getObject(id=firewall_id, mask=mask)\",\n \"def get_transfer_bid(self):\\n api_uri = self._uri_dict.get('getTransferBid')\\n data = {}\\n r_data = self._post(api_uri, data)\\n return r_data\",\n \"def get_bank(self):\\n return self._bank\",\n \"def get_spend_by_campaign_this_month(self, account_id):\\n try:\\n account = DependentAccount.objects.get(id=account_id)\\n except DependentAccount.DoesNotExist:\\n return\\n\\n client = get_client()\\n client.client_customer_id = account.dependent_account_id\\n\\n report_downloader = client.GetReportDownloader(version=settings.API_VERSION)\\n\\n campaign_report_selector = {\\n 'fields': ['Cost', 'CampaignId', 'CampaignStatus', 'CampaignName', 'Labels', 'Impressions'],\\n 'predicates': [\\n {\\n 'field': 'Cost',\\n 'operator': 'GREATER_THAN',\\n 'values': '0'\\n }\\n ]\\n }\\n\\n campaign_report_query = {\\n 'reportName': 'CAMPAIGN_PERFORMANCE_REPORT',\\n 'dateRangeType': 'THIS_MONTH',\\n 'reportType': 'CAMPAIGN_PERFORMANCE_REPORT',\\n 'downloadFormat': 'CSV',\\n 'selector': campaign_report_selector\\n }\\n\\n in_use_ids = []\\n\\n campaign_report = Reporting.parse_report_csv_new(report_downloader.DownloadReportAsString(campaign_report_query))\\n for campaign_row in campaign_report:\\n print(campaign_row)\\n campaign_id = campaign_row['campaign_id']\\n in_use_ids.append(campaign_row['campaign_id'])\\n campaign, created = Campaign.objects.get_or_create(campaign_id=campaign_id, account=account)\\n # Update campaign name\\n campaign.campaign_name = campaign_row['campaign']\\n # This is the cost for this month\\n cost = int(campaign_row['cost']) / 1000000\\n campaign.campaign_cost = cost\\n campaign.save()\\n print('Campaign: ' + str(campaign) + ' now has a spend this month of $' + str(campaign.campaign_cost))\\n\\n today = datetime.datetime.today()\\n\\n if today.day != 1:\\n yesterday = datetime.datetime.now() - datetime.timedelta(1)\\n first_day_of_month = datetime.datetime(yesterday.year, yesterday.month, 1)\\n\\n campaign_report_selector = {\\n 'fields': ['Cost', 'CampaignId', 'CampaignStatus', 'CampaignName', 'Labels', 'Impressions'],\\n 'predicates': [\\n {\\n 'field': 'Cost',\\n 'operator': 'GREATER_THAN',\\n 'values': '0'\\n }\\n ]\\n }\\n\\n campaign_report_query = {\\n 'reportName': 'CAMPAIGN_PERFORMANCE_REPORT',\\n 'dateRangeType': 'CUSTOM_DATE',\\n 'reportType': 'CAMPAIGN_PERFORMANCE_REPORT',\\n 'downloadFormat': 'CSV',\\n 'selector': campaign_report_selector\\n }\\n\\n start_date = first_day_of_month\\n end_date = yesterday\\n\\n campaign_report_selector['dateRange'] = {\\n 'min': start_date.strftime('%Y%m%d'),\\n 'max': end_date.strftime('%Y%m%d')\\n }\\n\\n campaign_yest_report = Reporting.parse_report_csv_new(\\n report_downloader.DownloadReportAsString(campaign_report_query))\\n for campaign_row in campaign_yest_report:\\n campaign_id = campaign_row['campaign_id']\\n campaign, created = Campaign.objects.get_or_create(campaign_id=campaign_id, account=account)\\n campaign.campaign_name = campaign_row['campaign']\\n # This is the cost for this month until yesterday\\n spend_until_yesterday = int(campaign_row['cost']) / 1000000\\n campaign.spend_until_yesterday = spend_until_yesterday\\n campaign.save()\\n print(\\n 'Campaign: ' + str(campaign) + ' has spend until yesterday of $' + str(campaign.spend_until_yesterday))\\n\\n return 'get_spend_by_campaign_this_month'\",\n \"def test_companies_company_id_data_bill_credit_notes_get(self):\\n pass\",\n \"def billing_info_list(request):\\n if request.method == 'GET':\\n billing_infos = BillingInfo.objects.all()\\n serializer = BillingInfoSerializer(billing_infos, many=True)\\n return JSONResponse(serializer.data)\\n\\n elif request.method == 'POST':\\n data = JSONParser().parse(request)\\n serializer = BillingInfoSerializer(data=data)\\n if serializer.is_valid():\\n serializer.save()\\n return JSONResponse(serializer.data, status=201)\\n return JSONResponse(serializer.errors, status=400)\",\n \"async def fetch_balance(self, params={}):\\n await self.load_markets()\\n request = {\\n 'currency': 'all',\\n }\\n response = await self.privateGetUserMargin(self.extend(request, params))\\n #\\n # [\\n # {\\n # \\\"account\\\":1455728,\\n # \\\"currency\\\":\\\"XBt\\\",\\n # \\\"riskLimit\\\":1000000000000,\\n # \\\"prevState\\\":\\\"\\\",\\n # \\\"state\\\":\\\"\\\",\\n # \\\"action\\\":\\\"\\\",\\n # \\\"amount\\\":263542,\\n # \\\"pendingCredit\\\":0,\\n # \\\"pendingDebit\\\":0,\\n # \\\"confirmedDebit\\\":0,\\n # \\\"prevRealisedPnl\\\":0,\\n # \\\"prevUnrealisedPnl\\\":0,\\n # \\\"grossComm\\\":0,\\n # \\\"grossOpenCost\\\":0,\\n # \\\"grossOpenPremium\\\":0,\\n # \\\"grossExecCost\\\":0,\\n # \\\"grossMarkValue\\\":0,\\n # \\\"riskValue\\\":0,\\n # \\\"taxableMargin\\\":0,\\n # \\\"initMargin\\\":0,\\n # \\\"maintMargin\\\":0,\\n # \\\"sessionMargin\\\":0,\\n # \\\"targetExcessMargin\\\":0,\\n # \\\"varMargin\\\":0,\\n # \\\"realisedPnl\\\":0,\\n # \\\"unrealisedPnl\\\":0,\\n # \\\"indicativeTax\\\":0,\\n # \\\"unrealisedProfit\\\":0,\\n # \\\"syntheticMargin\\\":null,\\n # \\\"walletBalance\\\":263542,\\n # \\\"marginBalance\\\":263542,\\n # \\\"marginBalancePcnt\\\":1,\\n # \\\"marginLeverage\\\":0,\\n # \\\"marginUsedPcnt\\\":0,\\n # \\\"excessMargin\\\":263542,\\n # \\\"excessMarginPcnt\\\":1,\\n # \\\"availableMargin\\\":263542,\\n # \\\"withdrawableMargin\\\":263542,\\n # \\\"timestamp\\\":\\\"2020-08-03T12:01:01.246Z\\\",\\n # \\\"grossLastValue\\\":0,\\n # \\\"commission\\\":null\\n # }\\n # ]\\n #\\n return self.parse_balance(response)\",\n \"def get_customer_balance_sheet(self):\\n total = 0\\n taxes = 0\\n balances = 0\\n un_paid_count = 0\\n conflicts = 0\\n unresolved_conflicts = 0\\n projected_before_tax = 0\\n\\n invoice_list = Customer_Invoice.objects.all()\\n count = len(invoice_list)\\n for invoice in invoice_list:\\n if invoice.invoice_quote.total_price_quoted:\\n total += invoice.invoice_quote.total_price_quoted\\n taxes += invoice.invoice_quote.tax_on_quote\\n balances += invoice.get_balance_due()\\n else:\\n projected = invoice.get_cost()\\n projected_before_tax += projected[1]\\n if not invoice.paid_in_full:\\n un_paid_count += 1\\n for conflict in invoice.conflict.all():\\n conflicts += 1\\n if not conflict.conflict_resolution:\\n unresolved_conflicts += 1\\n profit = total - taxes\\n\\n return total, taxes, profit, balances, count, conflicts, unresolved_conflicts, projected_before_tax\",\n \"def default_billing(self):\\n return self._default_billing\",\n \"def get_budget(\\n self, f=None, names=None, zones=None, net=False, pivot=False\\n ):\\n aliases = None\\n if self._zon is not None:\\n aliases = self._zon.aliases\\n\\n if f is None and self._recarray is None:\\n f = os.path.join(self._model_ws, f\\\"{self._name}.csv\\\")\\n self._recarray = _read_zb_csv2(\\n f, add_prefix=False, aliases=aliases\\n )\\n elif f is None:\\n pass\\n else:\\n self._recarray = _read_zb_csv2(\\n f, add_prefix=False, aliases=aliases\\n )\\n\\n recarray = _get_budget(\\n self._recarray,\\n self._zon._zonenamedict,\\n names=names,\\n zones=zones,\\n net=net,\\n )\\n\\n if pivot:\\n recarray = _pivot_recarray(recarray)\\n\\n return recarray\",\n \"def get_billing_document(self):\\n if self.rut:\\n return self.rut\\n elif self.billing_id_doc:\\n return self.billing_id_doc\\n else:\\n return self.contact.id_document\",\n \"def plan_list_get(request):\\n return list_by_company_guid(request, PlanModel)\",\n \"def get_transactions_for_budget(self, budget_name=None):\\n if len(self.budgets) > 1 and budget_name is None:\\n self._logger.error('There are multiple budgets and no budget name was provided')\\n raise MultipleBudgets\\n if budget_name is None:\\n self._logger.debug('No budget name provided returning the only budget registered')\\n budget = self.budgets[0]\\n else:\\n self._logger.debug('Trying to retrieve budget with name \\\"%s\\\"', budget_name)\\n budget = next((budget for budget in self.budgets\\n if budget.name.lower() == budget_name.lower()), None)\\n if not budget:\\n return []\\n return [YnabServerTransaction(transaction, transaction.account)\\n for transaction in budget.transactions]\",\n \"def retrieve(self, request, *args, **kwargs):\\n return super(BalanceBillsViewSet, self).retrieve(\\n request,\\n *args,\\n **kwargs\\n )\",\n \"def billing_account(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"billing_account\\\")\",\n \"def billing_account(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"billing_account\\\")\",\n \"def test_companies_company_id_data_bank_accounts_account_id_transactions_get(self):\\n pass\",\n \"def GetAllCostByDateOfPaymentBandFromDB(startDate, endDate):\\n\\n logs.logger.debug(\\n \\\"Start to get back all Cost object from database \\\"\\n \\\"based on payment date band.\\\")\\n try:\\n searchedCostByDateOfPaymentBandFromDB = session.query(\\n Cost.Cost).filter(Cost.Cost.dateOfPayment >= startDate, Cost.Cost.dateOfPayment <= endDate).all()\\n logs.logger.info(\\n \\\"Get back all Cost object from database \\\"\\n \\\"based on payment date band.\\\")\\n return [item for item in searchedCostByDateOfPaymentBandFromDB]\\n except Exception as e:\\n logs.logger.error(e, exc_info=True)\",\n \"def balance(self):\\n balance = {'A': 0, 'B': 0}\\n account_balances = AccountBalance.objects.filter(\\n organization_id=self.id,\\n expiration_date=None\\n ).order_by('-id')\\n\\n credit_class = CreditClass.objects.filter(credit_class=\\\"A\\\").first()\\n for account_balance in account_balances:\\n if account_balance.credit_class_id == credit_class.id:\\n balance['A'] = account_balance.balance\\n else:\\n balance['B'] = account_balance.balance\\n return balance\",\n \"def test_retrieve_all_by_bank(self):\\n swa = frontend.SupplyWinApi()\\n query_dict = dict(\\n dev=\\\"rrenaud\\\",\\n targets=\\\"\\\",\\n interaction=\\\"Bank\\\",\\n unconditional=\\\"true\\\",\\n )\\n\\n card_stats = swa.retrieve_data(query_dict)\\n\\n # Gets 288 entries back, because one for each of the 144\\n # cards, plus the unconditioned version of each\\n self.assertEquals(len(card_stats), 288)\\n\\n self.assertEquals(card_stats[0]['card_name'], 'Adventurer')\\n\\n json = swa.readable_json_card_stats(card_stats)\\n self.assertEquals(json[0:14], '[{\\\"card_name\\\":')\",\n \"def test_get_virtual_account_beneficiary(self):\\n pass\",\n \"def budget_filter(self) -> pulumi.Output['outputs.BudgetBudgetFilter']:\\n return pulumi.get(self, \\\"budget_filter\\\")\",\n \"def getBudgetBalance(self, budgetName):\\r\\n assert budgetName in self.budgets, \\\"Specified budget doesn't exist\\\"\\r\\n return \\\"%.2f\\\" % float(self.budgets[budgetName])\",\n \"def billing_account(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"billing_account\\\")\",\n \"def billing_account(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"billing_account\\\")\",\n \"def fetch_balance(self, params={}):\\n self.load_markets()\\n response = self.privateGetAccountBalanceV2(params)\\n #\\n # {\\n # \\\"AVAILABLE_NIS\\\": 0.0,\\n # \\\"NIS\\\": 0.0,\\n # \\\"LOCKED_NIS\\\": 0.0,\\n # \\\"AVAILABLE_BTC\\\": 0.0,\\n # \\\"BTC\\\": 0.0,\\n # \\\"LOCKED_BTC\\\": 0.0,\\n # \\\"AVAILABLE_ETH\\\": 0.0,\\n # \\\"ETH\\\": 0.0,\\n # \\\"LOCKED_ETH\\\": 0.0,\\n # \\\"AVAILABLE_BCHSV\\\": 0.0,\\n # \\\"BCHSV\\\": 0.0,\\n # \\\"LOCKED_BCHSV\\\": 0.0,\\n # \\\"AVAILABLE_BCHABC\\\": 0.0,\\n # \\\"BCHABC\\\": 0.0,\\n # \\\"LOCKED_BCHABC\\\": 0.0,\\n # \\\"AVAILABLE_LTC\\\": 0.0,\\n # \\\"LTC\\\": 0.0,\\n # \\\"LOCKED_LTC\\\": 0.0,\\n # \\\"AVAILABLE_ETC\\\": 0.0,\\n # \\\"ETC\\\": 0.0,\\n # \\\"LOCKED_ETC\\\": 0.0,\\n # \\\"AVAILABLE_BTG\\\": 0.0,\\n # \\\"BTG\\\": 0.0,\\n # \\\"LOCKED_BTG\\\": 0.0,\\n # \\\"AVAILABLE_GRIN\\\": 0.0,\\n # \\\"GRIN\\\": 0.0,\\n # \\\"LOCKED_GRIN\\\": 0.0,\\n # \\\"Fees\\\": {\\n # \\\"BtcNis\\\": {\\\"FeeMaker\\\": 1.0, \\\"FeeTaker\\\": 1.0},\\n # \\\"EthNis\\\": {\\\"FeeMaker\\\": 1.0, \\\"FeeTaker\\\": 1.0},\\n # \\\"BchabcNis\\\": {\\\"FeeMaker\\\": 1.0, \\\"FeeTaker\\\": 1.0},\\n # \\\"LtcNis\\\": {\\\"FeeMaker\\\": 1.0, \\\"FeeTaker\\\": 1.0},\\n # \\\"EtcNis\\\": {\\\"FeeMaker\\\": 1.0, \\\"FeeTaker\\\": 1.0},\\n # \\\"BtgNis\\\": {\\\"FeeMaker\\\": 1.0, \\\"FeeTaker\\\": 1.0},\\n # \\\"LtcBtc\\\": {\\\"FeeMaker\\\": 1.0, \\\"FeeTaker\\\": 1.0},\\n # \\\"BchsvNis\\\": {\\\"FeeMaker\\\": 1.0, \\\"FeeTaker\\\": 1.0},\\n # \\\"GrinNis\\\": {\\\"FeeMaker\\\": 1.0, \\\"FeeTaker\\\": 1.0}\\n # }\\n # }\\n #\\n return self.parse_balance(response)\",\n \"def get():\\n\\n # \\\\todo List of available data, fetched and processed\\n\\n return jsonify({'valid_resources': ['balance', 'balance_usd', 'trade_history', 'balance_norm_price_history', 'open_orders']})\",\n \"def get_campaign_cost(self, id):\\n logger.info(\\\"Function call: get_campaign_cost: '{}'\\\".format(id, ))\\n return self.__handle_error(\\\"Empty addressbook id\\\") if not id else self.__handle_result(self.__send_request('addressbooks/{}/cost'.format(id)))\",\n \"def test_get_virtual_account_beneficiaries(self):\\n pass\",\n \"def get_amount():\\n conn = None\\n try:\\n params = config()\\n conn = psycopg2.connect(**params)\\n cur = conn.cursor()\\n\\n #tas\\n raw={}\\n raw['plan']={}\\n raw['actual']={}\\n\\n cur.execute(\\\"SELECT slc.*,plc.amount as amount_plan,ppm.amount as price \\\\\\n ,to_char((slc.amount*ppm.amount)/aco.amount_actual_coal,'999.999') as cost_actual \\\\\\n , to_char((plc.amount*ppm.amount)/aco.amount_actual_coal,'999.999') as cost_plan \\\\\\n ,aco.amount_actual_coal \\\\\\n FROM vw_tta_cps_sum_land_clearing_now AS slc \\\\\\n LEFT JOIN vw_tta_cps_price_per_month AS ppm \\\\\\n ON slc.int_month=ppm.month \\\\\\n AND slc.year_id=ppm.year_id \\\\\\n LEFT JOIN vw_tta_cps_plan_land_clearing AS plc \\\\\\n ON slc.periode_month_id=plc.periode_month_id \\\\\\n AND slc.land_clearing_location_id=plc.land_clearing_location_id \\\\\\n LEFT JOIN vw_tta_cps_sr_all_per_month_plan_actual as aco \\\\\\n ON aco.int_month=slc.int_month \\\\\\n WHERE ppm.jenis_price=10 \\\\\\n AND aco.plan_id=1\\\")\\n rowcount=cur.rowcount\\n print(\\\"The number of row: \\\", rowcount)\\n row = cur.fetchone()\\n counter=0\\n item={}\\n\\n if rowcount>0:\\n f=open('../../data_cost_per_ton.csv','w')\\n f.write('AREA,PLAN,ACTUAL\\\\n')\\n while row is not None:\\n #print(row)\\n raw[\\\"plan\\\"]=row[11]\\n raw[\\\"actual\\\"]=row[10]\\n f.write(str('RAW')+','+str(raw[\\\"plan\\\"])+','+str(raw[\\\"actual\\\"])+\\\"\\\\n\\\")\\n\\n row = cur.fetchone()\\n\\n if rowcount>0:\\n f.close()\\n cur.close()\\n\\n print(str(datetime.datetime.now())+' '+str(rowcount)+' row updated')\\n except (Exception, psycopg2.DatabaseError) as error:\\n print(str(datetime.datetime.now())+' '+str(error))\\n finally:\\n if conn is not None:\\n conn.close()\",\n \"def get_all_spend_by_campaign_custom(self):\\n budgets = Budget.objects.filter(has_adwords=True, is_monthly=False)\\n for budget in budgets:\\n for aw_account in budget.account.adwords.all():\\n if settings.DEBUG:\\n get_spend_by_campaign_custom(budget.id, aw_account.id)\\n else:\\n get_spend_by_campaign_custom.delay(budget.id, aw_account.id)\\n\\n return 'get_all_spend_by_campaign_custom'\",\n \"def sum_budget(monthly_budget: dict):\\n sum = 0\\n for k, v in monthly_budget.items():\\n if v is not None and k != env.BUDGET_TOTAL_KEY:\\n sum += v\\n\\n return sum\",\n \"def get_entity_contracts():\\n url = 'http://www.base.gov.pt/base2/rest/contratos?' \\\\\\n 'adjudicatariaid=%d' % entity.base_id\\n\\n response = requests.get(url, headers={'Range': 'items=0-1000000'})\\n return json.loads(response.text)\",\n \"def FundingInfo(self, default=[{}]):\\n tmp = self.data.get('metadata', {}).get('funding_info', default)\\n return [HEP.FundingObject(i) for i in tmp]\",\n \"def complete(self, cr, uid, ids, context={}):\\n budget_pool = self.pool.get('account.budget')\\n budget_line_pool = self.pool.get('account.budget.lines')\\n for r in self.browse(cr, uid, ids, context=context):\\n if r.type=='transfer' and not r.line_ids:\\n raise osv.except_osv(_('Error!'),_('You cannot complete Transfer Operations without any Budget line.'))\\n if r.budget_type=='cash':\\n budget_ids = budget_pool.search(cr, uid,[('analytic_account_id', '=', r.analytic_account_id.id), \\n ('period_id', '=', r.period_id.id)], context=context)\\n budget_line_id = budget_line_pool.search(cr, uid,[('general_account_id', '=', r.account_id.id), \\n ('account_budget_id', 'in', tuple(budget_ids))], context=context)\\n if budget_line_id:\\n line=budget_line_pool.browse(cr, uid, budget_line_id, context=context)[0]\\n if line.planned_amount+line.total_operation < line.cash_total_operation + r.amount:\\n raise orm.except_orm(_('Error!'),\\n _(\\\"Cash budget (%s) can't be more than planned budget (%s)!\\\") % \\\\\\n ( line.cash_total_operation+ r.amount,line.planned_amount+line.total_operation ,))\\n if line.cash_residual_balance + r.amount <=0:\\n raise orm.except_orm(_('Error!'),\\n _(\\\"The amount you try to transfer (%s) is more than %s residual (%s)!\\\") % \\\\\\n (r.amount, line.name, line.cash_residual_balance,))\\n for e in r.line_ids:\\n if line.planned_amount+line.total_operation < line.cash_total_operation - r.amount:\\n raise orm.except_orm(_('Error!'),\\n _(\\\"Cash budget (%s) can't be more than planned budget (%s)!\\\") % \\\\\\n ( e.cash_total_operation- r.amount,line.planned_amount+line.total_operation ,))\\n if e.line_id.cash_residual_balance - e.amount <=0:\\n raise orm.except_orm(_('Error!'),\\n _(\\\"The amount you try to transfer (%s) is more than %s residual (%s)!\\\") % \\\\\\n (e.amount, e.line_id.name, e.line_id.cash_residual_balance,))\\n return self.write(cr, uid, ids,{'state':'complete','name': r.name == '/' and \\n self.pool.get('ir.sequence').get(cr, uid, 'account.budget.operation') or \\n r.name, 'amount': r.type=='increase' and r.amount or sum([l.amount for l in r.line_ids])}, context=context)\\n \\n return super(account_budget_operation, self).complete(cr, uid, ids, context=context)\",\n \"def get_business(api_key, business_id):\\n\\n business_path = BUSINESS_PATH + business_id\\n\\n\\n return request(API_HOST, business_path, api_key)\",\n \"def test_companies_company_id_data_tax_rates_get(self):\\n pass\",\n \"def bcp_get(self, **kwargs):\\n pass\",\n \"def get_pending_orders(self):\\n\\n r = requests.get(build_api_call(self.base_url, ACCOUNTID, 'pending', ''), auth=HTTPBasicAuth(KEY, SECRET))\\n\\n if r.status_code == 200:\\n return r.json()\\n else:\\n return 'error'\",\n \"def billing(self, account_id):\\n from pureport_client.commands.accounts.billing import Command\\n return Command(self.client, account_id)\",\n \"def add_budget(self, budget: Budget) -> None:\\n self.budgets[budget.category] = budget\",\n \"def get_list() -> List[BankDetails]:\\n from paynlsdk.client.transaction import Transaction\\n return Transaction.get_banks().banks\",\n \"def get_broilers_budget(chickens: int = 1):\\n budget = get_budget_fixture(thing_being_farmed=2)\\n\\n for i, segment in enumerate(budget['segments']):\\n for i2, activity in enumerate(segment['activities']):\\n for i3, item in enumerate(activity['inputs']):\\n new_price = chickens * item['price']\\n item['estimated_price'] = new_price\\n item['price'] = new_price\\n\\n return budget\",\n \"def ListUserBillingCycles(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def payback_form_data(self):\\n return {\\n 'date': date.today(),\\n 'who_from': 'Georgie',\\n 'who_to': 'Tristan',\\n 'amount': 50,\\n 'currency': 'GBP',\\n 'method': 'Bank_transfer'\\n }\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66888595","0.6544355","0.64032984","0.6293646","0.62567914","0.625594","0.62317514","0.6158417","0.6107173","0.60221004","0.59583","0.586195","0.58142555","0.57493407","0.56994355","0.5688151","0.5630534","0.5616468","0.56075585","0.5590992","0.5573143","0.55689305","0.5564759","0.5552304","0.5542231","0.5503946","0.5483847","0.54810107","0.5463703","0.5454207","0.54327214","0.5428958","0.5427901","0.5408684","0.54038906","0.53833085","0.5379731","0.5376678","0.5376678","0.5376678","0.5372952","0.5372906","0.5368391","0.5355997","0.53545624","0.5341898","0.5340229","0.533204","0.5324086","0.5323478","0.5316224","0.5310702","0.53087777","0.5307988","0.53072894","0.5307256","0.53048205","0.5294596","0.52943766","0.52919644","0.52812916","0.52805215","0.5272894","0.52713424","0.5268449","0.52536476","0.5226082","0.5223371","0.52058595","0.5205518","0.5205518","0.520527","0.52027977","0.5192338","0.51843125","0.51392907","0.51351047","0.51324564","0.5121087","0.5121087","0.5114291","0.5113227","0.5111747","0.5104885","0.50985074","0.50979","0.5093064","0.5085721","0.50799024","0.5077532","0.5069483","0.50647444","0.5062828","0.5062258","0.50568414","0.50560707","0.5049608","0.5045234","0.5042542","0.5039526"],"string":"[\n \"0.66888595\",\n \"0.6544355\",\n \"0.64032984\",\n \"0.6293646\",\n \"0.62567914\",\n \"0.625594\",\n \"0.62317514\",\n \"0.6158417\",\n \"0.6107173\",\n \"0.60221004\",\n \"0.59583\",\n \"0.586195\",\n \"0.58142555\",\n \"0.57493407\",\n \"0.56994355\",\n \"0.5688151\",\n \"0.5630534\",\n \"0.5616468\",\n \"0.56075585\",\n \"0.5590992\",\n \"0.5573143\",\n \"0.55689305\",\n \"0.5564759\",\n \"0.5552304\",\n \"0.5542231\",\n \"0.5503946\",\n \"0.5483847\",\n \"0.54810107\",\n \"0.5463703\",\n \"0.5454207\",\n \"0.54327214\",\n \"0.5428958\",\n \"0.5427901\",\n \"0.5408684\",\n \"0.54038906\",\n \"0.53833085\",\n \"0.5379731\",\n \"0.5376678\",\n \"0.5376678\",\n \"0.5376678\",\n \"0.5372952\",\n \"0.5372906\",\n \"0.5368391\",\n \"0.5355997\",\n \"0.53545624\",\n \"0.5341898\",\n \"0.5340229\",\n \"0.533204\",\n \"0.5324086\",\n \"0.5323478\",\n \"0.5316224\",\n \"0.5310702\",\n \"0.53087777\",\n \"0.5307988\",\n \"0.53072894\",\n \"0.5307256\",\n \"0.53048205\",\n \"0.5294596\",\n \"0.52943766\",\n \"0.52919644\",\n \"0.52812916\",\n \"0.52805215\",\n \"0.5272894\",\n \"0.52713424\",\n \"0.5268449\",\n \"0.52536476\",\n \"0.5226082\",\n \"0.5223371\",\n \"0.52058595\",\n \"0.5205518\",\n \"0.5205518\",\n \"0.520527\",\n \"0.52027977\",\n \"0.5192338\",\n \"0.51843125\",\n \"0.51392907\",\n \"0.51351047\",\n \"0.51324564\",\n \"0.5121087\",\n \"0.5121087\",\n \"0.5114291\",\n \"0.5113227\",\n \"0.5111747\",\n \"0.5104885\",\n \"0.50985074\",\n \"0.50979\",\n \"0.5093064\",\n \"0.5085721\",\n \"0.50799024\",\n \"0.5077532\",\n \"0.5069483\",\n \"0.50647444\",\n \"0.5062828\",\n \"0.5062258\",\n \"0.50568414\",\n \"0.50560707\",\n \"0.5049608\",\n \"0.5045234\",\n \"0.5042542\",\n \"0.5039526\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7448803"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":7296,"cells":{"query":{"kind":"string","value":"get data from appliance usage"},"document":{"kind":"string","value":"async def __getDataFromApplianceUsage(self, account, lastBilledDate) -> dict:\n _LOGGER.info(\"Getting appliance usage data\")\n\n JSON = {\"startDate\": str(lastBilledDate.strftime(\"%m%d%Y\"))}\n data = {}\n\n try:\n async with async_timeout.timeout(TIMEOUT):\n response = await self.session.post(\n URL_APPLIANCE_USAGE.format(account=account), json=JSON\n )\n if response.status == 200:\n electric = (await response.json())[\"data\"][\"electric\"]\n\n full = 100\n for e in electric:\n rr = round(float(e[\"percentageDollar\"]))\n if rr < full:\n full = full - rr\n else:\n rr = full\n data[e[\"category\"].replace(\" \", \"_\")] = rr\n except Exception as e:\n _LOGGER.error(e)\n\n return {\"energy_percent_by_applicance\": data}"},"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 getUsageInfo(self):\n return self.jsonRequest(\"/api/v1/usage\", { \"apiKey\": self._apiKey })","def get_application_api_usage_get(self, applicationId, end, start):\n # TODO: Assuming first server is good - need to make fallback logic\n return self.session.get_any(\"{base}{request_url}\".format(base=self.servers[0],\n request_url=F\"/App/ApiUsage/{applicationId}/\"))","def get_usage_data(username, password):\n usage_req = XfinityUsage(username, password, browser_name=\"firefox-headless\")\n return usage_req.run()","def test_getusage(self):\n ret = {\"message\": \"No Random.org api key or api version found.\", \"res\": False}\n self.assertDictEqual(random_org.getUsage(), ret)\n\n self.assertDictEqual(\n random_org.getUsage(api_key=\"peW\", api_version=\"1\"),\n {\n \"bitsLeft\": None,\n \"requestsLeft\": None,\n \"res\": True,\n \"totalBits\": None,\n \"totalRequests\": None,\n },\n )","async def __getDataFromBalance(self, account) -> dict:\n _LOGGER.info(\"Getting appliance usage data\")\n\n data = {}\n\n URL_BALANCE = API_HOST + \"/api/resources/account/{account}/balance?count=-1\"\n\n try:\n async with async_timeout.timeout(TIMEOUT):\n response = await self.session.get(URL_BALANCE.format(account=account))\n if response.status == 200:\n data = (await response.json())[\"data\"]\n\n indice = [i for i, x in enumerate(data) if x[\"details\"] == \"DEBT\"][\n 0\n ]\n\n deb = data[indice][\"amount\"]\n\n except Exception as e:\n _LOGGER.error(e)\n\n return {\"balance_data\": data}","def retr_devices_by_app( app ) :\n\n\t\t\t_logger.info( '...retr_devices_by_app...' )\n\t\t\toutput = []\n\t\t\ttry :\n\t\t\t\tdb = mongo.db.auth_devices\n\t\t\t\tfor device in db.find( { 'app_tags' : app } ) :\n\t\t\t\t\toutput.append({'moniker' : device['moniker'] ,\n\t\t\t\t\t\t\t\t 'description' : device['description'] ,\n\t\t\t\t\t\t\t\t 'active' : device['active'] ,\n\t\t\t\t\t\t\t\t 'device_id' : device['device_id'] ,\n\t\t\t\t\t\t\t\t 'enlisted' : device['enlisted'] ,\n\t\t\t\t\t\t\t\t 'last_kown_remote_ip' : device['last_known_remote_ip'] ,\n\t\t\t\t\t\t\t\t 'engaged' : device['engaged'] ,\n\t\t\t\t\t\t\t\t 'canononical_user' : device['canonical_user'] ,\n\t\t\t\t\t\t\t\t 'scope' : device['scope'] ,\n\t\t\t\t\t\t\t\t 'segment' : device['segment']\n\t\t\t\t\t})\n\t\t\texcept Exception as e :\n\t\t\t\t _logger.error( '...retr_devices_by_app %s' % e.message )\n\t\t\treturn jsonify({'result' : output})","def get_data():\n pass","def get_info():\n global PERF_APP\n archs = None\n best_arch = None\n cipher_algos = None\n hash_algos = None\n aead_algos = None\n\n cmd = PERF_APP + ' --print-info'\n\n try:\n res = subprocess.run(cmd, stdout=subprocess.PIPE, \\\n stderr=subprocess.STDOUT, \\\n env=ENVS, shell=True, check=True)\n output = res.stdout.decode('utf-8')\n except subprocess.CalledProcessError as e:\n print(\"Error (\" + str(e.returncode) + \")\")\n print(e.output.decode('utf-8'))\n sys.exit(1)\n\n lines = output.rstrip().split('\\n')\n try:\n for line in lines:\n info = line.split(':')\n if info[0] == 'Supported architectures':\n archs = info[1].split()\n if info[0] == 'Best architecture':\n best_arch = info[1].split()\n if info[0] == 'Supported cipher algorithms':\n cipher_algos = info[1].split()\n if info[0] == 'Supported hash algorithms':\n hash_algos = info[1].split()\n if info[0] == 'Supported aead algorithms':\n aead_algos = info[1].split()\n except:\n print(\"Error parsing --print-info output:\\n\" \\\n \"{}\".format(output), file=sys.stderr)\n\n if archs is None or best_arch is None or cipher_algos is None \\\n or hash_algos is None or aead_algos is None:\n print(\"Error parsing system and app information\", file=sys.stderr)\n sys.exit(1)\n\n return archs, best_arch, cipher_algos, hash_algos, aead_algos","def usage(self, host):","def getInfo():","def print_app_data(self):\n print(\"===================================\")\n print(\"== RESULTS: ==\")\n print(\"===================================\")\n\n # Analog application results\n print(\"--------------------------\")\n print(\"-- Analog applications --\")\n print(\"--------------------------\")\n print(\"Number of analog application processed: {}\".format(len(self.analog_apps)))\n if (self.verbose):\n for app in self.analog_apps:\n print(\" Application data:\")\n print(\" - - - - - - - - - - - - -\")\n print(' - EPICS PREFIX: MPLN:{}:{}:{}'.format(app[\"link_node_area\"].upper(), app[\"link_node_location\"].upper(), app[\"card_index\"]))\n print(\" - App ID : {}\".format(app[\"app_id\"]))\n print(\" - Cpu name : {}\".format(app[\"cpu_name\"]))\n print(\" - Crate ID : {}\".format(app[\"crate_id\"]))\n print(\" - Slot number : {}\".format(app[\"slot_number\"]))\n print(\" - Link node name : {}\".format(app[\"link_node_name\"]))\n print(\" - Link node area : {}\".format(app[\"link_node_area\"]))\n print(\" - Link node location : {}\".format(app[\"link_node_location\"]))\n print(\" - Card index : {}\".format(app[\"card_index\"]))\n print(\" - Number of devices : {}\".format(len(app[\"devices\"])))\n for device in app[\"devices\"]:\n print(\" Device data:\")\n print(\" .....................\")\n print(\" - EPICS PREFIX: {}:{}:{}\".format(device[\"type_name\"], device[\"area\"], device[\"position\"]))\n print(\" - Type name : {}\".format(device[\"type_name\"]))\n print(\" - Bay number : {}\".format(device[\"bay_number\"]))\n print(\" - Channel number : {}\".format(device[\"channel_number\"]))\n print(\" - Area : {}\".format(device[\"area\"]))\n print(\" - Position : {}\".format(device[\"position\"]))\n print(\" - Number of faults : {}\".format(len(device[\"faults\"])))\n for fault_id,fault_data in device[\"faults\"].items():\n print(\" Fault data:\")\n print(\" . . . . . . . . . . . . \")\n print(\" - EPICS PREFIX: {}_T{}\".format(fault_data[\"name\"], fault_data[\"bit_positions\"][0]))\n print(\" - ID : {}\".format(fault_id))\n print(\" - Name : {}\".format(fault_data[\"name\"]))\n print(\" - Description : {}\".format(fault_data[\"description\"]))\n print(\" - Bit positions : {}\".format(fault_data[\"bit_positions\"]))\n print(\" . . . . . . . . . . . . \")\n print(\" .....................\")\n print(\" - - - - - - - - - - - - -\")\n print(\"\")\n print(\"--------------------------\")\n\n # Digital application result\n print(\"----------------------------\")\n print(\"-- Digital applications --\")\n print(\"----------------------------\")\n print(\"Number of digital application processed: {}\".format(len(self.digital_apps)))\n if (self.verbose):\n for app in self.digital_apps:\n print(\" Application data:\")\n print(\" - - - - - - - - - - - - -\")\n print(' - EPICS PREFIX: MPLN:{}:{}:{}'.format(app[\"link_node_area\"].upper(), app[\"link_node_location\"].upper(), app[\"card_index\"]))\n print(\" - App ID : {}\".format(app[\"app_id\"]))\n print(\" - Cpu name : {}\".format(app[\"cpu_name\"]))\n print(\" - Crate ID : {}\".format(app[\"crate_id\"]))\n print(\" - Slot number : {}\".format(app[\"slot_number\"]))\n print(\" - Link node name : {}\".format(app[\"link_node_name\"]))\n print(\" - Link node area : {}\".format(app[\"link_node_area\"]))\n print(\" - Link node location : {}\".format(app[\"link_node_location\"]))\n print(\" - Card index : {}\".format(app[\"card_index\"]))\n print(\" - Number of devices : {}\".format(len(app[\"devices\"])))\n for device in app[\"devices\"]:\n print(\" Device data:\")\n print(\" .....................\")\n print(\" - EPICS PREFIX: {}:{}:{}\".format(device[\"type_name\"], device[\"area\"], device[\"position\"]))\n print(\" - Type name : {}\".format(device[\"type_name\"]))\n print(\" - Area : {}\".format(device[\"area\"]))\n print(\" - Position : {}\".format(device[\"position\"]))\n print(\" - Number of inputs : {}\".format(len(device[\"inputs\"])))\n for input in device[\"inputs\"]:\n print(\" Input data:\")\n print(\" . . . . . . . . . . . . \")\n print(\" - EPICS PREFIX: {}\".format(input[\"name\"]))\n print(\" - Name : {}\".format(input[\"name\"]))\n print(\" - Bit position : {}\".format(input[\"bit_position\"]))\n print(\" - Zero name : {}\".format(input[\"zero_name\"]))\n print(\" - One name : {}\".format(input[\"one_name\"]))\n print(\" - Alarm state : {}\".format(input[\"alarm_state\"]))\n print(\" - Debounce : {}\".format(input[\"debounce\"]))\n print(\" . . . . . . . . . . . . \")\n print(\" .....................\")\n print(\" - - - - - - - - - - - - -\")\n print(\"\")\n print(\"----------------------------\")\n\n\n print(\"===================================\")\n\n print('Found {} link nodes:'.format(len(self.link_nodes)))\n for k,v in self.link_nodes.items():\n print('{}: {}'.format(k, v['type']))","def get_apk(self):","def get_discovery_summary():\n pass","def usage_information(self):\n return self._usage_information","def gather_metric(self):\n result = self._shell.run(self.ADB_COMMAND)\n stdout = result.stdout.splitlines()\n adb_version = stdout[0].split()[-1]\n # Revision information will always be in next line\n adb_revision = stdout[1].split()[1]\n\n response = {\n self.ADB_VERSION: adb_version,\n self.ADB_REVISION: adb_revision\n }\n return response","def device_overview(self):\r\n data = {}\r\n\r\n # GET DATA\r\n token = request.headers.get('token')\r\n userid = request.headers.get('userid')\r\n vessel_id = request.args.get('vessel_id')\r\n epoch_format = request.args.get('format')\r\n\r\n # CHECK TOKEN\r\n if not self.validate_token(token, userid):\r\n data['alert'] = \"Invalid Token\"\r\n data['status'] = 'Failed'\r\n return self.return_data(data)\r\n\r\n alarm_types = self.get_alarm_types()\r\n\r\n ats = self.get_alarm_trigger()\r\n\r\n devices = self.couch_query.get_all_devices(vessel_id)\r\n\r\n standard_time = self.epoch_day(time.time())\r\n\r\n epoch_time = time.time()\r\n\r\n temp_data = []\r\n\r\n start_date = self.get_start_date(epoch_format)\r\n\r\n if not start_date and epoch_format not in [\"day\", \"hours\"]:\r\n\r\n data['alert'] = \"Invalid format!\"\r\n data['status'] = 'Failed'\r\n\r\n return self.return_data(data)\r\n\r\n for device in devices:\r\n\r\n if device['doc']['device'] in ['PARAMETERS', 'NTWCONF', 'NTWPERF1']:\r\n\r\n continue\r\n\r\n row = {}\r\n row['device'] = device['doc']['device']\r\n row['name'] = device['doc']['device']\r\n row['Alert'] = 0\r\n row['Critical'] = 0\r\n row['Warning'] = 0\r\n row['Info'] = 0\r\n row['Debug'] = 0\r\n for atrigger in ats:\r\n\r\n trigger_type = self.get_alarm_type_name(alarm_types, atrigger['alarm_type_id'])\r\n\r\n at_id = atrigger['alarm_trigger_id']\r\n device_id = device['id']\r\n\r\n datas = self.calc.calculate_trigger([at_id], standard_time,\r\n epoch_time, vessel_id=vessel_id,\r\n device_id=device_id)\r\n\r\n if not datas == \"No Alarm Trigger found.\":\r\n\r\n datas_index_0 = datas[0]\r\n len_datas = datas_index_0['results']\r\n if len_datas:\r\n\r\n row[trigger_type] = 1\r\n\r\n if epoch_format in ['week', 'month', \"quarter\", 'annual']:\r\n\r\n sql_str = \"SELECT COUNT(alarm_trigger_id) FROM alarm_data \"\r\n sql_str += \"WHERE device_id='{0}' \".format(device_id)\r\n sql_str += \"AND epoch_date > {0} \".format(start_date)\r\n sql_str += \"AND epoch_date < {0}\".format(epoch_time)\r\n\r\n res = self.postgres.query_fetch_one(sql_str)\r\n\r\n row[trigger_type] = row[trigger_type] + res['count']\r\n\r\n temp_data.append(row)\r\n\r\n final_data = {}\r\n final_data['data'] = temp_data\r\n final_data['status'] = 'ok'\r\n\r\n return self.return_data(final_data)","def get_devices_summary():\n\n # This function was created to replace get_devices_information\n # because it wasn't detecting virtual systems in Palo Alto Virtual Systems\n global nipper_xml\n devices = {}\n headings = []\n\n # Add the table headings to a list\n for h in nipper_xml.findall(\"./summary/table/[@ref='SCOPE.AUDITDEVICELIST.TABLE']/headings/heading\"):\n if h not in headings:\n headings.append(h.text)\n\n for device in nipper_xml.findall(\"./summary/table/[@ref='SCOPE.AUDITDEVICELIST.TABLE']/tablebody/tablerow\"):\n values = []\n for i in device.findall('./tablecell/item'):\n if i not in values:\n values.append(i.text)\n if DEBUG:\n print \"\\t\" + note + \"%s: %s\" % (headings[headings.index('Name')], values[headings.index('Name')])\n print \"\\t\" + note + \"%s: %s\" % (headings[headings.index('Device')], values[headings.index('Device')])\n print \"\\t\" + note + \"%s: %s\" % (headings[headings.index('OS')], values[headings.index('OS')].split(\" \")[0])\n print \"\\t\" + note + \"%s: %s\" % (headings[headings.index('OS')], values[headings.index('OS')].split(\" \")[1])\n devices[values[headings.index('Name')]] = {'name': values[headings.index('Name')],\n 'type': values[headings.index('Device')],\n 'os': values[headings.index('OS')].split(' ')[0],\n 'osversion': values[headings.index('OS')].split(' ')[1]\n }\n\n if DEBUG:\n print info + \"Device Object:\"\n print devices\n raw_input(warn + \"Press enter to continue\")\n return devices","def getEnergyUsage():\n energy_data = asyncio.run(plug.get_emeter_realtime())\n\n return energy_data","def get_data():\n return","def data_setup_appliances():\n appliance_list = []\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_BASIC, \"appliance1\", gpio_pin_id=None))\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_BASIC, \"appliance2\", gpio_pin_id=None))\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_BASIC, \"appliance3\", gpio_pin_id=None))\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_BASIC, \"appliance4\", gpio_pin_id=None))\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_BASIC, \"appliance5\", gpio_pin_id=None))\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_RELAY, \"gpio_appliance1\", gpio_pin_id=13))\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_RELAY, \"gpio_appliance2\", gpio_pin_id=15))\n return appliance_list","def get_data(self):","def _get_data(self):\n c = Connector(self.host, self.username, self.password)\n return c.getLanDevices()","def get_data():\n pass","def get_data():\n pass","def get_data():\n pass","def user_sends_get_call_to_the_devices():\n web_app.list_devices()","def info_equipment_get():\n equipment = _equipment_by_group()\n return equipment, 200","def retrieve_dial_data(app_name):\n # NOTE: the reference code store the file in the application folder, we read the file in our data folder\n # perhaps other changes will be needed to allow USE_ADDITIONAL_DATA feature to work\n file_path = 'dial_data/' + app_name + '.json'\n if not fileops.file_exists(file_path):\n return {}\n data = fileops.load_file_def(file_path)\n return json.loads(data)","def get(self):\n try:\n log.debug(\"Device info : \")\n #get the payload to influx DB\n url = \"http://localhost:8086/query\"\n querystring = {\"pretty\": \"true\", \"db\": \"IOT\",\n \"q\":\"SELECT DISTINCT(deviceId) FROM(SELECT deviceId,q1 FROM \\\"ttd_devices\\\" ) \" }\n response = requests.request(\"GET\", url, params=querystring)\n r_d=json.loads(response.text)\n result_d=[]\n for rec in r_d['results'][0]['series']:\n for element in rec['values']:\n result_d.append(element[1])\n result={}\n result['status'] = 1\n result['message']=result_d\n return_status = 200\n except ValueError as e:\n result = {}\n log.exception('Value Exception while fetching device list')\n result['status'] = 0\n return_status = 400\n result['message'] = e.args[0]\n except :\n result = {}\n log.exception('Exception while fetching the device data')\n return_status = 500\n result['status'] = 0\n result['message'] = 'Internal Error has occurred while fetching devie data'\n finally:\n resp = Response(json.dumps(result), status=return_status, mimetype=\"application/json\")\n return resp","def show(ctx, appeui):\n if '.' in appeui:\n appeui = str(hexStringInt(str(appeui)))\n \n # Form the url and payload\n server = ctx.obj['server']\n payload = {'token': ctx.obj['token']}\n url = 'http://{}/api/v{}'.format(server, str(version))\n url += '/apps' if appeui == 'all' else '/app/{}'.format(appeui)\n \n # Make the request\n data = restRequest(server, url, 'get', payload, 200)\n if data is None:\n return\n \n # Single application\n if appeui != 'all':\n a = data\n indent = ' ' * 10\n if a['appinterface_id'] == 0:\n a['appinterface_id'] = '-'\n if a['domain'] is None:\n a['domain'] = '-'\n click.echo('Application EUI: ' + euiString(a['appeui']))\n click.echo('{}name: {}'.format(indent, a['name']))\n click.echo('{}domain: {}'.format(indent, a['domain']))\n click.echo('{}fport: {}'.format(indent, a['fport']))\n click.echo('{}interface: {}'.format(indent, a['appinterface_id']))\n if a['appinterface_id'] != '-':\n click.echo('{}Properties:'.format(indent))\n properties = sorted(a['properties'].values(), key=lambda k: k['port'])\n for p in properties:\n click.echo('{} {} {}:{}'.format(indent, p['port'], p['name'], p['type']))\n return\n \n # All applications\n click.echo('{:14}'.format('Application') + \\\n '{:24}'.format('AppEUI') + \\\n '{:15}'.format('Domain') + \\\n '{:6}'.format('Fport') + \\\n '{:10}'.format('Interface'))\n for i,a in data.iteritems():\n if a['appinterface_id'] == 0:\n a['appinterface_id'] = '-'\n if a['domain'] is None:\n a['domain'] = '-'\n click.echo('{:13.13}'.format(a['name']) + ' ' + \\\n '{:23}'.format(euiString(a['appeui'])) + ' ' + \\\n '{:14.14}'.format(a['domain']) + ' ' + \\\n '{:5.5}'.format(str(a['fport'])) + ' ' + \\\n '{:10}'.format(str(a['appinterface_id'])))","def get_usage_data(self):\n with self._lock:\n data_copy = self._data.copy()\n return data_copy","def get_listing_information():\n\n #getting the guidebox_id variable from show_page.html\n guidebox_id = request.args.get(\"guidebox_id\")\n\n #get the show from the database\n show = Show.find_show_with_guidebox_id(guidebox_id)\n\n #get show title from Guidebox so it can be used in the OnConnect title search url \n show_title = str(show.title)\n\n #get OnConnect seriesId\n series_id = onconnect_search_series_id(show_title)\n\n #obtaining listing information for a 24 hour period from the current time\n airings = onconnect_search_airings(series_id)\n\n return jsonify(airings)","def available(self, app):\n return self.xlist(\"testfor\", app)[0]","def GetData(self):\r\n if self.Error == False:\r\n Extra = {}\r\n try:\r\n result = {}\r\n temp = self.ScrapeMainWebpage()\r\n if temp != None:\r\n result.update(temp)\r\n temp = self.ScrapeParameters1Webpage()\r\n if temp != None:\r\n result.update(temp)\r\n temp = self.ScrapeParameters2Webpage()\r\n if temp != None:\r\n result.update(temp)\r\n temp = self.ScrapeStatusWebpage()\r\n if temp != None:\r\n result.update(temp)\r\n sqlArray = {}\r\n sqlArray[self.deviceDescr] = {}\r\n sqlArray[self.deviceDescr][self.devNumber] = {}\r\n sqlArray[self.deviceDescr][self.devNumber][\"General\"] = result\r\n sqlArray[self.deviceDescr][self.devNumber][\"_ExtractInfo\"] = {}\r\n sqlArray[self.deviceDescr][self.devNumber][\"_ExtractInfo\"][\"ExtractTime\"] = time.time()\r\n sqlArray[\"ReadError\"] = False \r\n return sqlArray\r\n \r\n except Exception as e: \r\n self.log.printError(\"ERROR in Retreiving Seatel VSAT Data,%s Module Error\" % sys._getframe().f_code.co_name) \r\n self.log.printError( str(e))\r\n self.Error = True\r\n Extra[\"ReadError\"] = True\r\n return Extra\r\n else:\r\n self.log.printWarning(\"%s skipped due to previous failure\" % sys._getframe().f_code.co_name)\r\n return None","def __get_data_from_store(term):\n url_search = PLAY_STORE_URL + \"/search\"\n response = requests.get(url_search, {'c': 'apps', 'q': term})\n soup = BeautifulSoup(response.content, \"html.parser\")\n apps = soup.find_all(\"div\", {\"class\": \"card no-rationale square-cover apps small\"})\n\n result = []\n print(result)\n for i, app in enumerate(apps):\n app_details_basic = app.find(\"div\", {\"class\": \"details\"})\n app_id = app['data-docid']\n app_data = {\n 'uid': app_id,\n 'name': app_details_basic.find(\"a\", {\"class\": \"title\"})['title'].strip().encode('utf-8'),\n 'dev_name': app_details_basic.find(\"a\", {\"class\": \"subtitle\"})['title'].strip(),\n 'icon_url': \"http://\" + app.find(\n \"div\", {\"class\": \"cover-inner-align\"}).img['data-cover-large'].strip(\"//\")\n }\n\n url_app_detail = PLAY_STORE_URL + \"/apps/details\"\n response = requests.get(url_app_detail, {'id': app_id})\n soup = BeautifulSoup(response.content, \"html.parser\")\n\n app_data.update({\n 'category': soup.find(\"a\", {\"itemprop\": \"genre\"}).text,\n 'description': soup.find(\"div\", {\"itemprop\": \"description\"}).text.strip().encode('utf-8'),\n \n })\n\n \n dev_links = soup.find_all(\"a\", {\"class\": \"dev-link\", \"rel\": \"nofollow\"})\n if dev_links:\n for dev_link in dev_links:\n if \"mailto\" in dev_link['href']:\n app_data['dev_email'] = dev_link['href'].replace(\"mailto:\", \"\")\n break\n\n result.append(app_data)\n\n if i + 1 == SEARCH_RESULT_COUNT:\n break\n print(result)\n return result","def get_usage(self):\r\n return self.box_usage","async def get_device_data(self):\n pass","def getatt(self):\n err = True\n retry = 0\n while err and retry<2:\n try:\n r = requests.get(self.url+'ATT?\\n')\n res = float(r.text)\n err = False\n except:\n err = True\n time.sleep(1)\n retry += 1\n res = nan\n return res","def get_data(self):\n pass","def get_data(self):\n pass","def application_list(p_engine, p_username, format, appname):\n\n ret = 0\n\n enginelist = get_list_of_engines(p_engine, p_username)\n\n if enginelist is None:\n return 1\n\n data = DataFormatter()\n data_header = [\n (\"Engine name\", 30),\n (\"Application name\", 30),\n ]\n data.create_header(data_header)\n data.format_type = format\n for engine_tuple in enginelist:\n engine_obj = DxMaskingEngine(engine_tuple)\n if engine_obj.get_session():\n continue\n applist = DxApplicationList()\n # load all objects\n applist.LoadApplications()\n\n if appname is None:\n applications = applist.get_allref()\n else:\n applications = applist.get_applicationId_by_name(appname)\n if len(applications) == 0:\n ret = ret + 1\n\n for appref in applications:\n appobj = applist.get_by_ref(appref)\n data.data_insert(\n engine_tuple[0],\n appobj.application_name\n )\n\n print(\"\")\n print (data.data_output(False))\n print(\"\")\n \n \n return ret","def _get_dapall_from_api(self):\n\n url = marvin.config.urlmap['api']['dapall']['url']\n\n url_full = url.format(name=self.plateifu,\n bintype=self.bintype.name,\n template=self.template.name)\n\n try:\n response = self._toolInteraction(url_full)\n except Exception as ee:\n raise MarvinError('found a problem while getting DAPall: {0}'.format(str(ee)))\n\n if response.results['error'] is not None:\n raise MarvinError('found a problem while getting DAPall: {}'\n .format(str(response.results['error'])))\n\n data = response.getData()\n\n return data['dapall_data']","def get_usage(self, start=None, end=None):\n return self.manager.get_usage(self, start=start, end=end)","def usage():\n return _usage","def summary(app):\n click.echo(get_summary(app))","def test_duo_application_get(self):\n pass","def get_data(self):\r\n pass","def usage(where=sys.stdout):\n print('Gather Holding IDs via REST using a list of MMS IDs.',\n file=where) \n print('Usage:', file=where)\n print(' west2_gather_Holding_IDs.py <file.txt> <APIKEY>', file=where)\n print('Where:', file=where)\n print(' file.txt List of MSS IDs (one / line)',\n file=where)\n print(' APIKEY API key for accessing Alma REST APIs',\n file=where)\n print('Output:', file=where)\n print(' Generates a datestamped text file: holding-and-mss-ids.<date>.txt',\n file=where)\n print(' consisting of lines holding_id<tab>mms_id', file=where)","def get_appliances(self):\n if self.appliances is not None:\n return self.appliances\n self.appliances = Appliance.objects.filter(user=self.request.user)\n return self.appliances","def get_usages(self):\n return self.client._perform_json(\"GET\", \"/projects/%s/managedfolders/%s/usages\" % (self.project_key, self.odb_id))","def get_usage(self):\n return self.box_usage","def AcquiredData (self) :\n\t\treturn self.run(\"AcquiredData\")","def usage():\r\n print 'Usage: collect_logs.py testrun \"env1, env2,...\" \"oscounters, applogs, gclogs, traces\"'\r\n print \"testrun = Name of the test execution e.g. 12032713\"\r\n print \"environments = Name of the environment defined in the environments.ini file\"\r\n print \"logtypes = List types of logfiles to collect\"","def get(category, page=1, per_page=5):\r\n\r\n count = n_count(category)\r\n\r\n sql = text('''SELECT app.id, app.name, app.short_name, app.description,\r\n app.info, app.created, app.category_id, \"user\".fullname AS owner,\r\n featured.app_id as featured\r\n FROM \"user\", task, app\r\n LEFT OUTER JOIN category ON app.category_id=category.id\r\n LEFT OUTER JOIN featured ON app.id=featured.app_id\r\n WHERE\r\n category.short_name=:category\r\n AND app.hidden=0\r\n AND \"user\".id=app.owner_id\r\n AND app.info LIKE('%task_presenter%')\r\n AND task.app_id=app.id\r\n GROUP BY app.id, \"user\".id, featured.app_id ORDER BY app.name\r\n OFFSET :offset\r\n LIMIT :limit;''')\r\n\r\n offset = (page - 1) * per_page\r\n results = db.engine.execute(sql, category=category, limit=per_page, offset=offset)\r\n apps = []\r\n for row in results:\r\n app = dict(id=row.id,\r\n name=row.name, short_name=row.short_name,\r\n created=row.created,\r\n description=row.description,\r\n owner=row.owner,\r\n featured=row.featured,\r\n last_activity=pretty_date(last_activity(row.id)),\r\n last_activity_raw=last_activity(row.id),\r\n overall_progress=overall_progress(row.id),\r\n info=dict(json.loads(row.info)))\r\n apps.append(app)\r\n return apps, count","def getStockData():\n pass","def extract_programs():\n if settings.XPRO_CATALOG_API_URL:\n return requests.get(settings.XPRO_CATALOG_API_URL, timeout=20).json()\n return []","def data():\n return volumes_fetchers.get_json_data()","def get_antivirus_info():\n query = {\n \"type\": \"op\",\n \"cmd\": \"<request><anti-virus><upgrade><info></info></upgrade></anti-virus></request>\",\n }\n\n return __proxy__[\"panos.call\"](query)","def test_mock_datasource_usages(self):\n account1 = self.test_data.accounts[0]\n meter = account1.meters[0]\n usage = meter.usages[0]\n self.assertIsInstance(usage, Usage)\n self.assertEqual(usage.PK, 6)\n self.assertEqual(usage.UsageActualName, \"test_usage\")\n self.assertEqual(usage.UsageAmount, Decimal(50.0))\n self.assertEqual(usage.RateComponent, \"test_rate_component\")\n self.assertEqual(usage.EnergyUnit, \"test_energy_unit\")\n self.assertEqual(usage.IntervalStart, date(2016, 1, 1))\n self.assertEqual(usage.IntervalEnd, date(2016, 2, 1))","def get_data_qos(args):\n diff_data(args, \"qos\")","def getAppInfo(self):\n data = self._client.Application.find(self.app_id)\n return data","def get_device_info(target_project_arn):\n try:\n device_info = device_farm.list_devices(\n arn=target_project_arn,\n filters=[\n {\n \"attribute\": \"PLATFORM\",\n \"operator\": \"EQUALS\",\n \"values\": ['ANDROID', ]\n },\n {\n \"attribute\": \"OS_VERSION\",\n \"operator\": \"GREATER_THAN_OR_EQUALS\",\n \"values\": ['9', ]\n },\n {\n \"attribute\": \"MANUFACTURER\",\n \"operator\": \"EQUALS\",\n \"values\": ['Google', ]\n },\n {\n \"attribute\": \"AVAILABILITY\",\n \"operator\": \"EQUALS\",\n \"values\": ['HIGHLY_AVAILABLE', ]\n },\n {\n \"attribute\": \"FLEET_TYPE\",\n \"operator\": \"EQUALS\",\n \"values\": ['PUBLIC', ]\n }\n ])['devices']\n\n if device_info is not None:\n device_arn = device_info[0]['arn']\n device_name = device_info[0]['name']\n device_manufacture = device_info[0]['manufacturer']\n device_model = device_info[0]['model']\n device_model_id = device_info[0]['modelId']\n device_type = device_info[0]['formFactor']\n device_platform = device_info[0]['platform']\n device_os = device_info[0]['os']\n device_visibility = device_info[0]['fleetType']\n device_availability = device_info[0]['availability']\n\n print('Device Name - {} with Manufacture {}, model {}, modelId {} & type {}'.format(\n device_name,\n device_manufacture,\n device_model,\n device_model_id,\n device_type\n )\n )\n print('Device Platform {} with OS {}, visibility {} & availability - {} '.format(\n device_platform,\n device_os,\n device_visibility,\n device_availability\n )\n )\n\n if device_availability == TARGET_AVAILABILITY:\n print('AWS setup is complete')\n else:\n print('Problem, device is not available')\n else:\n print('Problem finding device info')\n\n except IndexError:\n print('Problem finding device from pool {}'.format(device_info))","def access():","def stats(self):\r\n\t\tdata = self._get('global/', query=None)\r\n\t\treturn data","def main():\n results = []\n results.extend(check_mounts())\n results.extend(diskusage())\n return results","def query(self):\n self._measurements[self.KEY_USAGE].df = self.fetch_data_usage()","def get_app(self, app_name, ns_name):\n\n status, _ = self.helm_client.status(app_name, namespace=ns_name)\n values, _ = self.helm_client.get_values(app_name, namespace=ns_name)\n release_data = {\"status\": status, \"values\": values}\n\n schema_path = Path(\"%s/%s/values.schema.json\"\n % (self._get_ns_dir(ns_name), app_name))\n if schema_path.exists():\n schema = json.loads(schema_path.read_text())\n release_data[\"schema\"] = schema\n\n return release_data","def diagnostics(self, oid):\n path = '/servers/%s/diagnostics' % oid\n res = self.client.call(path, 'GET', data='', token=self.manager.identity.token)\n self.logger.debug('Shows basic usage data for server %s: %s' % \n (oid, truncate(res)))\n return res[0]","def test_get_us_daily_data(self):\n dag = self.dagbag.get_dag(self.dag_id)\n extract_task = dag.get_task('extract')\n resp = self.extract.getDailyUSDataFromAPI()\n self.assertIsNotNone(resp)\n self.assertEqual(type(resp), list)","def getDeviceInfo():\n url = \"https://api.roblox.com/reference/deviceinfo\"\n r = requests.get(url)\n j = json.loads(r.text)\n return j","def who():\n cleanup()\n return {'available': userlist(), 'eta': data['etas'], 'etd': data['etds'], 'lastlocation': data['lastlocation'], 'ceitloch': ceitloch(), 'reminder': data['reminder']}","def get_app_info(self, name):\n with hide(\"output\", \"running\"):\n result = local(\"redis-cli -h {host} -p 6379 -n {db} hgetall {name}\".format(\n host=self.host, name=name, db=REDIS_APPLICATION_DB_NUM), capture=True)\n\n if len(result.stdout) > 0:\n splits = result.stdout.split(\"\\n\")\n fmt_result = dict([(splits[i], splits[i+1])\n for i in range(0, len(splits), 2)])\n pp = pprint.PrettyPrinter(indent=2)\n pp.pprint(fmt_result)\n return fmt_result\n else:\n warn(\"Application \\\"%s\\\" not found\" % name)\n return None","def get_patient_status():\n r = requests.get(\"http://vcm-7474.vm.duke.edu:5000/api/heart_rate/3\")\n print(r.text)","def usage(self):\r\n return usage.Usage(self)","def get_info(self):\n pass","def get_info(self):\n pass","def getTheData(self, dev):\n if self.debugLevel >= 2 and self.debug:\n self.debugLog(u\"getTheData FrontViewAPI method called.\")\n\n # dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\"Download\")\n try:\n url = 'http://' + dev.pluginProps['sourceXML'] + '/FrontView'\n r = requests.get(url,timeout=5)\n result = r.json()\n if self.debugLevel >= 2 and self.debug:\n self.debugLog(u\"Result:\" + unicode(result))\n self.WaitInterval = 1\n dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\"Online\")\n dev.setErrorStateOnServer(None)\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\n return result\n\n except Exception as error:\n\n indigo.server.log(u\"Error connecting to Device:\" + dev.name)\n self.WaitInterval = 60\n if self.debugLevel >= 2 and self.debug:\n self.debugLog(u\"Device is offline. No data to return. \")\n dev.updateStateOnServer('deviceIsOnline', value=False, uiValue=\"Offline\")\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\n dev.setErrorStateOnServer(u'Offline')\n result = \"\"\n return result","def device_count():\n apipath = \"/targets/devices\"\n url = SERVER + apipath\n params = {\n 'q': '(deviceType:ASA)',\n 'agg': 'count'}\n headers = {\n 'Accept': \"application/json\",\n 'Content-Type': \"application/json\",\n 'Authorization': \"bearer {}\".format(token)}\n response = requests.get(url, verify=False, stream=True, headers=headers, params=params)\n getstatuscode = response.status_code\n getresponse = response.json()\n if getstatuscode == 200:\n return getresponse\n else:\n response.raise_for_status()","def appdata(appname):\n z = Zap(appname)\n z.appdata(stdout=True)","def test_retrieve_1_by_all(self):\n swa = frontend.SupplyWinApi()\n query_dict = dict(\n dev=\"rrenaud\",\n targets=\"Council Room\",\n interaction=\"\",\n unconditional=\"true\",\n )\n\n card_stats = swa.retrieve_data(query_dict)\n\n self.assertEquals(len(card_stats), 1)\n\n self.assertEquals(card_stats[0]['card_name'], 'Council Room')\n self.assertEquals(len(card_stats[0]['condition']), 0)\n\n json = swa.readable_json_card_stats(card_stats)\n self.assertEquals(json[0:14], '[{\"card_name\":')","def games_usage(parsed_args):\n if parsed_args.verb == \"GET\":\n filter_dict = {\n \"game_type\": parsed_args.game_type,\n \"genre\": parsed_args.genre,\n \"keywords\": parsed_args.keywords,\n \"mechanic\": parsed_args.mechanic\n }\n df = get_games(parsed_args.id, filter_dict)\n if parsed_args.function == \"FILTERS\":\n df = get_game_filters(df)\n else:\n df = post_games(df, parsed_args.sort_by, parsed_args.weighting)\n return df","def get_data(self, label):\n self.application.get_data(label)","def get_usage_stats(self) -> UsageStats:\n return self._usage","def get(cls, service, name=\"\", option_=\"\") :\n\t\ttry :\n\t\t\tobj = audit_stats()\n\t\t\tif not name :\n\t\t\t\tresponse = obj.stat_resources(service, option_)\n\t\t\treturn response\n\t\texcept Exception as e:\n\t\t\traise e","def get(self, request, *args, **kwargs):\n device = Device.objects.get(name=kwargs[\"device_name\"])\n global_settings = GoldenConfigSettings.objects.get(id=\"aaaaaaaa-0000-0000-0000-000000000001\")\n status_code, data = graph_ql_query(request, device, global_settings.sot_agg_query)\n data = json.loads(json.dumps(data))\n return Response(GraphQLSerializer(data=data).initial_data, status=status_code)","def _get_values(self, app_name, chart_dir):\n\n raw, _ = self.helm_client.show_info(app_name, \"values\",\n chart_dir=chart_dir)\n return yaml.load(raw, yaml.SafeLoader)","def getAPData(ap, timePerRange=3*settings.SNMPAPLAP, \n\tstartTime=None,\n\tendTime=None):\n\n\tCOUNTERTOSPEED = ['ethernetRxTotalBytes','ethernetTxTotalBytes']\n\tGETMAX = []\n\t\n\tresult = []\n\ttry:\n\n\t\tif startTime == None:\n\t\t\tstartTime = APSnapshot.objects.aggregate(Min(\"date\"))[\"date__min\"]\n\t\tif endTime == None:\n\t\t\tendTime = APSnapshot.objects.aggregate(Max(\"date\"))[\"date__max\"]\n\n\n\t\tsnapshots = APSnapshot.objects.filter(ap=ap, date__gte=startTime, date__lte=endTime).order_by('date')\n\t\tstartAt = snapshots[0].date\n\t\t\n\t\tvalues = {}\n\t\tfor data in snapshots[0].apsnapshotdata_set.all():\n\t\t\tvalues[data.name] = [data.value]\n\n\t\tfor snap in snapshots[1:]:\n\t\t\t# Get the data of the period\n\t\t\tif snap.date < (startAt + timePerRange):\n\t\t\t\tfor data in snap.apsnapshotdata_set.all():\n\t\t\t\t\tif data.name in values:\n\t\t\t\t\t\tvalues[data.name].append(data.value)\n\n\t\t\t# Aggregate and reset the period\n\t\t\telse:\n\t\t\t\tdata = {}\n\t\t\t\tfor attr, value in values.items():\n\t\t\t\t\tif attr in COUNTERTOSPEED:\n\t\t\t\t\t\tdata[attr] = getSpeed(value[0], value[-1], timePerRange)\n\t\t\t\t\telif attr in GETMAX:\n\t\t\t\t\t\tdata[attr] = max(value)\n\t\t\t\t\telse:\n\t\t\t\t\t\tdata[attr] = sum(value)/float(len(value))\n\n\t\t\t\tresult.append({'date':timezone.localtime(startAt + timePerRange), 'data': data})\n\n\t\t\t\t# Start new period\n\t\t\t\tstartAt = snap.date\n\t\t\t\tvalues = {}\n\t\t\t\tfor data in snap.apsnapshotdata_set.all():\n\t\t\t\t\tvalues[data.name] = [data.value]\n\n\texcept Exception as e:\n\t\tOperationalError(source=\"getAPData\", error=str(e)).save()\n\t\traise e\n\n\treturn result","def healthcare():","def get_patient_average():\n r = requests.get(\"http://vcm-7474.vm.duke.edu:5000/api/heart_rate/average/2\")\n print(r.text)","def measurements_lookup(client, database):\n client.switch_database(database)\n mlist_dict = client.get_list_measurements()\n # print(\"def measurements_lookup 010:\", mlist_dict[:10])\n return mlist_dict","def get_meter_info(apt_no):\n if apt_no in ['102A', 102]:\n apt_no = '102A'\n payload = (\"select uuid, Metadata/Instrument/SupplyType \"\n \"where Metadata/LoadLocation/FlatNumber ='\" + str(apt_no) + \"' and \"\n \"Metadata/Extra/PhysicalParameter='Power'\")\n\n r = requests.post(url, data=payload)\n # logger.debug (\"%s\",r)\n payload_body = r.json()\n # logger.debug (\"Payload:\\n%s\", payload_body)\n\n meters = []\n for i in range(0, len(payload_body)):\n meter = payload_body[i]\n\n meters.append({'uuid': meter['uuid'], 'type': meter[\n 'Metadata']['Instrument']['SupplyType']})\n\n return meters","def _get_data(self):\n devices = []\n try:\n if not self.router_client.login():\n self.hass.states.set(f\"{DOMAIN}.statusmsg\", self.router_client.statusmsg)\n _LOGGER.warning(\"Login failed: {0}:{1}@{2}\".format(self.router_client.username, self.router_client.password,self.router_client.host))\n self.router_client.logout()\n return devices\n\n devices_json = self.router_client.get_devices_response()\n finally:\n self.router_client.logout()\n\n self.hass.states.set(f\"{DOMAIN}.scanning\", devices_json != False)\n\n if devices_json != False:\n for device in devices_json:\n # _LOGGER.debug(\"Device: {0}\".format(device))\n dev = Device(\n device['HostName'].replace('未知设备', 'Unknown'),\n device['IPAddress'],\n device['MACAddress'],\n device['Active'],\n ICONS.get(device['IconType'])\n )\n # _LOGGER.debug(\"Device: {0}\".format(dev))\n devices.append(dev)\n return devices\n else:\n return []","def get_inventory(self, context):\n # See below some example code demonstrating how to return the resource structure\n # and attributes. In real life, of course, if the actual values are not static,\n # this code would be preceded by some SNMP/other calls to get the actual resource information\n '''\n # Add sub resources details\n sub_resources = [ AutoLoadResource(model ='Generic Chassis',name= 'Chassis 1', relative_address='1'),\n AutoLoadResource(model='Generic Module',name= 'Module 1',relative_address= '1/1'),\n AutoLoadResource(model='Generic Port',name= 'Port 1', relative_address='1/1/1'),\n AutoLoadResource(model='Generic Port', name='Port 2', relative_address='1/1/2'),\n AutoLoadResource(model='Generic Power Port', name='Power Port', relative_address='1/PP1')]\n\n\n attributes = [ AutoLoadAttribute(relative_address='', attribute_name='Location', attribute_value='Santa Clara Lab'),\n AutoLoadAttribute('', 'Model', 'Catalyst 3850'),\n AutoLoadAttribute('', 'Vendor', 'Cisco'),\n AutoLoadAttribute('1', 'Serial Number', 'JAE053002JD'),\n AutoLoadAttribute('1', 'Model', 'WS-X4232-GB-RJ'),\n AutoLoadAttribute('1/1', 'Model', 'WS-X4233-GB-EJ'),\n AutoLoadAttribute('1/1', 'Serial Number', 'RVE056702UD'),\n AutoLoadAttribute('1/1/1', 'MAC Address', 'fe80::e10c:f055:f7f1:bb7t16'),\n AutoLoadAttribute('1/1/1', 'IPv4 Address', '192.168.10.7'),\n AutoLoadAttribute('1/1/2', 'MAC Address', 'te67::e40c:g755:f55y:gh7w36'),\n AutoLoadAttribute('1/1/2', 'IPv4 Address', '192.168.10.9'),\n AutoLoadAttribute('1/PP1', 'Model', 'WS-X4232-GB-RJ'),\n AutoLoadAttribute('1/PP1', 'Port Description', 'Power'),\n AutoLoadAttribute('1/PP1', 'Serial Number', 'RVE056702UD')]\n\n return AutoLoadDetails(sub_resources,attributes)\n '''\n\n self._log(context, 'Begin autoload')\n resources = []\n attributes = []\n\n\n attributes.append(AutoLoadAttribute('', 'replication_address', self.get_replication_address(context)))\n attributes.append(AutoLoadAttribute('', 'connection_key', self.get_connection_key(context)))\n\n networks = self._get_newtork_interfaces(context)\n self._log(context, 'got networks')\n\n controllers = self._get_controllers(context)\n self._log(context, 'got controllers')\n ports = self._get_ports(context)\n\n model = None\n for controller in controllers:\n self._log(context, 'Processing ctrlt: ' + controller['name'] + ':' + controller['model'])\n resources.append(AutoLoadResource(model='Generic Storage Controller', name=controller['name'],\n relative_address=controller['name']))\n if model is None:\n model = controller['model']\n\n attributes.append(AutoLoadAttribute('', 'Model', model))\n\n for network in networks:\n self._log(context, 'Processing netwk: ' + network['name'] + ':' + str(network['address']))\n net_name = network['name']\n controller = net_name.split('.')[0]\n if 'vir0' in controller or 'vir1' in controller:\n attributes.append(AutoLoadAttribute('',str(controller + '_address'), str(network['address'])))\n continue\n if 'vir' in controller:\n continue\n if 'management' not in network['services']:\n continue\n resources.append(AutoLoadResource(model='Storage Network Port', name=net_name,\n relative_address=controller.upper() + '/' + str(network['address'])))\n\n for port in ports:\n if port['iqn'] is not None:\n port_name = port['name']\n controller = port_name.split('.')[0]\n resources.append(AutoLoadResource(model='iSCSI Storage Port', name=port['name'],\n relative_address=controller + '/' + port['portal']))\n attributes.append(AutoLoadAttribute(controller + '/' + port['portal'], 'iqn', port['iqn']))\n elif port['wwn'] is not None:\n port_name = port['name']\n controller = port_name.split('.')[0]\n resources.append(AutoLoadResource(model='FC Storage Port', name=port['name'],\n relative_address=controller + '/' + port['name'].split('.')[1]))\n attributes.append(AutoLoadAttribute(controller + '/' + port['name'].split('.')[1], 'wwn', port['wwn']))\n\n return AutoLoadDetails(resources, attributes)","def amtool_brief(self, mess, args):\n helper = AmtoolHelper(\n alertmanager_address=self.config['server_address'])\n result = helper.get_alerts()\n return result","def getData(language=None):","def main(self, name):\n\t\tapi_results = [] \n\t\tparams = self.get_search_parameters(name)\n\t\tapi_results.append(self.api_connect(params))\n\t\ttime.sleep(1.0)\n\t\tkey = api_results[0]['businesses'][0]\n\t\tbusiness_information = [key['name'], self.phone_number_organizer(key), key['rating'],\\\n\t\tkey['review_count']]\n\t\treturn business_information","def _get_network_utilization(self):\n options = self.scenario_cfg[\"options\"]\n interval = options.get('interval', 1)\n count = options.get('count', 1)\n\n cmd = \"sudo sar -n DEV %d %d\" % (interval, count)\n\n raw_result = self._execute_command(cmd)\n result = self._filtrate_result(raw_result)\n\n return result","def get_oauth_data():","def probe_api():\n\n info = loads(get(url).text)\n return info","def get():"],"string":"[\n \"def getUsageInfo(self):\\n return self.jsonRequest(\\\"/api/v1/usage\\\", { \\\"apiKey\\\": self._apiKey })\",\n \"def get_application_api_usage_get(self, applicationId, end, start):\\n # TODO: Assuming first server is good - need to make fallback logic\\n return self.session.get_any(\\\"{base}{request_url}\\\".format(base=self.servers[0],\\n request_url=F\\\"/App/ApiUsage/{applicationId}/\\\"))\",\n \"def get_usage_data(username, password):\\n usage_req = XfinityUsage(username, password, browser_name=\\\"firefox-headless\\\")\\n return usage_req.run()\",\n \"def test_getusage(self):\\n ret = {\\\"message\\\": \\\"No Random.org api key or api version found.\\\", \\\"res\\\": False}\\n self.assertDictEqual(random_org.getUsage(), ret)\\n\\n self.assertDictEqual(\\n random_org.getUsage(api_key=\\\"peW\\\", api_version=\\\"1\\\"),\\n {\\n \\\"bitsLeft\\\": None,\\n \\\"requestsLeft\\\": None,\\n \\\"res\\\": True,\\n \\\"totalBits\\\": None,\\n \\\"totalRequests\\\": None,\\n },\\n )\",\n \"async def __getDataFromBalance(self, account) -> dict:\\n _LOGGER.info(\\\"Getting appliance usage data\\\")\\n\\n data = {}\\n\\n URL_BALANCE = API_HOST + \\\"/api/resources/account/{account}/balance?count=-1\\\"\\n\\n try:\\n async with async_timeout.timeout(TIMEOUT):\\n response = await self.session.get(URL_BALANCE.format(account=account))\\n if response.status == 200:\\n data = (await response.json())[\\\"data\\\"]\\n\\n indice = [i for i, x in enumerate(data) if x[\\\"details\\\"] == \\\"DEBT\\\"][\\n 0\\n ]\\n\\n deb = data[indice][\\\"amount\\\"]\\n\\n except Exception as e:\\n _LOGGER.error(e)\\n\\n return {\\\"balance_data\\\": data}\",\n \"def retr_devices_by_app( app ) :\\n\\n\\t\\t\\t_logger.info( '...retr_devices_by_app...' )\\n\\t\\t\\toutput = []\\n\\t\\t\\ttry :\\n\\t\\t\\t\\tdb = mongo.db.auth_devices\\n\\t\\t\\t\\tfor device in db.find( { 'app_tags' : app } ) :\\n\\t\\t\\t\\t\\toutput.append({'moniker' : device['moniker'] ,\\n\\t\\t\\t\\t\\t\\t\\t\\t 'description' : device['description'] ,\\n\\t\\t\\t\\t\\t\\t\\t\\t 'active' : device['active'] ,\\n\\t\\t\\t\\t\\t\\t\\t\\t 'device_id' : device['device_id'] ,\\n\\t\\t\\t\\t\\t\\t\\t\\t 'enlisted' : device['enlisted'] ,\\n\\t\\t\\t\\t\\t\\t\\t\\t 'last_kown_remote_ip' : device['last_known_remote_ip'] ,\\n\\t\\t\\t\\t\\t\\t\\t\\t 'engaged' : device['engaged'] ,\\n\\t\\t\\t\\t\\t\\t\\t\\t 'canononical_user' : device['canonical_user'] ,\\n\\t\\t\\t\\t\\t\\t\\t\\t 'scope' : device['scope'] ,\\n\\t\\t\\t\\t\\t\\t\\t\\t 'segment' : device['segment']\\n\\t\\t\\t\\t\\t})\\n\\t\\t\\texcept Exception as e :\\n\\t\\t\\t\\t _logger.error( '...retr_devices_by_app %s' % e.message )\\n\\t\\t\\treturn jsonify({'result' : output})\",\n \"def get_data():\\n pass\",\n \"def get_info():\\n global PERF_APP\\n archs = None\\n best_arch = None\\n cipher_algos = None\\n hash_algos = None\\n aead_algos = None\\n\\n cmd = PERF_APP + ' --print-info'\\n\\n try:\\n res = subprocess.run(cmd, stdout=subprocess.PIPE, \\\\\\n stderr=subprocess.STDOUT, \\\\\\n env=ENVS, shell=True, check=True)\\n output = res.stdout.decode('utf-8')\\n except subprocess.CalledProcessError as e:\\n print(\\\"Error (\\\" + str(e.returncode) + \\\")\\\")\\n print(e.output.decode('utf-8'))\\n sys.exit(1)\\n\\n lines = output.rstrip().split('\\\\n')\\n try:\\n for line in lines:\\n info = line.split(':')\\n if info[0] == 'Supported architectures':\\n archs = info[1].split()\\n if info[0] == 'Best architecture':\\n best_arch = info[1].split()\\n if info[0] == 'Supported cipher algorithms':\\n cipher_algos = info[1].split()\\n if info[0] == 'Supported hash algorithms':\\n hash_algos = info[1].split()\\n if info[0] == 'Supported aead algorithms':\\n aead_algos = info[1].split()\\n except:\\n print(\\\"Error parsing --print-info output:\\\\n\\\" \\\\\\n \\\"{}\\\".format(output), file=sys.stderr)\\n\\n if archs is None or best_arch is None or cipher_algos is None \\\\\\n or hash_algos is None or aead_algos is None:\\n print(\\\"Error parsing system and app information\\\", file=sys.stderr)\\n sys.exit(1)\\n\\n return archs, best_arch, cipher_algos, hash_algos, aead_algos\",\n \"def usage(self, host):\",\n \"def getInfo():\",\n \"def print_app_data(self):\\n print(\\\"===================================\\\")\\n print(\\\"== RESULTS: ==\\\")\\n print(\\\"===================================\\\")\\n\\n # Analog application results\\n print(\\\"--------------------------\\\")\\n print(\\\"-- Analog applications --\\\")\\n print(\\\"--------------------------\\\")\\n print(\\\"Number of analog application processed: {}\\\".format(len(self.analog_apps)))\\n if (self.verbose):\\n for app in self.analog_apps:\\n print(\\\" Application data:\\\")\\n print(\\\" - - - - - - - - - - - - -\\\")\\n print(' - EPICS PREFIX: MPLN:{}:{}:{}'.format(app[\\\"link_node_area\\\"].upper(), app[\\\"link_node_location\\\"].upper(), app[\\\"card_index\\\"]))\\n print(\\\" - App ID : {}\\\".format(app[\\\"app_id\\\"]))\\n print(\\\" - Cpu name : {}\\\".format(app[\\\"cpu_name\\\"]))\\n print(\\\" - Crate ID : {}\\\".format(app[\\\"crate_id\\\"]))\\n print(\\\" - Slot number : {}\\\".format(app[\\\"slot_number\\\"]))\\n print(\\\" - Link node name : {}\\\".format(app[\\\"link_node_name\\\"]))\\n print(\\\" - Link node area : {}\\\".format(app[\\\"link_node_area\\\"]))\\n print(\\\" - Link node location : {}\\\".format(app[\\\"link_node_location\\\"]))\\n print(\\\" - Card index : {}\\\".format(app[\\\"card_index\\\"]))\\n print(\\\" - Number of devices : {}\\\".format(len(app[\\\"devices\\\"])))\\n for device in app[\\\"devices\\\"]:\\n print(\\\" Device data:\\\")\\n print(\\\" .....................\\\")\\n print(\\\" - EPICS PREFIX: {}:{}:{}\\\".format(device[\\\"type_name\\\"], device[\\\"area\\\"], device[\\\"position\\\"]))\\n print(\\\" - Type name : {}\\\".format(device[\\\"type_name\\\"]))\\n print(\\\" - Bay number : {}\\\".format(device[\\\"bay_number\\\"]))\\n print(\\\" - Channel number : {}\\\".format(device[\\\"channel_number\\\"]))\\n print(\\\" - Area : {}\\\".format(device[\\\"area\\\"]))\\n print(\\\" - Position : {}\\\".format(device[\\\"position\\\"]))\\n print(\\\" - Number of faults : {}\\\".format(len(device[\\\"faults\\\"])))\\n for fault_id,fault_data in device[\\\"faults\\\"].items():\\n print(\\\" Fault data:\\\")\\n print(\\\" . . . . . . . . . . . . \\\")\\n print(\\\" - EPICS PREFIX: {}_T{}\\\".format(fault_data[\\\"name\\\"], fault_data[\\\"bit_positions\\\"][0]))\\n print(\\\" - ID : {}\\\".format(fault_id))\\n print(\\\" - Name : {}\\\".format(fault_data[\\\"name\\\"]))\\n print(\\\" - Description : {}\\\".format(fault_data[\\\"description\\\"]))\\n print(\\\" - Bit positions : {}\\\".format(fault_data[\\\"bit_positions\\\"]))\\n print(\\\" . . . . . . . . . . . . \\\")\\n print(\\\" .....................\\\")\\n print(\\\" - - - - - - - - - - - - -\\\")\\n print(\\\"\\\")\\n print(\\\"--------------------------\\\")\\n\\n # Digital application result\\n print(\\\"----------------------------\\\")\\n print(\\\"-- Digital applications --\\\")\\n print(\\\"----------------------------\\\")\\n print(\\\"Number of digital application processed: {}\\\".format(len(self.digital_apps)))\\n if (self.verbose):\\n for app in self.digital_apps:\\n print(\\\" Application data:\\\")\\n print(\\\" - - - - - - - - - - - - -\\\")\\n print(' - EPICS PREFIX: MPLN:{}:{}:{}'.format(app[\\\"link_node_area\\\"].upper(), app[\\\"link_node_location\\\"].upper(), app[\\\"card_index\\\"]))\\n print(\\\" - App ID : {}\\\".format(app[\\\"app_id\\\"]))\\n print(\\\" - Cpu name : {}\\\".format(app[\\\"cpu_name\\\"]))\\n print(\\\" - Crate ID : {}\\\".format(app[\\\"crate_id\\\"]))\\n print(\\\" - Slot number : {}\\\".format(app[\\\"slot_number\\\"]))\\n print(\\\" - Link node name : {}\\\".format(app[\\\"link_node_name\\\"]))\\n print(\\\" - Link node area : {}\\\".format(app[\\\"link_node_area\\\"]))\\n print(\\\" - Link node location : {}\\\".format(app[\\\"link_node_location\\\"]))\\n print(\\\" - Card index : {}\\\".format(app[\\\"card_index\\\"]))\\n print(\\\" - Number of devices : {}\\\".format(len(app[\\\"devices\\\"])))\\n for device in app[\\\"devices\\\"]:\\n print(\\\" Device data:\\\")\\n print(\\\" .....................\\\")\\n print(\\\" - EPICS PREFIX: {}:{}:{}\\\".format(device[\\\"type_name\\\"], device[\\\"area\\\"], device[\\\"position\\\"]))\\n print(\\\" - Type name : {}\\\".format(device[\\\"type_name\\\"]))\\n print(\\\" - Area : {}\\\".format(device[\\\"area\\\"]))\\n print(\\\" - Position : {}\\\".format(device[\\\"position\\\"]))\\n print(\\\" - Number of inputs : {}\\\".format(len(device[\\\"inputs\\\"])))\\n for input in device[\\\"inputs\\\"]:\\n print(\\\" Input data:\\\")\\n print(\\\" . . . . . . . . . . . . \\\")\\n print(\\\" - EPICS PREFIX: {}\\\".format(input[\\\"name\\\"]))\\n print(\\\" - Name : {}\\\".format(input[\\\"name\\\"]))\\n print(\\\" - Bit position : {}\\\".format(input[\\\"bit_position\\\"]))\\n print(\\\" - Zero name : {}\\\".format(input[\\\"zero_name\\\"]))\\n print(\\\" - One name : {}\\\".format(input[\\\"one_name\\\"]))\\n print(\\\" - Alarm state : {}\\\".format(input[\\\"alarm_state\\\"]))\\n print(\\\" - Debounce : {}\\\".format(input[\\\"debounce\\\"]))\\n print(\\\" . . . . . . . . . . . . \\\")\\n print(\\\" .....................\\\")\\n print(\\\" - - - - - - - - - - - - -\\\")\\n print(\\\"\\\")\\n print(\\\"----------------------------\\\")\\n\\n\\n print(\\\"===================================\\\")\\n\\n print('Found {} link nodes:'.format(len(self.link_nodes)))\\n for k,v in self.link_nodes.items():\\n print('{}: {}'.format(k, v['type']))\",\n \"def get_apk(self):\",\n \"def get_discovery_summary():\\n pass\",\n \"def usage_information(self):\\n return self._usage_information\",\n \"def gather_metric(self):\\n result = self._shell.run(self.ADB_COMMAND)\\n stdout = result.stdout.splitlines()\\n adb_version = stdout[0].split()[-1]\\n # Revision information will always be in next line\\n adb_revision = stdout[1].split()[1]\\n\\n response = {\\n self.ADB_VERSION: adb_version,\\n self.ADB_REVISION: adb_revision\\n }\\n return response\",\n \"def device_overview(self):\\r\\n data = {}\\r\\n\\r\\n # GET DATA\\r\\n token = request.headers.get('token')\\r\\n userid = request.headers.get('userid')\\r\\n vessel_id = request.args.get('vessel_id')\\r\\n epoch_format = request.args.get('format')\\r\\n\\r\\n # CHECK TOKEN\\r\\n if not self.validate_token(token, userid):\\r\\n data['alert'] = \\\"Invalid Token\\\"\\r\\n data['status'] = 'Failed'\\r\\n return self.return_data(data)\\r\\n\\r\\n alarm_types = self.get_alarm_types()\\r\\n\\r\\n ats = self.get_alarm_trigger()\\r\\n\\r\\n devices = self.couch_query.get_all_devices(vessel_id)\\r\\n\\r\\n standard_time = self.epoch_day(time.time())\\r\\n\\r\\n epoch_time = time.time()\\r\\n\\r\\n temp_data = []\\r\\n\\r\\n start_date = self.get_start_date(epoch_format)\\r\\n\\r\\n if not start_date and epoch_format not in [\\\"day\\\", \\\"hours\\\"]:\\r\\n\\r\\n data['alert'] = \\\"Invalid format!\\\"\\r\\n data['status'] = 'Failed'\\r\\n\\r\\n return self.return_data(data)\\r\\n\\r\\n for device in devices:\\r\\n\\r\\n if device['doc']['device'] in ['PARAMETERS', 'NTWCONF', 'NTWPERF1']:\\r\\n\\r\\n continue\\r\\n\\r\\n row = {}\\r\\n row['device'] = device['doc']['device']\\r\\n row['name'] = device['doc']['device']\\r\\n row['Alert'] = 0\\r\\n row['Critical'] = 0\\r\\n row['Warning'] = 0\\r\\n row['Info'] = 0\\r\\n row['Debug'] = 0\\r\\n for atrigger in ats:\\r\\n\\r\\n trigger_type = self.get_alarm_type_name(alarm_types, atrigger['alarm_type_id'])\\r\\n\\r\\n at_id = atrigger['alarm_trigger_id']\\r\\n device_id = device['id']\\r\\n\\r\\n datas = self.calc.calculate_trigger([at_id], standard_time,\\r\\n epoch_time, vessel_id=vessel_id,\\r\\n device_id=device_id)\\r\\n\\r\\n if not datas == \\\"No Alarm Trigger found.\\\":\\r\\n\\r\\n datas_index_0 = datas[0]\\r\\n len_datas = datas_index_0['results']\\r\\n if len_datas:\\r\\n\\r\\n row[trigger_type] = 1\\r\\n\\r\\n if epoch_format in ['week', 'month', \\\"quarter\\\", 'annual']:\\r\\n\\r\\n sql_str = \\\"SELECT COUNT(alarm_trigger_id) FROM alarm_data \\\"\\r\\n sql_str += \\\"WHERE device_id='{0}' \\\".format(device_id)\\r\\n sql_str += \\\"AND epoch_date > {0} \\\".format(start_date)\\r\\n sql_str += \\\"AND epoch_date < {0}\\\".format(epoch_time)\\r\\n\\r\\n res = self.postgres.query_fetch_one(sql_str)\\r\\n\\r\\n row[trigger_type] = row[trigger_type] + res['count']\\r\\n\\r\\n temp_data.append(row)\\r\\n\\r\\n final_data = {}\\r\\n final_data['data'] = temp_data\\r\\n final_data['status'] = 'ok'\\r\\n\\r\\n return self.return_data(final_data)\",\n \"def get_devices_summary():\\n\\n # This function was created to replace get_devices_information\\n # because it wasn't detecting virtual systems in Palo Alto Virtual Systems\\n global nipper_xml\\n devices = {}\\n headings = []\\n\\n # Add the table headings to a list\\n for h in nipper_xml.findall(\\\"./summary/table/[@ref='SCOPE.AUDITDEVICELIST.TABLE']/headings/heading\\\"):\\n if h not in headings:\\n headings.append(h.text)\\n\\n for device in nipper_xml.findall(\\\"./summary/table/[@ref='SCOPE.AUDITDEVICELIST.TABLE']/tablebody/tablerow\\\"):\\n values = []\\n for i in device.findall('./tablecell/item'):\\n if i not in values:\\n values.append(i.text)\\n if DEBUG:\\n print \\\"\\\\t\\\" + note + \\\"%s: %s\\\" % (headings[headings.index('Name')], values[headings.index('Name')])\\n print \\\"\\\\t\\\" + note + \\\"%s: %s\\\" % (headings[headings.index('Device')], values[headings.index('Device')])\\n print \\\"\\\\t\\\" + note + \\\"%s: %s\\\" % (headings[headings.index('OS')], values[headings.index('OS')].split(\\\" \\\")[0])\\n print \\\"\\\\t\\\" + note + \\\"%s: %s\\\" % (headings[headings.index('OS')], values[headings.index('OS')].split(\\\" \\\")[1])\\n devices[values[headings.index('Name')]] = {'name': values[headings.index('Name')],\\n 'type': values[headings.index('Device')],\\n 'os': values[headings.index('OS')].split(' ')[0],\\n 'osversion': values[headings.index('OS')].split(' ')[1]\\n }\\n\\n if DEBUG:\\n print info + \\\"Device Object:\\\"\\n print devices\\n raw_input(warn + \\\"Press enter to continue\\\")\\n return devices\",\n \"def getEnergyUsage():\\n energy_data = asyncio.run(plug.get_emeter_realtime())\\n\\n return energy_data\",\n \"def get_data():\\n return\",\n \"def data_setup_appliances():\\n appliance_list = []\\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_BASIC, \\\"appliance1\\\", gpio_pin_id=None))\\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_BASIC, \\\"appliance2\\\", gpio_pin_id=None))\\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_BASIC, \\\"appliance3\\\", gpio_pin_id=None))\\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_BASIC, \\\"appliance4\\\", gpio_pin_id=None))\\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_BASIC, \\\"appliance5\\\", gpio_pin_id=None))\\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_RELAY, \\\"gpio_appliance1\\\", gpio_pin_id=13))\\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_RELAY, \\\"gpio_appliance2\\\", gpio_pin_id=15))\\n return appliance_list\",\n \"def get_data(self):\",\n \"def _get_data(self):\\n c = Connector(self.host, self.username, self.password)\\n return c.getLanDevices()\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def user_sends_get_call_to_the_devices():\\n web_app.list_devices()\",\n \"def info_equipment_get():\\n equipment = _equipment_by_group()\\n return equipment, 200\",\n \"def retrieve_dial_data(app_name):\\n # NOTE: the reference code store the file in the application folder, we read the file in our data folder\\n # perhaps other changes will be needed to allow USE_ADDITIONAL_DATA feature to work\\n file_path = 'dial_data/' + app_name + '.json'\\n if not fileops.file_exists(file_path):\\n return {}\\n data = fileops.load_file_def(file_path)\\n return json.loads(data)\",\n \"def get(self):\\n try:\\n log.debug(\\\"Device info : \\\")\\n #get the payload to influx DB\\n url = \\\"http://localhost:8086/query\\\"\\n querystring = {\\\"pretty\\\": \\\"true\\\", \\\"db\\\": \\\"IOT\\\",\\n \\\"q\\\":\\\"SELECT DISTINCT(deviceId) FROM(SELECT deviceId,q1 FROM \\\\\\\"ttd_devices\\\\\\\" ) \\\" }\\n response = requests.request(\\\"GET\\\", url, params=querystring)\\n r_d=json.loads(response.text)\\n result_d=[]\\n for rec in r_d['results'][0]['series']:\\n for element in rec['values']:\\n result_d.append(element[1])\\n result={}\\n result['status'] = 1\\n result['message']=result_d\\n return_status = 200\\n except ValueError as e:\\n result = {}\\n log.exception('Value Exception while fetching device list')\\n result['status'] = 0\\n return_status = 400\\n result['message'] = e.args[0]\\n except :\\n result = {}\\n log.exception('Exception while fetching the device data')\\n return_status = 500\\n result['status'] = 0\\n result['message'] = 'Internal Error has occurred while fetching devie data'\\n finally:\\n resp = Response(json.dumps(result), status=return_status, mimetype=\\\"application/json\\\")\\n return resp\",\n \"def show(ctx, appeui):\\n if '.' in appeui:\\n appeui = str(hexStringInt(str(appeui)))\\n \\n # Form the url and payload\\n server = ctx.obj['server']\\n payload = {'token': ctx.obj['token']}\\n url = 'http://{}/api/v{}'.format(server, str(version))\\n url += '/apps' if appeui == 'all' else '/app/{}'.format(appeui)\\n \\n # Make the request\\n data = restRequest(server, url, 'get', payload, 200)\\n if data is None:\\n return\\n \\n # Single application\\n if appeui != 'all':\\n a = data\\n indent = ' ' * 10\\n if a['appinterface_id'] == 0:\\n a['appinterface_id'] = '-'\\n if a['domain'] is None:\\n a['domain'] = '-'\\n click.echo('Application EUI: ' + euiString(a['appeui']))\\n click.echo('{}name: {}'.format(indent, a['name']))\\n click.echo('{}domain: {}'.format(indent, a['domain']))\\n click.echo('{}fport: {}'.format(indent, a['fport']))\\n click.echo('{}interface: {}'.format(indent, a['appinterface_id']))\\n if a['appinterface_id'] != '-':\\n click.echo('{}Properties:'.format(indent))\\n properties = sorted(a['properties'].values(), key=lambda k: k['port'])\\n for p in properties:\\n click.echo('{} {} {}:{}'.format(indent, p['port'], p['name'], p['type']))\\n return\\n \\n # All applications\\n click.echo('{:14}'.format('Application') + \\\\\\n '{:24}'.format('AppEUI') + \\\\\\n '{:15}'.format('Domain') + \\\\\\n '{:6}'.format('Fport') + \\\\\\n '{:10}'.format('Interface'))\\n for i,a in data.iteritems():\\n if a['appinterface_id'] == 0:\\n a['appinterface_id'] = '-'\\n if a['domain'] is None:\\n a['domain'] = '-'\\n click.echo('{:13.13}'.format(a['name']) + ' ' + \\\\\\n '{:23}'.format(euiString(a['appeui'])) + ' ' + \\\\\\n '{:14.14}'.format(a['domain']) + ' ' + \\\\\\n '{:5.5}'.format(str(a['fport'])) + ' ' + \\\\\\n '{:10}'.format(str(a['appinterface_id'])))\",\n \"def get_usage_data(self):\\n with self._lock:\\n data_copy = self._data.copy()\\n return data_copy\",\n \"def get_listing_information():\\n\\n #getting the guidebox_id variable from show_page.html\\n guidebox_id = request.args.get(\\\"guidebox_id\\\")\\n\\n #get the show from the database\\n show = Show.find_show_with_guidebox_id(guidebox_id)\\n\\n #get show title from Guidebox so it can be used in the OnConnect title search url \\n show_title = str(show.title)\\n\\n #get OnConnect seriesId\\n series_id = onconnect_search_series_id(show_title)\\n\\n #obtaining listing information for a 24 hour period from the current time\\n airings = onconnect_search_airings(series_id)\\n\\n return jsonify(airings)\",\n \"def available(self, app):\\n return self.xlist(\\\"testfor\\\", app)[0]\",\n \"def GetData(self):\\r\\n if self.Error == False:\\r\\n Extra = {}\\r\\n try:\\r\\n result = {}\\r\\n temp = self.ScrapeMainWebpage()\\r\\n if temp != None:\\r\\n result.update(temp)\\r\\n temp = self.ScrapeParameters1Webpage()\\r\\n if temp != None:\\r\\n result.update(temp)\\r\\n temp = self.ScrapeParameters2Webpage()\\r\\n if temp != None:\\r\\n result.update(temp)\\r\\n temp = self.ScrapeStatusWebpage()\\r\\n if temp != None:\\r\\n result.update(temp)\\r\\n sqlArray = {}\\r\\n sqlArray[self.deviceDescr] = {}\\r\\n sqlArray[self.deviceDescr][self.devNumber] = {}\\r\\n sqlArray[self.deviceDescr][self.devNumber][\\\"General\\\"] = result\\r\\n sqlArray[self.deviceDescr][self.devNumber][\\\"_ExtractInfo\\\"] = {}\\r\\n sqlArray[self.deviceDescr][self.devNumber][\\\"_ExtractInfo\\\"][\\\"ExtractTime\\\"] = time.time()\\r\\n sqlArray[\\\"ReadError\\\"] = False \\r\\n return sqlArray\\r\\n \\r\\n except Exception as e: \\r\\n self.log.printError(\\\"ERROR in Retreiving Seatel VSAT Data,%s Module Error\\\" % sys._getframe().f_code.co_name) \\r\\n self.log.printError( str(e))\\r\\n self.Error = True\\r\\n Extra[\\\"ReadError\\\"] = True\\r\\n return Extra\\r\\n else:\\r\\n self.log.printWarning(\\\"%s skipped due to previous failure\\\" % sys._getframe().f_code.co_name)\\r\\n return None\",\n \"def __get_data_from_store(term):\\n url_search = PLAY_STORE_URL + \\\"/search\\\"\\n response = requests.get(url_search, {'c': 'apps', 'q': term})\\n soup = BeautifulSoup(response.content, \\\"html.parser\\\")\\n apps = soup.find_all(\\\"div\\\", {\\\"class\\\": \\\"card no-rationale square-cover apps small\\\"})\\n\\n result = []\\n print(result)\\n for i, app in enumerate(apps):\\n app_details_basic = app.find(\\\"div\\\", {\\\"class\\\": \\\"details\\\"})\\n app_id = app['data-docid']\\n app_data = {\\n 'uid': app_id,\\n 'name': app_details_basic.find(\\\"a\\\", {\\\"class\\\": \\\"title\\\"})['title'].strip().encode('utf-8'),\\n 'dev_name': app_details_basic.find(\\\"a\\\", {\\\"class\\\": \\\"subtitle\\\"})['title'].strip(),\\n 'icon_url': \\\"http://\\\" + app.find(\\n \\\"div\\\", {\\\"class\\\": \\\"cover-inner-align\\\"}).img['data-cover-large'].strip(\\\"//\\\")\\n }\\n\\n url_app_detail = PLAY_STORE_URL + \\\"/apps/details\\\"\\n response = requests.get(url_app_detail, {'id': app_id})\\n soup = BeautifulSoup(response.content, \\\"html.parser\\\")\\n\\n app_data.update({\\n 'category': soup.find(\\\"a\\\", {\\\"itemprop\\\": \\\"genre\\\"}).text,\\n 'description': soup.find(\\\"div\\\", {\\\"itemprop\\\": \\\"description\\\"}).text.strip().encode('utf-8'),\\n \\n })\\n\\n \\n dev_links = soup.find_all(\\\"a\\\", {\\\"class\\\": \\\"dev-link\\\", \\\"rel\\\": \\\"nofollow\\\"})\\n if dev_links:\\n for dev_link in dev_links:\\n if \\\"mailto\\\" in dev_link['href']:\\n app_data['dev_email'] = dev_link['href'].replace(\\\"mailto:\\\", \\\"\\\")\\n break\\n\\n result.append(app_data)\\n\\n if i + 1 == SEARCH_RESULT_COUNT:\\n break\\n print(result)\\n return result\",\n \"def get_usage(self):\\r\\n return self.box_usage\",\n \"async def get_device_data(self):\\n pass\",\n \"def getatt(self):\\n err = True\\n retry = 0\\n while err and retry<2:\\n try:\\n r = requests.get(self.url+'ATT?\\\\n')\\n res = float(r.text)\\n err = False\\n except:\\n err = True\\n time.sleep(1)\\n retry += 1\\n res = nan\\n return res\",\n \"def get_data(self):\\n pass\",\n \"def get_data(self):\\n pass\",\n \"def application_list(p_engine, p_username, format, appname):\\n\\n ret = 0\\n\\n enginelist = get_list_of_engines(p_engine, p_username)\\n\\n if enginelist is None:\\n return 1\\n\\n data = DataFormatter()\\n data_header = [\\n (\\\"Engine name\\\", 30),\\n (\\\"Application name\\\", 30),\\n ]\\n data.create_header(data_header)\\n data.format_type = format\\n for engine_tuple in enginelist:\\n engine_obj = DxMaskingEngine(engine_tuple)\\n if engine_obj.get_session():\\n continue\\n applist = DxApplicationList()\\n # load all objects\\n applist.LoadApplications()\\n\\n if appname is None:\\n applications = applist.get_allref()\\n else:\\n applications = applist.get_applicationId_by_name(appname)\\n if len(applications) == 0:\\n ret = ret + 1\\n\\n for appref in applications:\\n appobj = applist.get_by_ref(appref)\\n data.data_insert(\\n engine_tuple[0],\\n appobj.application_name\\n )\\n\\n print(\\\"\\\")\\n print (data.data_output(False))\\n print(\\\"\\\")\\n \\n \\n return ret\",\n \"def _get_dapall_from_api(self):\\n\\n url = marvin.config.urlmap['api']['dapall']['url']\\n\\n url_full = url.format(name=self.plateifu,\\n bintype=self.bintype.name,\\n template=self.template.name)\\n\\n try:\\n response = self._toolInteraction(url_full)\\n except Exception as ee:\\n raise MarvinError('found a problem while getting DAPall: {0}'.format(str(ee)))\\n\\n if response.results['error'] is not None:\\n raise MarvinError('found a problem while getting DAPall: {}'\\n .format(str(response.results['error'])))\\n\\n data = response.getData()\\n\\n return data['dapall_data']\",\n \"def get_usage(self, start=None, end=None):\\n return self.manager.get_usage(self, start=start, end=end)\",\n \"def usage():\\n return _usage\",\n \"def summary(app):\\n click.echo(get_summary(app))\",\n \"def test_duo_application_get(self):\\n pass\",\n \"def get_data(self):\\r\\n pass\",\n \"def usage(where=sys.stdout):\\n print('Gather Holding IDs via REST using a list of MMS IDs.',\\n file=where) \\n print('Usage:', file=where)\\n print(' west2_gather_Holding_IDs.py <file.txt> <APIKEY>', file=where)\\n print('Where:', file=where)\\n print(' file.txt List of MSS IDs (one / line)',\\n file=where)\\n print(' APIKEY API key for accessing Alma REST APIs',\\n file=where)\\n print('Output:', file=where)\\n print(' Generates a datestamped text file: holding-and-mss-ids.<date>.txt',\\n file=where)\\n print(' consisting of lines holding_id<tab>mms_id', file=where)\",\n \"def get_appliances(self):\\n if self.appliances is not None:\\n return self.appliances\\n self.appliances = Appliance.objects.filter(user=self.request.user)\\n return self.appliances\",\n \"def get_usages(self):\\n return self.client._perform_json(\\\"GET\\\", \\\"/projects/%s/managedfolders/%s/usages\\\" % (self.project_key, self.odb_id))\",\n \"def get_usage(self):\\n return self.box_usage\",\n \"def AcquiredData (self) :\\n\\t\\treturn self.run(\\\"AcquiredData\\\")\",\n \"def usage():\\r\\n print 'Usage: collect_logs.py testrun \\\"env1, env2,...\\\" \\\"oscounters, applogs, gclogs, traces\\\"'\\r\\n print \\\"testrun = Name of the test execution e.g. 12032713\\\"\\r\\n print \\\"environments = Name of the environment defined in the environments.ini file\\\"\\r\\n print \\\"logtypes = List types of logfiles to collect\\\"\",\n \"def get(category, page=1, per_page=5):\\r\\n\\r\\n count = n_count(category)\\r\\n\\r\\n sql = text('''SELECT app.id, app.name, app.short_name, app.description,\\r\\n app.info, app.created, app.category_id, \\\"user\\\".fullname AS owner,\\r\\n featured.app_id as featured\\r\\n FROM \\\"user\\\", task, app\\r\\n LEFT OUTER JOIN category ON app.category_id=category.id\\r\\n LEFT OUTER JOIN featured ON app.id=featured.app_id\\r\\n WHERE\\r\\n category.short_name=:category\\r\\n AND app.hidden=0\\r\\n AND \\\"user\\\".id=app.owner_id\\r\\n AND app.info LIKE('%task_presenter%')\\r\\n AND task.app_id=app.id\\r\\n GROUP BY app.id, \\\"user\\\".id, featured.app_id ORDER BY app.name\\r\\n OFFSET :offset\\r\\n LIMIT :limit;''')\\r\\n\\r\\n offset = (page - 1) * per_page\\r\\n results = db.engine.execute(sql, category=category, limit=per_page, offset=offset)\\r\\n apps = []\\r\\n for row in results:\\r\\n app = dict(id=row.id,\\r\\n name=row.name, short_name=row.short_name,\\r\\n created=row.created,\\r\\n description=row.description,\\r\\n owner=row.owner,\\r\\n featured=row.featured,\\r\\n last_activity=pretty_date(last_activity(row.id)),\\r\\n last_activity_raw=last_activity(row.id),\\r\\n overall_progress=overall_progress(row.id),\\r\\n info=dict(json.loads(row.info)))\\r\\n apps.append(app)\\r\\n return apps, count\",\n \"def getStockData():\\n pass\",\n \"def extract_programs():\\n if settings.XPRO_CATALOG_API_URL:\\n return requests.get(settings.XPRO_CATALOG_API_URL, timeout=20).json()\\n return []\",\n \"def data():\\n return volumes_fetchers.get_json_data()\",\n \"def get_antivirus_info():\\n query = {\\n \\\"type\\\": \\\"op\\\",\\n \\\"cmd\\\": \\\"<request><anti-virus><upgrade><info></info></upgrade></anti-virus></request>\\\",\\n }\\n\\n return __proxy__[\\\"panos.call\\\"](query)\",\n \"def test_mock_datasource_usages(self):\\n account1 = self.test_data.accounts[0]\\n meter = account1.meters[0]\\n usage = meter.usages[0]\\n self.assertIsInstance(usage, Usage)\\n self.assertEqual(usage.PK, 6)\\n self.assertEqual(usage.UsageActualName, \\\"test_usage\\\")\\n self.assertEqual(usage.UsageAmount, Decimal(50.0))\\n self.assertEqual(usage.RateComponent, \\\"test_rate_component\\\")\\n self.assertEqual(usage.EnergyUnit, \\\"test_energy_unit\\\")\\n self.assertEqual(usage.IntervalStart, date(2016, 1, 1))\\n self.assertEqual(usage.IntervalEnd, date(2016, 2, 1))\",\n \"def get_data_qos(args):\\n diff_data(args, \\\"qos\\\")\",\n \"def getAppInfo(self):\\n data = self._client.Application.find(self.app_id)\\n return data\",\n \"def get_device_info(target_project_arn):\\n try:\\n device_info = device_farm.list_devices(\\n arn=target_project_arn,\\n filters=[\\n {\\n \\\"attribute\\\": \\\"PLATFORM\\\",\\n \\\"operator\\\": \\\"EQUALS\\\",\\n \\\"values\\\": ['ANDROID', ]\\n },\\n {\\n \\\"attribute\\\": \\\"OS_VERSION\\\",\\n \\\"operator\\\": \\\"GREATER_THAN_OR_EQUALS\\\",\\n \\\"values\\\": ['9', ]\\n },\\n {\\n \\\"attribute\\\": \\\"MANUFACTURER\\\",\\n \\\"operator\\\": \\\"EQUALS\\\",\\n \\\"values\\\": ['Google', ]\\n },\\n {\\n \\\"attribute\\\": \\\"AVAILABILITY\\\",\\n \\\"operator\\\": \\\"EQUALS\\\",\\n \\\"values\\\": ['HIGHLY_AVAILABLE', ]\\n },\\n {\\n \\\"attribute\\\": \\\"FLEET_TYPE\\\",\\n \\\"operator\\\": \\\"EQUALS\\\",\\n \\\"values\\\": ['PUBLIC', ]\\n }\\n ])['devices']\\n\\n if device_info is not None:\\n device_arn = device_info[0]['arn']\\n device_name = device_info[0]['name']\\n device_manufacture = device_info[0]['manufacturer']\\n device_model = device_info[0]['model']\\n device_model_id = device_info[0]['modelId']\\n device_type = device_info[0]['formFactor']\\n device_platform = device_info[0]['platform']\\n device_os = device_info[0]['os']\\n device_visibility = device_info[0]['fleetType']\\n device_availability = device_info[0]['availability']\\n\\n print('Device Name - {} with Manufacture {}, model {}, modelId {} & type {}'.format(\\n device_name,\\n device_manufacture,\\n device_model,\\n device_model_id,\\n device_type\\n )\\n )\\n print('Device Platform {} with OS {}, visibility {} & availability - {} '.format(\\n device_platform,\\n device_os,\\n device_visibility,\\n device_availability\\n )\\n )\\n\\n if device_availability == TARGET_AVAILABILITY:\\n print('AWS setup is complete')\\n else:\\n print('Problem, device is not available')\\n else:\\n print('Problem finding device info')\\n\\n except IndexError:\\n print('Problem finding device from pool {}'.format(device_info))\",\n \"def access():\",\n \"def stats(self):\\r\\n\\t\\tdata = self._get('global/', query=None)\\r\\n\\t\\treturn data\",\n \"def main():\\n results = []\\n results.extend(check_mounts())\\n results.extend(diskusage())\\n return results\",\n \"def query(self):\\n self._measurements[self.KEY_USAGE].df = self.fetch_data_usage()\",\n \"def get_app(self, app_name, ns_name):\\n\\n status, _ = self.helm_client.status(app_name, namespace=ns_name)\\n values, _ = self.helm_client.get_values(app_name, namespace=ns_name)\\n release_data = {\\\"status\\\": status, \\\"values\\\": values}\\n\\n schema_path = Path(\\\"%s/%s/values.schema.json\\\"\\n % (self._get_ns_dir(ns_name), app_name))\\n if schema_path.exists():\\n schema = json.loads(schema_path.read_text())\\n release_data[\\\"schema\\\"] = schema\\n\\n return release_data\",\n \"def diagnostics(self, oid):\\n path = '/servers/%s/diagnostics' % oid\\n res = self.client.call(path, 'GET', data='', token=self.manager.identity.token)\\n self.logger.debug('Shows basic usage data for server %s: %s' % \\n (oid, truncate(res)))\\n return res[0]\",\n \"def test_get_us_daily_data(self):\\n dag = self.dagbag.get_dag(self.dag_id)\\n extract_task = dag.get_task('extract')\\n resp = self.extract.getDailyUSDataFromAPI()\\n self.assertIsNotNone(resp)\\n self.assertEqual(type(resp), list)\",\n \"def getDeviceInfo():\\n url = \\\"https://api.roblox.com/reference/deviceinfo\\\"\\n r = requests.get(url)\\n j = json.loads(r.text)\\n return j\",\n \"def who():\\n cleanup()\\n return {'available': userlist(), 'eta': data['etas'], 'etd': data['etds'], 'lastlocation': data['lastlocation'], 'ceitloch': ceitloch(), 'reminder': data['reminder']}\",\n \"def get_app_info(self, name):\\n with hide(\\\"output\\\", \\\"running\\\"):\\n result = local(\\\"redis-cli -h {host} -p 6379 -n {db} hgetall {name}\\\".format(\\n host=self.host, name=name, db=REDIS_APPLICATION_DB_NUM), capture=True)\\n\\n if len(result.stdout) > 0:\\n splits = result.stdout.split(\\\"\\\\n\\\")\\n fmt_result = dict([(splits[i], splits[i+1])\\n for i in range(0, len(splits), 2)])\\n pp = pprint.PrettyPrinter(indent=2)\\n pp.pprint(fmt_result)\\n return fmt_result\\n else:\\n warn(\\\"Application \\\\\\\"%s\\\\\\\" not found\\\" % name)\\n return None\",\n \"def get_patient_status():\\n r = requests.get(\\\"http://vcm-7474.vm.duke.edu:5000/api/heart_rate/3\\\")\\n print(r.text)\",\n \"def usage(self):\\r\\n return usage.Usage(self)\",\n \"def get_info(self):\\n pass\",\n \"def get_info(self):\\n pass\",\n \"def getTheData(self, dev):\\n if self.debugLevel >= 2 and self.debug:\\n self.debugLog(u\\\"getTheData FrontViewAPI method called.\\\")\\n\\n # dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\\\"Download\\\")\\n try:\\n url = 'http://' + dev.pluginProps['sourceXML'] + '/FrontView'\\n r = requests.get(url,timeout=5)\\n result = r.json()\\n if self.debugLevel >= 2 and self.debug:\\n self.debugLog(u\\\"Result:\\\" + unicode(result))\\n self.WaitInterval = 1\\n dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\\\"Online\\\")\\n dev.setErrorStateOnServer(None)\\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\\n return result\\n\\n except Exception as error:\\n\\n indigo.server.log(u\\\"Error connecting to Device:\\\" + dev.name)\\n self.WaitInterval = 60\\n if self.debugLevel >= 2 and self.debug:\\n self.debugLog(u\\\"Device is offline. No data to return. \\\")\\n dev.updateStateOnServer('deviceIsOnline', value=False, uiValue=\\\"Offline\\\")\\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\\n dev.setErrorStateOnServer(u'Offline')\\n result = \\\"\\\"\\n return result\",\n \"def device_count():\\n apipath = \\\"/targets/devices\\\"\\n url = SERVER + apipath\\n params = {\\n 'q': '(deviceType:ASA)',\\n 'agg': 'count'}\\n headers = {\\n 'Accept': \\\"application/json\\\",\\n 'Content-Type': \\\"application/json\\\",\\n 'Authorization': \\\"bearer {}\\\".format(token)}\\n response = requests.get(url, verify=False, stream=True, headers=headers, params=params)\\n getstatuscode = response.status_code\\n getresponse = response.json()\\n if getstatuscode == 200:\\n return getresponse\\n else:\\n response.raise_for_status()\",\n \"def appdata(appname):\\n z = Zap(appname)\\n z.appdata(stdout=True)\",\n \"def test_retrieve_1_by_all(self):\\n swa = frontend.SupplyWinApi()\\n query_dict = dict(\\n dev=\\\"rrenaud\\\",\\n targets=\\\"Council Room\\\",\\n interaction=\\\"\\\",\\n unconditional=\\\"true\\\",\\n )\\n\\n card_stats = swa.retrieve_data(query_dict)\\n\\n self.assertEquals(len(card_stats), 1)\\n\\n self.assertEquals(card_stats[0]['card_name'], 'Council Room')\\n self.assertEquals(len(card_stats[0]['condition']), 0)\\n\\n json = swa.readable_json_card_stats(card_stats)\\n self.assertEquals(json[0:14], '[{\\\"card_name\\\":')\",\n \"def games_usage(parsed_args):\\n if parsed_args.verb == \\\"GET\\\":\\n filter_dict = {\\n \\\"game_type\\\": parsed_args.game_type,\\n \\\"genre\\\": parsed_args.genre,\\n \\\"keywords\\\": parsed_args.keywords,\\n \\\"mechanic\\\": parsed_args.mechanic\\n }\\n df = get_games(parsed_args.id, filter_dict)\\n if parsed_args.function == \\\"FILTERS\\\":\\n df = get_game_filters(df)\\n else:\\n df = post_games(df, parsed_args.sort_by, parsed_args.weighting)\\n return df\",\n \"def get_data(self, label):\\n self.application.get_data(label)\",\n \"def get_usage_stats(self) -> UsageStats:\\n return self._usage\",\n \"def get(cls, service, name=\\\"\\\", option_=\\\"\\\") :\\n\\t\\ttry :\\n\\t\\t\\tobj = audit_stats()\\n\\t\\t\\tif not name :\\n\\t\\t\\t\\tresponse = obj.stat_resources(service, option_)\\n\\t\\t\\treturn response\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise e\",\n \"def get(self, request, *args, **kwargs):\\n device = Device.objects.get(name=kwargs[\\\"device_name\\\"])\\n global_settings = GoldenConfigSettings.objects.get(id=\\\"aaaaaaaa-0000-0000-0000-000000000001\\\")\\n status_code, data = graph_ql_query(request, device, global_settings.sot_agg_query)\\n data = json.loads(json.dumps(data))\\n return Response(GraphQLSerializer(data=data).initial_data, status=status_code)\",\n \"def _get_values(self, app_name, chart_dir):\\n\\n raw, _ = self.helm_client.show_info(app_name, \\\"values\\\",\\n chart_dir=chart_dir)\\n return yaml.load(raw, yaml.SafeLoader)\",\n \"def getAPData(ap, timePerRange=3*settings.SNMPAPLAP, \\n\\tstartTime=None,\\n\\tendTime=None):\\n\\n\\tCOUNTERTOSPEED = ['ethernetRxTotalBytes','ethernetTxTotalBytes']\\n\\tGETMAX = []\\n\\t\\n\\tresult = []\\n\\ttry:\\n\\n\\t\\tif startTime == None:\\n\\t\\t\\tstartTime = APSnapshot.objects.aggregate(Min(\\\"date\\\"))[\\\"date__min\\\"]\\n\\t\\tif endTime == None:\\n\\t\\t\\tendTime = APSnapshot.objects.aggregate(Max(\\\"date\\\"))[\\\"date__max\\\"]\\n\\n\\n\\t\\tsnapshots = APSnapshot.objects.filter(ap=ap, date__gte=startTime, date__lte=endTime).order_by('date')\\n\\t\\tstartAt = snapshots[0].date\\n\\t\\t\\n\\t\\tvalues = {}\\n\\t\\tfor data in snapshots[0].apsnapshotdata_set.all():\\n\\t\\t\\tvalues[data.name] = [data.value]\\n\\n\\t\\tfor snap in snapshots[1:]:\\n\\t\\t\\t# Get the data of the period\\n\\t\\t\\tif snap.date < (startAt + timePerRange):\\n\\t\\t\\t\\tfor data in snap.apsnapshotdata_set.all():\\n\\t\\t\\t\\t\\tif data.name in values:\\n\\t\\t\\t\\t\\t\\tvalues[data.name].append(data.value)\\n\\n\\t\\t\\t# Aggregate and reset the period\\n\\t\\t\\telse:\\n\\t\\t\\t\\tdata = {}\\n\\t\\t\\t\\tfor attr, value in values.items():\\n\\t\\t\\t\\t\\tif attr in COUNTERTOSPEED:\\n\\t\\t\\t\\t\\t\\tdata[attr] = getSpeed(value[0], value[-1], timePerRange)\\n\\t\\t\\t\\t\\telif attr in GETMAX:\\n\\t\\t\\t\\t\\t\\tdata[attr] = max(value)\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tdata[attr] = sum(value)/float(len(value))\\n\\n\\t\\t\\t\\tresult.append({'date':timezone.localtime(startAt + timePerRange), 'data': data})\\n\\n\\t\\t\\t\\t# Start new period\\n\\t\\t\\t\\tstartAt = snap.date\\n\\t\\t\\t\\tvalues = {}\\n\\t\\t\\t\\tfor data in snap.apsnapshotdata_set.all():\\n\\t\\t\\t\\t\\tvalues[data.name] = [data.value]\\n\\n\\texcept Exception as e:\\n\\t\\tOperationalError(source=\\\"getAPData\\\", error=str(e)).save()\\n\\t\\traise e\\n\\n\\treturn result\",\n \"def healthcare():\",\n \"def get_patient_average():\\n r = requests.get(\\\"http://vcm-7474.vm.duke.edu:5000/api/heart_rate/average/2\\\")\\n print(r.text)\",\n \"def measurements_lookup(client, database):\\n client.switch_database(database)\\n mlist_dict = client.get_list_measurements()\\n # print(\\\"def measurements_lookup 010:\\\", mlist_dict[:10])\\n return mlist_dict\",\n \"def get_meter_info(apt_no):\\n if apt_no in ['102A', 102]:\\n apt_no = '102A'\\n payload = (\\\"select uuid, Metadata/Instrument/SupplyType \\\"\\n \\\"where Metadata/LoadLocation/FlatNumber ='\\\" + str(apt_no) + \\\"' and \\\"\\n \\\"Metadata/Extra/PhysicalParameter='Power'\\\")\\n\\n r = requests.post(url, data=payload)\\n # logger.debug (\\\"%s\\\",r)\\n payload_body = r.json()\\n # logger.debug (\\\"Payload:\\\\n%s\\\", payload_body)\\n\\n meters = []\\n for i in range(0, len(payload_body)):\\n meter = payload_body[i]\\n\\n meters.append({'uuid': meter['uuid'], 'type': meter[\\n 'Metadata']['Instrument']['SupplyType']})\\n\\n return meters\",\n \"def _get_data(self):\\n devices = []\\n try:\\n if not self.router_client.login():\\n self.hass.states.set(f\\\"{DOMAIN}.statusmsg\\\", self.router_client.statusmsg)\\n _LOGGER.warning(\\\"Login failed: {0}:{1}@{2}\\\".format(self.router_client.username, self.router_client.password,self.router_client.host))\\n self.router_client.logout()\\n return devices\\n\\n devices_json = self.router_client.get_devices_response()\\n finally:\\n self.router_client.logout()\\n\\n self.hass.states.set(f\\\"{DOMAIN}.scanning\\\", devices_json != False)\\n\\n if devices_json != False:\\n for device in devices_json:\\n # _LOGGER.debug(\\\"Device: {0}\\\".format(device))\\n dev = Device(\\n device['HostName'].replace('未知设备', 'Unknown'),\\n device['IPAddress'],\\n device['MACAddress'],\\n device['Active'],\\n ICONS.get(device['IconType'])\\n )\\n # _LOGGER.debug(\\\"Device: {0}\\\".format(dev))\\n devices.append(dev)\\n return devices\\n else:\\n return []\",\n \"def get_inventory(self, context):\\n # See below some example code demonstrating how to return the resource structure\\n # and attributes. In real life, of course, if the actual values are not static,\\n # this code would be preceded by some SNMP/other calls to get the actual resource information\\n '''\\n # Add sub resources details\\n sub_resources = [ AutoLoadResource(model ='Generic Chassis',name= 'Chassis 1', relative_address='1'),\\n AutoLoadResource(model='Generic Module',name= 'Module 1',relative_address= '1/1'),\\n AutoLoadResource(model='Generic Port',name= 'Port 1', relative_address='1/1/1'),\\n AutoLoadResource(model='Generic Port', name='Port 2', relative_address='1/1/2'),\\n AutoLoadResource(model='Generic Power Port', name='Power Port', relative_address='1/PP1')]\\n\\n\\n attributes = [ AutoLoadAttribute(relative_address='', attribute_name='Location', attribute_value='Santa Clara Lab'),\\n AutoLoadAttribute('', 'Model', 'Catalyst 3850'),\\n AutoLoadAttribute('', 'Vendor', 'Cisco'),\\n AutoLoadAttribute('1', 'Serial Number', 'JAE053002JD'),\\n AutoLoadAttribute('1', 'Model', 'WS-X4232-GB-RJ'),\\n AutoLoadAttribute('1/1', 'Model', 'WS-X4233-GB-EJ'),\\n AutoLoadAttribute('1/1', 'Serial Number', 'RVE056702UD'),\\n AutoLoadAttribute('1/1/1', 'MAC Address', 'fe80::e10c:f055:f7f1:bb7t16'),\\n AutoLoadAttribute('1/1/1', 'IPv4 Address', '192.168.10.7'),\\n AutoLoadAttribute('1/1/2', 'MAC Address', 'te67::e40c:g755:f55y:gh7w36'),\\n AutoLoadAttribute('1/1/2', 'IPv4 Address', '192.168.10.9'),\\n AutoLoadAttribute('1/PP1', 'Model', 'WS-X4232-GB-RJ'),\\n AutoLoadAttribute('1/PP1', 'Port Description', 'Power'),\\n AutoLoadAttribute('1/PP1', 'Serial Number', 'RVE056702UD')]\\n\\n return AutoLoadDetails(sub_resources,attributes)\\n '''\\n\\n self._log(context, 'Begin autoload')\\n resources = []\\n attributes = []\\n\\n\\n attributes.append(AutoLoadAttribute('', 'replication_address', self.get_replication_address(context)))\\n attributes.append(AutoLoadAttribute('', 'connection_key', self.get_connection_key(context)))\\n\\n networks = self._get_newtork_interfaces(context)\\n self._log(context, 'got networks')\\n\\n controllers = self._get_controllers(context)\\n self._log(context, 'got controllers')\\n ports = self._get_ports(context)\\n\\n model = None\\n for controller in controllers:\\n self._log(context, 'Processing ctrlt: ' + controller['name'] + ':' + controller['model'])\\n resources.append(AutoLoadResource(model='Generic Storage Controller', name=controller['name'],\\n relative_address=controller['name']))\\n if model is None:\\n model = controller['model']\\n\\n attributes.append(AutoLoadAttribute('', 'Model', model))\\n\\n for network in networks:\\n self._log(context, 'Processing netwk: ' + network['name'] + ':' + str(network['address']))\\n net_name = network['name']\\n controller = net_name.split('.')[0]\\n if 'vir0' in controller or 'vir1' in controller:\\n attributes.append(AutoLoadAttribute('',str(controller + '_address'), str(network['address'])))\\n continue\\n if 'vir' in controller:\\n continue\\n if 'management' not in network['services']:\\n continue\\n resources.append(AutoLoadResource(model='Storage Network Port', name=net_name,\\n relative_address=controller.upper() + '/' + str(network['address'])))\\n\\n for port in ports:\\n if port['iqn'] is not None:\\n port_name = port['name']\\n controller = port_name.split('.')[0]\\n resources.append(AutoLoadResource(model='iSCSI Storage Port', name=port['name'],\\n relative_address=controller + '/' + port['portal']))\\n attributes.append(AutoLoadAttribute(controller + '/' + port['portal'], 'iqn', port['iqn']))\\n elif port['wwn'] is not None:\\n port_name = port['name']\\n controller = port_name.split('.')[0]\\n resources.append(AutoLoadResource(model='FC Storage Port', name=port['name'],\\n relative_address=controller + '/' + port['name'].split('.')[1]))\\n attributes.append(AutoLoadAttribute(controller + '/' + port['name'].split('.')[1], 'wwn', port['wwn']))\\n\\n return AutoLoadDetails(resources, attributes)\",\n \"def amtool_brief(self, mess, args):\\n helper = AmtoolHelper(\\n alertmanager_address=self.config['server_address'])\\n result = helper.get_alerts()\\n return result\",\n \"def getData(language=None):\",\n \"def main(self, name):\\n\\t\\tapi_results = [] \\n\\t\\tparams = self.get_search_parameters(name)\\n\\t\\tapi_results.append(self.api_connect(params))\\n\\t\\ttime.sleep(1.0)\\n\\t\\tkey = api_results[0]['businesses'][0]\\n\\t\\tbusiness_information = [key['name'], self.phone_number_organizer(key), key['rating'],\\\\\\n\\t\\tkey['review_count']]\\n\\t\\treturn business_information\",\n \"def _get_network_utilization(self):\\n options = self.scenario_cfg[\\\"options\\\"]\\n interval = options.get('interval', 1)\\n count = options.get('count', 1)\\n\\n cmd = \\\"sudo sar -n DEV %d %d\\\" % (interval, count)\\n\\n raw_result = self._execute_command(cmd)\\n result = self._filtrate_result(raw_result)\\n\\n return result\",\n \"def get_oauth_data():\",\n \"def probe_api():\\n\\n info = loads(get(url).text)\\n return info\",\n \"def get():\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6542614","0.6461803","0.6203412","0.6135864","0.5930974","0.5910394","0.5888209","0.5844207","0.58017164","0.5787487","0.57435703","0.5714978","0.5709852","0.564539","0.5628239","0.5616134","0.5614402","0.56101","0.5602017","0.55986047","0.5594599","0.5585295","0.555319","0.555319","0.555319","0.55047464","0.54400617","0.5439377","0.54390097","0.5437","0.54108024","0.5409253","0.53943783","0.539259","0.5366763","0.5348971","0.5336694","0.53354645","0.5322523","0.5322523","0.53214484","0.5306477","0.5306357","0.5293695","0.5292136","0.5289622","0.5282176","0.52788544","0.52651113","0.5264503","0.52639383","0.5257026","0.52563804","0.5228213","0.52273536","0.52263695","0.5222667","0.52185977","0.5213061","0.5211865","0.52102023","0.520823","0.52043957","0.5201907","0.51920867","0.5189327","0.51883113","0.5185219","0.5154445","0.5149091","0.51479435","0.5117948","0.5117097","0.51147753","0.51086634","0.51086634","0.51074755","0.51065046","0.5106256","0.51035696","0.51008266","0.5094939","0.5090189","0.5080007","0.5076841","0.5074381","0.5072463","0.5072011","0.5064217","0.5062383","0.5061672","0.50547254","0.5049254","0.5046863","0.50416464","0.5041614","0.50342315","0.5031484","0.50244623","0.50229454"],"string":"[\n \"0.6542614\",\n \"0.6461803\",\n \"0.6203412\",\n \"0.6135864\",\n \"0.5930974\",\n \"0.5910394\",\n \"0.5888209\",\n \"0.5844207\",\n \"0.58017164\",\n \"0.5787487\",\n \"0.57435703\",\n \"0.5714978\",\n \"0.5709852\",\n \"0.564539\",\n \"0.5628239\",\n \"0.5616134\",\n \"0.5614402\",\n \"0.56101\",\n \"0.5602017\",\n \"0.55986047\",\n \"0.5594599\",\n \"0.5585295\",\n \"0.555319\",\n \"0.555319\",\n \"0.555319\",\n \"0.55047464\",\n \"0.54400617\",\n \"0.5439377\",\n \"0.54390097\",\n \"0.5437\",\n \"0.54108024\",\n \"0.5409253\",\n \"0.53943783\",\n \"0.539259\",\n \"0.5366763\",\n \"0.5348971\",\n \"0.5336694\",\n \"0.53354645\",\n \"0.5322523\",\n \"0.5322523\",\n \"0.53214484\",\n \"0.5306477\",\n \"0.5306357\",\n \"0.5293695\",\n \"0.5292136\",\n \"0.5289622\",\n \"0.5282176\",\n \"0.52788544\",\n \"0.52651113\",\n \"0.5264503\",\n \"0.52639383\",\n \"0.5257026\",\n \"0.52563804\",\n \"0.5228213\",\n \"0.52273536\",\n \"0.52263695\",\n \"0.5222667\",\n \"0.52185977\",\n \"0.5213061\",\n \"0.5211865\",\n \"0.52102023\",\n \"0.520823\",\n \"0.52043957\",\n \"0.5201907\",\n \"0.51920867\",\n \"0.5189327\",\n \"0.51883113\",\n \"0.5185219\",\n \"0.5154445\",\n \"0.5149091\",\n \"0.51479435\",\n \"0.5117948\",\n \"0.5117097\",\n \"0.51147753\",\n \"0.51086634\",\n \"0.51086634\",\n \"0.51074755\",\n \"0.51065046\",\n \"0.5106256\",\n \"0.51035696\",\n \"0.51008266\",\n \"0.5094939\",\n \"0.5090189\",\n \"0.5080007\",\n \"0.5076841\",\n \"0.5074381\",\n \"0.5072463\",\n \"0.5072011\",\n \"0.5064217\",\n \"0.5062383\",\n \"0.5061672\",\n \"0.50547254\",\n \"0.5049254\",\n \"0.5046863\",\n \"0.50416464\",\n \"0.5041614\",\n \"0.50342315\",\n \"0.5031484\",\n \"0.50244623\",\n \"0.50229454\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6843256"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":7297,"cells":{"query":{"kind":"string","value":"get data from appliance usage"},"document":{"kind":"string","value":"async def __getDataFromBalance(self, account) -> dict:\n _LOGGER.info(\"Getting appliance usage data\")\n\n data = {}\n\n URL_BALANCE = API_HOST + \"/api/resources/account/{account}/balance?count=-1\"\n\n try:\n async with async_timeout.timeout(TIMEOUT):\n response = await self.session.get(URL_BALANCE.format(account=account))\n if response.status == 200:\n data = (await response.json())[\"data\"]\n\n indice = [i for i, x in enumerate(data) if x[\"details\"] == \"DEBT\"][\n 0\n ]\n\n deb = data[indice][\"amount\"]\n\n except Exception as e:\n _LOGGER.error(e)\n\n return {\"balance_data\": data}"},"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":["async def __getDataFromApplianceUsage(self, account, lastBilledDate) -> dict:\n _LOGGER.info(\"Getting appliance usage data\")\n\n JSON = {\"startDate\": str(lastBilledDate.strftime(\"%m%d%Y\"))}\n data = {}\n\n try:\n async with async_timeout.timeout(TIMEOUT):\n response = await self.session.post(\n URL_APPLIANCE_USAGE.format(account=account), json=JSON\n )\n if response.status == 200:\n electric = (await response.json())[\"data\"][\"electric\"]\n\n full = 100\n for e in electric:\n rr = round(float(e[\"percentageDollar\"]))\n if rr < full:\n full = full - rr\n else:\n rr = full\n data[e[\"category\"].replace(\" \", \"_\")] = rr\n except Exception as e:\n _LOGGER.error(e)\n\n return {\"energy_percent_by_applicance\": data}","def getUsageInfo(self):\n return self.jsonRequest(\"/api/v1/usage\", { \"apiKey\": self._apiKey })","def get_application_api_usage_get(self, applicationId, end, start):\n # TODO: Assuming first server is good - need to make fallback logic\n return self.session.get_any(\"{base}{request_url}\".format(base=self.servers[0],\n request_url=F\"/App/ApiUsage/{applicationId}/\"))","def get_usage_data(username, password):\n usage_req = XfinityUsage(username, password, browser_name=\"firefox-headless\")\n return usage_req.run()","def test_getusage(self):\n ret = {\"message\": \"No Random.org api key or api version found.\", \"res\": False}\n self.assertDictEqual(random_org.getUsage(), ret)\n\n self.assertDictEqual(\n random_org.getUsage(api_key=\"peW\", api_version=\"1\"),\n {\n \"bitsLeft\": None,\n \"requestsLeft\": None,\n \"res\": True,\n \"totalBits\": None,\n \"totalRequests\": None,\n },\n )","def retr_devices_by_app( app ) :\n\n\t\t\t_logger.info( '...retr_devices_by_app...' )\n\t\t\toutput = []\n\t\t\ttry :\n\t\t\t\tdb = mongo.db.auth_devices\n\t\t\t\tfor device in db.find( { 'app_tags' : app } ) :\n\t\t\t\t\toutput.append({'moniker' : device['moniker'] ,\n\t\t\t\t\t\t\t\t 'description' : device['description'] ,\n\t\t\t\t\t\t\t\t 'active' : device['active'] ,\n\t\t\t\t\t\t\t\t 'device_id' : device['device_id'] ,\n\t\t\t\t\t\t\t\t 'enlisted' : device['enlisted'] ,\n\t\t\t\t\t\t\t\t 'last_kown_remote_ip' : device['last_known_remote_ip'] ,\n\t\t\t\t\t\t\t\t 'engaged' : device['engaged'] ,\n\t\t\t\t\t\t\t\t 'canononical_user' : device['canonical_user'] ,\n\t\t\t\t\t\t\t\t 'scope' : device['scope'] ,\n\t\t\t\t\t\t\t\t 'segment' : device['segment']\n\t\t\t\t\t})\n\t\t\texcept Exception as e :\n\t\t\t\t _logger.error( '...retr_devices_by_app %s' % e.message )\n\t\t\treturn jsonify({'result' : output})","def get_data():\n pass","def get_info():\n global PERF_APP\n archs = None\n best_arch = None\n cipher_algos = None\n hash_algos = None\n aead_algos = None\n\n cmd = PERF_APP + ' --print-info'\n\n try:\n res = subprocess.run(cmd, stdout=subprocess.PIPE, \\\n stderr=subprocess.STDOUT, \\\n env=ENVS, shell=True, check=True)\n output = res.stdout.decode('utf-8')\n except subprocess.CalledProcessError as e:\n print(\"Error (\" + str(e.returncode) + \")\")\n print(e.output.decode('utf-8'))\n sys.exit(1)\n\n lines = output.rstrip().split('\\n')\n try:\n for line in lines:\n info = line.split(':')\n if info[0] == 'Supported architectures':\n archs = info[1].split()\n if info[0] == 'Best architecture':\n best_arch = info[1].split()\n if info[0] == 'Supported cipher algorithms':\n cipher_algos = info[1].split()\n if info[0] == 'Supported hash algorithms':\n hash_algos = info[1].split()\n if info[0] == 'Supported aead algorithms':\n aead_algos = info[1].split()\n except:\n print(\"Error parsing --print-info output:\\n\" \\\n \"{}\".format(output), file=sys.stderr)\n\n if archs is None or best_arch is None or cipher_algos is None \\\n or hash_algos is None or aead_algos is None:\n print(\"Error parsing system and app information\", file=sys.stderr)\n sys.exit(1)\n\n return archs, best_arch, cipher_algos, hash_algos, aead_algos","def usage(self, host):","def getInfo():","def print_app_data(self):\n print(\"===================================\")\n print(\"== RESULTS: ==\")\n print(\"===================================\")\n\n # Analog application results\n print(\"--------------------------\")\n print(\"-- Analog applications --\")\n print(\"--------------------------\")\n print(\"Number of analog application processed: {}\".format(len(self.analog_apps)))\n if (self.verbose):\n for app in self.analog_apps:\n print(\" Application data:\")\n print(\" - - - - - - - - - - - - -\")\n print(' - EPICS PREFIX: MPLN:{}:{}:{}'.format(app[\"link_node_area\"].upper(), app[\"link_node_location\"].upper(), app[\"card_index\"]))\n print(\" - App ID : {}\".format(app[\"app_id\"]))\n print(\" - Cpu name : {}\".format(app[\"cpu_name\"]))\n print(\" - Crate ID : {}\".format(app[\"crate_id\"]))\n print(\" - Slot number : {}\".format(app[\"slot_number\"]))\n print(\" - Link node name : {}\".format(app[\"link_node_name\"]))\n print(\" - Link node area : {}\".format(app[\"link_node_area\"]))\n print(\" - Link node location : {}\".format(app[\"link_node_location\"]))\n print(\" - Card index : {}\".format(app[\"card_index\"]))\n print(\" - Number of devices : {}\".format(len(app[\"devices\"])))\n for device in app[\"devices\"]:\n print(\" Device data:\")\n print(\" .....................\")\n print(\" - EPICS PREFIX: {}:{}:{}\".format(device[\"type_name\"], device[\"area\"], device[\"position\"]))\n print(\" - Type name : {}\".format(device[\"type_name\"]))\n print(\" - Bay number : {}\".format(device[\"bay_number\"]))\n print(\" - Channel number : {}\".format(device[\"channel_number\"]))\n print(\" - Area : {}\".format(device[\"area\"]))\n print(\" - Position : {}\".format(device[\"position\"]))\n print(\" - Number of faults : {}\".format(len(device[\"faults\"])))\n for fault_id,fault_data in device[\"faults\"].items():\n print(\" Fault data:\")\n print(\" . . . . . . . . . . . . \")\n print(\" - EPICS PREFIX: {}_T{}\".format(fault_data[\"name\"], fault_data[\"bit_positions\"][0]))\n print(\" - ID : {}\".format(fault_id))\n print(\" - Name : {}\".format(fault_data[\"name\"]))\n print(\" - Description : {}\".format(fault_data[\"description\"]))\n print(\" - Bit positions : {}\".format(fault_data[\"bit_positions\"]))\n print(\" . . . . . . . . . . . . \")\n print(\" .....................\")\n print(\" - - - - - - - - - - - - -\")\n print(\"\")\n print(\"--------------------------\")\n\n # Digital application result\n print(\"----------------------------\")\n print(\"-- Digital applications --\")\n print(\"----------------------------\")\n print(\"Number of digital application processed: {}\".format(len(self.digital_apps)))\n if (self.verbose):\n for app in self.digital_apps:\n print(\" Application data:\")\n print(\" - - - - - - - - - - - - -\")\n print(' - EPICS PREFIX: MPLN:{}:{}:{}'.format(app[\"link_node_area\"].upper(), app[\"link_node_location\"].upper(), app[\"card_index\"]))\n print(\" - App ID : {}\".format(app[\"app_id\"]))\n print(\" - Cpu name : {}\".format(app[\"cpu_name\"]))\n print(\" - Crate ID : {}\".format(app[\"crate_id\"]))\n print(\" - Slot number : {}\".format(app[\"slot_number\"]))\n print(\" - Link node name : {}\".format(app[\"link_node_name\"]))\n print(\" - Link node area : {}\".format(app[\"link_node_area\"]))\n print(\" - Link node location : {}\".format(app[\"link_node_location\"]))\n print(\" - Card index : {}\".format(app[\"card_index\"]))\n print(\" - Number of devices : {}\".format(len(app[\"devices\"])))\n for device in app[\"devices\"]:\n print(\" Device data:\")\n print(\" .....................\")\n print(\" - EPICS PREFIX: {}:{}:{}\".format(device[\"type_name\"], device[\"area\"], device[\"position\"]))\n print(\" - Type name : {}\".format(device[\"type_name\"]))\n print(\" - Area : {}\".format(device[\"area\"]))\n print(\" - Position : {}\".format(device[\"position\"]))\n print(\" - Number of inputs : {}\".format(len(device[\"inputs\"])))\n for input in device[\"inputs\"]:\n print(\" Input data:\")\n print(\" . . . . . . . . . . . . \")\n print(\" - EPICS PREFIX: {}\".format(input[\"name\"]))\n print(\" - Name : {}\".format(input[\"name\"]))\n print(\" - Bit position : {}\".format(input[\"bit_position\"]))\n print(\" - Zero name : {}\".format(input[\"zero_name\"]))\n print(\" - One name : {}\".format(input[\"one_name\"]))\n print(\" - Alarm state : {}\".format(input[\"alarm_state\"]))\n print(\" - Debounce : {}\".format(input[\"debounce\"]))\n print(\" . . . . . . . . . . . . \")\n print(\" .....................\")\n print(\" - - - - - - - - - - - - -\")\n print(\"\")\n print(\"----------------------------\")\n\n\n print(\"===================================\")\n\n print('Found {} link nodes:'.format(len(self.link_nodes)))\n for k,v in self.link_nodes.items():\n print('{}: {}'.format(k, v['type']))","def get_apk(self):","def get_discovery_summary():\n pass","def usage_information(self):\n return self._usage_information","def gather_metric(self):\n result = self._shell.run(self.ADB_COMMAND)\n stdout = result.stdout.splitlines()\n adb_version = stdout[0].split()[-1]\n # Revision information will always be in next line\n adb_revision = stdout[1].split()[1]\n\n response = {\n self.ADB_VERSION: adb_version,\n self.ADB_REVISION: adb_revision\n }\n return response","def device_overview(self):\r\n data = {}\r\n\r\n # GET DATA\r\n token = request.headers.get('token')\r\n userid = request.headers.get('userid')\r\n vessel_id = request.args.get('vessel_id')\r\n epoch_format = request.args.get('format')\r\n\r\n # CHECK TOKEN\r\n if not self.validate_token(token, userid):\r\n data['alert'] = \"Invalid Token\"\r\n data['status'] = 'Failed'\r\n return self.return_data(data)\r\n\r\n alarm_types = self.get_alarm_types()\r\n\r\n ats = self.get_alarm_trigger()\r\n\r\n devices = self.couch_query.get_all_devices(vessel_id)\r\n\r\n standard_time = self.epoch_day(time.time())\r\n\r\n epoch_time = time.time()\r\n\r\n temp_data = []\r\n\r\n start_date = self.get_start_date(epoch_format)\r\n\r\n if not start_date and epoch_format not in [\"day\", \"hours\"]:\r\n\r\n data['alert'] = \"Invalid format!\"\r\n data['status'] = 'Failed'\r\n\r\n return self.return_data(data)\r\n\r\n for device in devices:\r\n\r\n if device['doc']['device'] in ['PARAMETERS', 'NTWCONF', 'NTWPERF1']:\r\n\r\n continue\r\n\r\n row = {}\r\n row['device'] = device['doc']['device']\r\n row['name'] = device['doc']['device']\r\n row['Alert'] = 0\r\n row['Critical'] = 0\r\n row['Warning'] = 0\r\n row['Info'] = 0\r\n row['Debug'] = 0\r\n for atrigger in ats:\r\n\r\n trigger_type = self.get_alarm_type_name(alarm_types, atrigger['alarm_type_id'])\r\n\r\n at_id = atrigger['alarm_trigger_id']\r\n device_id = device['id']\r\n\r\n datas = self.calc.calculate_trigger([at_id], standard_time,\r\n epoch_time, vessel_id=vessel_id,\r\n device_id=device_id)\r\n\r\n if not datas == \"No Alarm Trigger found.\":\r\n\r\n datas_index_0 = datas[0]\r\n len_datas = datas_index_0['results']\r\n if len_datas:\r\n\r\n row[trigger_type] = 1\r\n\r\n if epoch_format in ['week', 'month', \"quarter\", 'annual']:\r\n\r\n sql_str = \"SELECT COUNT(alarm_trigger_id) FROM alarm_data \"\r\n sql_str += \"WHERE device_id='{0}' \".format(device_id)\r\n sql_str += \"AND epoch_date > {0} \".format(start_date)\r\n sql_str += \"AND epoch_date < {0}\".format(epoch_time)\r\n\r\n res = self.postgres.query_fetch_one(sql_str)\r\n\r\n row[trigger_type] = row[trigger_type] + res['count']\r\n\r\n temp_data.append(row)\r\n\r\n final_data = {}\r\n final_data['data'] = temp_data\r\n final_data['status'] = 'ok'\r\n\r\n return self.return_data(final_data)","def get_devices_summary():\n\n # This function was created to replace get_devices_information\n # because it wasn't detecting virtual systems in Palo Alto Virtual Systems\n global nipper_xml\n devices = {}\n headings = []\n\n # Add the table headings to a list\n for h in nipper_xml.findall(\"./summary/table/[@ref='SCOPE.AUDITDEVICELIST.TABLE']/headings/heading\"):\n if h not in headings:\n headings.append(h.text)\n\n for device in nipper_xml.findall(\"./summary/table/[@ref='SCOPE.AUDITDEVICELIST.TABLE']/tablebody/tablerow\"):\n values = []\n for i in device.findall('./tablecell/item'):\n if i not in values:\n values.append(i.text)\n if DEBUG:\n print \"\\t\" + note + \"%s: %s\" % (headings[headings.index('Name')], values[headings.index('Name')])\n print \"\\t\" + note + \"%s: %s\" % (headings[headings.index('Device')], values[headings.index('Device')])\n print \"\\t\" + note + \"%s: %s\" % (headings[headings.index('OS')], values[headings.index('OS')].split(\" \")[0])\n print \"\\t\" + note + \"%s: %s\" % (headings[headings.index('OS')], values[headings.index('OS')].split(\" \")[1])\n devices[values[headings.index('Name')]] = {'name': values[headings.index('Name')],\n 'type': values[headings.index('Device')],\n 'os': values[headings.index('OS')].split(' ')[0],\n 'osversion': values[headings.index('OS')].split(' ')[1]\n }\n\n if DEBUG:\n print info + \"Device Object:\"\n print devices\n raw_input(warn + \"Press enter to continue\")\n return devices","def getEnergyUsage():\n energy_data = asyncio.run(plug.get_emeter_realtime())\n\n return energy_data","def get_data():\n return","def data_setup_appliances():\n appliance_list = []\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_BASIC, \"appliance1\", gpio_pin_id=None))\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_BASIC, \"appliance2\", gpio_pin_id=None))\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_BASIC, \"appliance3\", gpio_pin_id=None))\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_BASIC, \"appliance4\", gpio_pin_id=None))\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_BASIC, \"appliance5\", gpio_pin_id=None))\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_RELAY, \"gpio_appliance1\", gpio_pin_id=13))\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_RELAY, \"gpio_appliance2\", gpio_pin_id=15))\n return appliance_list","def get_data(self):","def _get_data(self):\n c = Connector(self.host, self.username, self.password)\n return c.getLanDevices()","def get_data():\n pass","def get_data():\n pass","def get_data():\n pass","def user_sends_get_call_to_the_devices():\n web_app.list_devices()","def info_equipment_get():\n equipment = _equipment_by_group()\n return equipment, 200","def get(self):\n try:\n log.debug(\"Device info : \")\n #get the payload to influx DB\n url = \"http://localhost:8086/query\"\n querystring = {\"pretty\": \"true\", \"db\": \"IOT\",\n \"q\":\"SELECT DISTINCT(deviceId) FROM(SELECT deviceId,q1 FROM \\\"ttd_devices\\\" ) \" }\n response = requests.request(\"GET\", url, params=querystring)\n r_d=json.loads(response.text)\n result_d=[]\n for rec in r_d['results'][0]['series']:\n for element in rec['values']:\n result_d.append(element[1])\n result={}\n result['status'] = 1\n result['message']=result_d\n return_status = 200\n except ValueError as e:\n result = {}\n log.exception('Value Exception while fetching device list')\n result['status'] = 0\n return_status = 400\n result['message'] = e.args[0]\n except :\n result = {}\n log.exception('Exception while fetching the device data')\n return_status = 500\n result['status'] = 0\n result['message'] = 'Internal Error has occurred while fetching devie data'\n finally:\n resp = Response(json.dumps(result), status=return_status, mimetype=\"application/json\")\n return resp","def retrieve_dial_data(app_name):\n # NOTE: the reference code store the file in the application folder, we read the file in our data folder\n # perhaps other changes will be needed to allow USE_ADDITIONAL_DATA feature to work\n file_path = 'dial_data/' + app_name + '.json'\n if not fileops.file_exists(file_path):\n return {}\n data = fileops.load_file_def(file_path)\n return json.loads(data)","def show(ctx, appeui):\n if '.' in appeui:\n appeui = str(hexStringInt(str(appeui)))\n \n # Form the url and payload\n server = ctx.obj['server']\n payload = {'token': ctx.obj['token']}\n url = 'http://{}/api/v{}'.format(server, str(version))\n url += '/apps' if appeui == 'all' else '/app/{}'.format(appeui)\n \n # Make the request\n data = restRequest(server, url, 'get', payload, 200)\n if data is None:\n return\n \n # Single application\n if appeui != 'all':\n a = data\n indent = ' ' * 10\n if a['appinterface_id'] == 0:\n a['appinterface_id'] = '-'\n if a['domain'] is None:\n a['domain'] = '-'\n click.echo('Application EUI: ' + euiString(a['appeui']))\n click.echo('{}name: {}'.format(indent, a['name']))\n click.echo('{}domain: {}'.format(indent, a['domain']))\n click.echo('{}fport: {}'.format(indent, a['fport']))\n click.echo('{}interface: {}'.format(indent, a['appinterface_id']))\n if a['appinterface_id'] != '-':\n click.echo('{}Properties:'.format(indent))\n properties = sorted(a['properties'].values(), key=lambda k: k['port'])\n for p in properties:\n click.echo('{} {} {}:{}'.format(indent, p['port'], p['name'], p['type']))\n return\n \n # All applications\n click.echo('{:14}'.format('Application') + \\\n '{:24}'.format('AppEUI') + \\\n '{:15}'.format('Domain') + \\\n '{:6}'.format('Fport') + \\\n '{:10}'.format('Interface'))\n for i,a in data.iteritems():\n if a['appinterface_id'] == 0:\n a['appinterface_id'] = '-'\n if a['domain'] is None:\n a['domain'] = '-'\n click.echo('{:13.13}'.format(a['name']) + ' ' + \\\n '{:23}'.format(euiString(a['appeui'])) + ' ' + \\\n '{:14.14}'.format(a['domain']) + ' ' + \\\n '{:5.5}'.format(str(a['fport'])) + ' ' + \\\n '{:10}'.format(str(a['appinterface_id'])))","def get_usage_data(self):\n with self._lock:\n data_copy = self._data.copy()\n return data_copy","def get_listing_information():\n\n #getting the guidebox_id variable from show_page.html\n guidebox_id = request.args.get(\"guidebox_id\")\n\n #get the show from the database\n show = Show.find_show_with_guidebox_id(guidebox_id)\n\n #get show title from Guidebox so it can be used in the OnConnect title search url \n show_title = str(show.title)\n\n #get OnConnect seriesId\n series_id = onconnect_search_series_id(show_title)\n\n #obtaining listing information for a 24 hour period from the current time\n airings = onconnect_search_airings(series_id)\n\n return jsonify(airings)","def available(self, app):\n return self.xlist(\"testfor\", app)[0]","def GetData(self):\r\n if self.Error == False:\r\n Extra = {}\r\n try:\r\n result = {}\r\n temp = self.ScrapeMainWebpage()\r\n if temp != None:\r\n result.update(temp)\r\n temp = self.ScrapeParameters1Webpage()\r\n if temp != None:\r\n result.update(temp)\r\n temp = self.ScrapeParameters2Webpage()\r\n if temp != None:\r\n result.update(temp)\r\n temp = self.ScrapeStatusWebpage()\r\n if temp != None:\r\n result.update(temp)\r\n sqlArray = {}\r\n sqlArray[self.deviceDescr] = {}\r\n sqlArray[self.deviceDescr][self.devNumber] = {}\r\n sqlArray[self.deviceDescr][self.devNumber][\"General\"] = result\r\n sqlArray[self.deviceDescr][self.devNumber][\"_ExtractInfo\"] = {}\r\n sqlArray[self.deviceDescr][self.devNumber][\"_ExtractInfo\"][\"ExtractTime\"] = time.time()\r\n sqlArray[\"ReadError\"] = False \r\n return sqlArray\r\n \r\n except Exception as e: \r\n self.log.printError(\"ERROR in Retreiving Seatel VSAT Data,%s Module Error\" % sys._getframe().f_code.co_name) \r\n self.log.printError( str(e))\r\n self.Error = True\r\n Extra[\"ReadError\"] = True\r\n return Extra\r\n else:\r\n self.log.printWarning(\"%s skipped due to previous failure\" % sys._getframe().f_code.co_name)\r\n return None","def __get_data_from_store(term):\n url_search = PLAY_STORE_URL + \"/search\"\n response = requests.get(url_search, {'c': 'apps', 'q': term})\n soup = BeautifulSoup(response.content, \"html.parser\")\n apps = soup.find_all(\"div\", {\"class\": \"card no-rationale square-cover apps small\"})\n\n result = []\n print(result)\n for i, app in enumerate(apps):\n app_details_basic = app.find(\"div\", {\"class\": \"details\"})\n app_id = app['data-docid']\n app_data = {\n 'uid': app_id,\n 'name': app_details_basic.find(\"a\", {\"class\": \"title\"})['title'].strip().encode('utf-8'),\n 'dev_name': app_details_basic.find(\"a\", {\"class\": \"subtitle\"})['title'].strip(),\n 'icon_url': \"http://\" + app.find(\n \"div\", {\"class\": \"cover-inner-align\"}).img['data-cover-large'].strip(\"//\")\n }\n\n url_app_detail = PLAY_STORE_URL + \"/apps/details\"\n response = requests.get(url_app_detail, {'id': app_id})\n soup = BeautifulSoup(response.content, \"html.parser\")\n\n app_data.update({\n 'category': soup.find(\"a\", {\"itemprop\": \"genre\"}).text,\n 'description': soup.find(\"div\", {\"itemprop\": \"description\"}).text.strip().encode('utf-8'),\n \n })\n\n \n dev_links = soup.find_all(\"a\", {\"class\": \"dev-link\", \"rel\": \"nofollow\"})\n if dev_links:\n for dev_link in dev_links:\n if \"mailto\" in dev_link['href']:\n app_data['dev_email'] = dev_link['href'].replace(\"mailto:\", \"\")\n break\n\n result.append(app_data)\n\n if i + 1 == SEARCH_RESULT_COUNT:\n break\n print(result)\n return result","def get_usage(self):\r\n return self.box_usage","async def get_device_data(self):\n pass","def getatt(self):\n err = True\n retry = 0\n while err and retry<2:\n try:\n r = requests.get(self.url+'ATT?\\n')\n res = float(r.text)\n err = False\n except:\n err = True\n time.sleep(1)\n retry += 1\n res = nan\n return res","def get_data(self):\n pass","def get_data(self):\n pass","def application_list(p_engine, p_username, format, appname):\n\n ret = 0\n\n enginelist = get_list_of_engines(p_engine, p_username)\n\n if enginelist is None:\n return 1\n\n data = DataFormatter()\n data_header = [\n (\"Engine name\", 30),\n (\"Application name\", 30),\n ]\n data.create_header(data_header)\n data.format_type = format\n for engine_tuple in enginelist:\n engine_obj = DxMaskingEngine(engine_tuple)\n if engine_obj.get_session():\n continue\n applist = DxApplicationList()\n # load all objects\n applist.LoadApplications()\n\n if appname is None:\n applications = applist.get_allref()\n else:\n applications = applist.get_applicationId_by_name(appname)\n if len(applications) == 0:\n ret = ret + 1\n\n for appref in applications:\n appobj = applist.get_by_ref(appref)\n data.data_insert(\n engine_tuple[0],\n appobj.application_name\n )\n\n print(\"\")\n print (data.data_output(False))\n print(\"\")\n \n \n return ret","def get_usage(self, start=None, end=None):\n return self.manager.get_usage(self, start=start, end=end)","def _get_dapall_from_api(self):\n\n url = marvin.config.urlmap['api']['dapall']['url']\n\n url_full = url.format(name=self.plateifu,\n bintype=self.bintype.name,\n template=self.template.name)\n\n try:\n response = self._toolInteraction(url_full)\n except Exception as ee:\n raise MarvinError('found a problem while getting DAPall: {0}'.format(str(ee)))\n\n if response.results['error'] is not None:\n raise MarvinError('found a problem while getting DAPall: {}'\n .format(str(response.results['error'])))\n\n data = response.getData()\n\n return data['dapall_data']","def usage():\n return _usage","def summary(app):\n click.echo(get_summary(app))","def test_duo_application_get(self):\n pass","def get_data(self):\r\n pass","def usage(where=sys.stdout):\n print('Gather Holding IDs via REST using a list of MMS IDs.',\n file=where) \n print('Usage:', file=where)\n print(' west2_gather_Holding_IDs.py <file.txt> <APIKEY>', file=where)\n print('Where:', file=where)\n print(' file.txt List of MSS IDs (one / line)',\n file=where)\n print(' APIKEY API key for accessing Alma REST APIs',\n file=where)\n print('Output:', file=where)\n print(' Generates a datestamped text file: holding-and-mss-ids.<date>.txt',\n file=where)\n print(' consisting of lines holding_id<tab>mms_id', file=where)","def get_usages(self):\n return self.client._perform_json(\"GET\", \"/projects/%s/managedfolders/%s/usages\" % (self.project_key, self.odb_id))","def get_usage(self):\n return self.box_usage","def get_appliances(self):\n if self.appliances is not None:\n return self.appliances\n self.appliances = Appliance.objects.filter(user=self.request.user)\n return self.appliances","def usage():\r\n print 'Usage: collect_logs.py testrun \"env1, env2,...\" \"oscounters, applogs, gclogs, traces\"'\r\n print \"testrun = Name of the test execution e.g. 12032713\"\r\n print \"environments = Name of the environment defined in the environments.ini file\"\r\n print \"logtypes = List types of logfiles to collect\"","def AcquiredData (self) :\n\t\treturn self.run(\"AcquiredData\")","def get(category, page=1, per_page=5):\r\n\r\n count = n_count(category)\r\n\r\n sql = text('''SELECT app.id, app.name, app.short_name, app.description,\r\n app.info, app.created, app.category_id, \"user\".fullname AS owner,\r\n featured.app_id as featured\r\n FROM \"user\", task, app\r\n LEFT OUTER JOIN category ON app.category_id=category.id\r\n LEFT OUTER JOIN featured ON app.id=featured.app_id\r\n WHERE\r\n category.short_name=:category\r\n AND app.hidden=0\r\n AND \"user\".id=app.owner_id\r\n AND app.info LIKE('%task_presenter%')\r\n AND task.app_id=app.id\r\n GROUP BY app.id, \"user\".id, featured.app_id ORDER BY app.name\r\n OFFSET :offset\r\n LIMIT :limit;''')\r\n\r\n offset = (page - 1) * per_page\r\n results = db.engine.execute(sql, category=category, limit=per_page, offset=offset)\r\n apps = []\r\n for row in results:\r\n app = dict(id=row.id,\r\n name=row.name, short_name=row.short_name,\r\n created=row.created,\r\n description=row.description,\r\n owner=row.owner,\r\n featured=row.featured,\r\n last_activity=pretty_date(last_activity(row.id)),\r\n last_activity_raw=last_activity(row.id),\r\n overall_progress=overall_progress(row.id),\r\n info=dict(json.loads(row.info)))\r\n apps.append(app)\r\n return apps, count","def extract_programs():\n if settings.XPRO_CATALOG_API_URL:\n return requests.get(settings.XPRO_CATALOG_API_URL, timeout=20).json()\n return []","def getStockData():\n pass","def data():\n return volumes_fetchers.get_json_data()","def get_antivirus_info():\n query = {\n \"type\": \"op\",\n \"cmd\": \"<request><anti-virus><upgrade><info></info></upgrade></anti-virus></request>\",\n }\n\n return __proxy__[\"panos.call\"](query)","def test_mock_datasource_usages(self):\n account1 = self.test_data.accounts[0]\n meter = account1.meters[0]\n usage = meter.usages[0]\n self.assertIsInstance(usage, Usage)\n self.assertEqual(usage.PK, 6)\n self.assertEqual(usage.UsageActualName, \"test_usage\")\n self.assertEqual(usage.UsageAmount, Decimal(50.0))\n self.assertEqual(usage.RateComponent, \"test_rate_component\")\n self.assertEqual(usage.EnergyUnit, \"test_energy_unit\")\n self.assertEqual(usage.IntervalStart, date(2016, 1, 1))\n self.assertEqual(usage.IntervalEnd, date(2016, 2, 1))","def get_data_qos(args):\n diff_data(args, \"qos\")","def getAppInfo(self):\n data = self._client.Application.find(self.app_id)\n return data","def get_device_info(target_project_arn):\n try:\n device_info = device_farm.list_devices(\n arn=target_project_arn,\n filters=[\n {\n \"attribute\": \"PLATFORM\",\n \"operator\": \"EQUALS\",\n \"values\": ['ANDROID', ]\n },\n {\n \"attribute\": \"OS_VERSION\",\n \"operator\": \"GREATER_THAN_OR_EQUALS\",\n \"values\": ['9', ]\n },\n {\n \"attribute\": \"MANUFACTURER\",\n \"operator\": \"EQUALS\",\n \"values\": ['Google', ]\n },\n {\n \"attribute\": \"AVAILABILITY\",\n \"operator\": \"EQUALS\",\n \"values\": ['HIGHLY_AVAILABLE', ]\n },\n {\n \"attribute\": \"FLEET_TYPE\",\n \"operator\": \"EQUALS\",\n \"values\": ['PUBLIC', ]\n }\n ])['devices']\n\n if device_info is not None:\n device_arn = device_info[0]['arn']\n device_name = device_info[0]['name']\n device_manufacture = device_info[0]['manufacturer']\n device_model = device_info[0]['model']\n device_model_id = device_info[0]['modelId']\n device_type = device_info[0]['formFactor']\n device_platform = device_info[0]['platform']\n device_os = device_info[0]['os']\n device_visibility = device_info[0]['fleetType']\n device_availability = device_info[0]['availability']\n\n print('Device Name - {} with Manufacture {}, model {}, modelId {} & type {}'.format(\n device_name,\n device_manufacture,\n device_model,\n device_model_id,\n device_type\n )\n )\n print('Device Platform {} with OS {}, visibility {} & availability - {} '.format(\n device_platform,\n device_os,\n device_visibility,\n device_availability\n )\n )\n\n if device_availability == TARGET_AVAILABILITY:\n print('AWS setup is complete')\n else:\n print('Problem, device is not available')\n else:\n print('Problem finding device info')\n\n except IndexError:\n print('Problem finding device from pool {}'.format(device_info))","def access():","def stats(self):\r\n\t\tdata = self._get('global/', query=None)\r\n\t\treturn data","def main():\n results = []\n results.extend(check_mounts())\n results.extend(diskusage())\n return results","def get_app(self, app_name, ns_name):\n\n status, _ = self.helm_client.status(app_name, namespace=ns_name)\n values, _ = self.helm_client.get_values(app_name, namespace=ns_name)\n release_data = {\"status\": status, \"values\": values}\n\n schema_path = Path(\"%s/%s/values.schema.json\"\n % (self._get_ns_dir(ns_name), app_name))\n if schema_path.exists():\n schema = json.loads(schema_path.read_text())\n release_data[\"schema\"] = schema\n\n return release_data","def query(self):\n self._measurements[self.KEY_USAGE].df = self.fetch_data_usage()","def diagnostics(self, oid):\n path = '/servers/%s/diagnostics' % oid\n res = self.client.call(path, 'GET', data='', token=self.manager.identity.token)\n self.logger.debug('Shows basic usage data for server %s: %s' % \n (oid, truncate(res)))\n return res[0]","def test_get_us_daily_data(self):\n dag = self.dagbag.get_dag(self.dag_id)\n extract_task = dag.get_task('extract')\n resp = self.extract.getDailyUSDataFromAPI()\n self.assertIsNotNone(resp)\n self.assertEqual(type(resp), list)","def getDeviceInfo():\n url = \"https://api.roblox.com/reference/deviceinfo\"\n r = requests.get(url)\n j = json.loads(r.text)\n return j","def who():\n cleanup()\n return {'available': userlist(), 'eta': data['etas'], 'etd': data['etds'], 'lastlocation': data['lastlocation'], 'ceitloch': ceitloch(), 'reminder': data['reminder']}","def get_app_info(self, name):\n with hide(\"output\", \"running\"):\n result = local(\"redis-cli -h {host} -p 6379 -n {db} hgetall {name}\".format(\n host=self.host, name=name, db=REDIS_APPLICATION_DB_NUM), capture=True)\n\n if len(result.stdout) > 0:\n splits = result.stdout.split(\"\\n\")\n fmt_result = dict([(splits[i], splits[i+1])\n for i in range(0, len(splits), 2)])\n pp = pprint.PrettyPrinter(indent=2)\n pp.pprint(fmt_result)\n return fmt_result\n else:\n warn(\"Application \\\"%s\\\" not found\" % name)\n return None","def get_patient_status():\n r = requests.get(\"http://vcm-7474.vm.duke.edu:5000/api/heart_rate/3\")\n print(r.text)","def usage(self):\r\n return usage.Usage(self)","def get_info(self):\n pass","def get_info(self):\n pass","def getTheData(self, dev):\n if self.debugLevel >= 2 and self.debug:\n self.debugLog(u\"getTheData FrontViewAPI method called.\")\n\n # dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\"Download\")\n try:\n url = 'http://' + dev.pluginProps['sourceXML'] + '/FrontView'\n r = requests.get(url,timeout=5)\n result = r.json()\n if self.debugLevel >= 2 and self.debug:\n self.debugLog(u\"Result:\" + unicode(result))\n self.WaitInterval = 1\n dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\"Online\")\n dev.setErrorStateOnServer(None)\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\n return result\n\n except Exception as error:\n\n indigo.server.log(u\"Error connecting to Device:\" + dev.name)\n self.WaitInterval = 60\n if self.debugLevel >= 2 and self.debug:\n self.debugLog(u\"Device is offline. No data to return. \")\n dev.updateStateOnServer('deviceIsOnline', value=False, uiValue=\"Offline\")\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\n dev.setErrorStateOnServer(u'Offline')\n result = \"\"\n return result","def device_count():\n apipath = \"/targets/devices\"\n url = SERVER + apipath\n params = {\n 'q': '(deviceType:ASA)',\n 'agg': 'count'}\n headers = {\n 'Accept': \"application/json\",\n 'Content-Type': \"application/json\",\n 'Authorization': \"bearer {}\".format(token)}\n response = requests.get(url, verify=False, stream=True, headers=headers, params=params)\n getstatuscode = response.status_code\n getresponse = response.json()\n if getstatuscode == 200:\n return getresponse\n else:\n response.raise_for_status()","def appdata(appname):\n z = Zap(appname)\n z.appdata(stdout=True)","def test_retrieve_1_by_all(self):\n swa = frontend.SupplyWinApi()\n query_dict = dict(\n dev=\"rrenaud\",\n targets=\"Council Room\",\n interaction=\"\",\n unconditional=\"true\",\n )\n\n card_stats = swa.retrieve_data(query_dict)\n\n self.assertEquals(len(card_stats), 1)\n\n self.assertEquals(card_stats[0]['card_name'], 'Council Room')\n self.assertEquals(len(card_stats[0]['condition']), 0)\n\n json = swa.readable_json_card_stats(card_stats)\n self.assertEquals(json[0:14], '[{\"card_name\":')","def games_usage(parsed_args):\n if parsed_args.verb == \"GET\":\n filter_dict = {\n \"game_type\": parsed_args.game_type,\n \"genre\": parsed_args.genre,\n \"keywords\": parsed_args.keywords,\n \"mechanic\": parsed_args.mechanic\n }\n df = get_games(parsed_args.id, filter_dict)\n if parsed_args.function == \"FILTERS\":\n df = get_game_filters(df)\n else:\n df = post_games(df, parsed_args.sort_by, parsed_args.weighting)\n return df","def get_data(self, label):\n self.application.get_data(label)","def get_usage_stats(self) -> UsageStats:\n return self._usage","def get(cls, service, name=\"\", option_=\"\") :\n\t\ttry :\n\t\t\tobj = audit_stats()\n\t\t\tif not name :\n\t\t\t\tresponse = obj.stat_resources(service, option_)\n\t\t\treturn response\n\t\texcept Exception as e:\n\t\t\traise e","def get(self, request, *args, **kwargs):\n device = Device.objects.get(name=kwargs[\"device_name\"])\n global_settings = GoldenConfigSettings.objects.get(id=\"aaaaaaaa-0000-0000-0000-000000000001\")\n status_code, data = graph_ql_query(request, device, global_settings.sot_agg_query)\n data = json.loads(json.dumps(data))\n return Response(GraphQLSerializer(data=data).initial_data, status=status_code)","def _get_values(self, app_name, chart_dir):\n\n raw, _ = self.helm_client.show_info(app_name, \"values\",\n chart_dir=chart_dir)\n return yaml.load(raw, yaml.SafeLoader)","def healthcare():","def getAPData(ap, timePerRange=3*settings.SNMPAPLAP, \n\tstartTime=None,\n\tendTime=None):\n\n\tCOUNTERTOSPEED = ['ethernetRxTotalBytes','ethernetTxTotalBytes']\n\tGETMAX = []\n\t\n\tresult = []\n\ttry:\n\n\t\tif startTime == None:\n\t\t\tstartTime = APSnapshot.objects.aggregate(Min(\"date\"))[\"date__min\"]\n\t\tif endTime == None:\n\t\t\tendTime = APSnapshot.objects.aggregate(Max(\"date\"))[\"date__max\"]\n\n\n\t\tsnapshots = APSnapshot.objects.filter(ap=ap, date__gte=startTime, date__lte=endTime).order_by('date')\n\t\tstartAt = snapshots[0].date\n\t\t\n\t\tvalues = {}\n\t\tfor data in snapshots[0].apsnapshotdata_set.all():\n\t\t\tvalues[data.name] = [data.value]\n\n\t\tfor snap in snapshots[1:]:\n\t\t\t# Get the data of the period\n\t\t\tif snap.date < (startAt + timePerRange):\n\t\t\t\tfor data in snap.apsnapshotdata_set.all():\n\t\t\t\t\tif data.name in values:\n\t\t\t\t\t\tvalues[data.name].append(data.value)\n\n\t\t\t# Aggregate and reset the period\n\t\t\telse:\n\t\t\t\tdata = {}\n\t\t\t\tfor attr, value in values.items():\n\t\t\t\t\tif attr in COUNTERTOSPEED:\n\t\t\t\t\t\tdata[attr] = getSpeed(value[0], value[-1], timePerRange)\n\t\t\t\t\telif attr in GETMAX:\n\t\t\t\t\t\tdata[attr] = max(value)\n\t\t\t\t\telse:\n\t\t\t\t\t\tdata[attr] = sum(value)/float(len(value))\n\n\t\t\t\tresult.append({'date':timezone.localtime(startAt + timePerRange), 'data': data})\n\n\t\t\t\t# Start new period\n\t\t\t\tstartAt = snap.date\n\t\t\t\tvalues = {}\n\t\t\t\tfor data in snap.apsnapshotdata_set.all():\n\t\t\t\t\tvalues[data.name] = [data.value]\n\n\texcept Exception as e:\n\t\tOperationalError(source=\"getAPData\", error=str(e)).save()\n\t\traise e\n\n\treturn result","def get_patient_average():\n r = requests.get(\"http://vcm-7474.vm.duke.edu:5000/api/heart_rate/average/2\")\n print(r.text)","def measurements_lookup(client, database):\n client.switch_database(database)\n mlist_dict = client.get_list_measurements()\n # print(\"def measurements_lookup 010:\", mlist_dict[:10])\n return mlist_dict","def get_meter_info(apt_no):\n if apt_no in ['102A', 102]:\n apt_no = '102A'\n payload = (\"select uuid, Metadata/Instrument/SupplyType \"\n \"where Metadata/LoadLocation/FlatNumber ='\" + str(apt_no) + \"' and \"\n \"Metadata/Extra/PhysicalParameter='Power'\")\n\n r = requests.post(url, data=payload)\n # logger.debug (\"%s\",r)\n payload_body = r.json()\n # logger.debug (\"Payload:\\n%s\", payload_body)\n\n meters = []\n for i in range(0, len(payload_body)):\n meter = payload_body[i]\n\n meters.append({'uuid': meter['uuid'], 'type': meter[\n 'Metadata']['Instrument']['SupplyType']})\n\n return meters","def _get_data(self):\n devices = []\n try:\n if not self.router_client.login():\n self.hass.states.set(f\"{DOMAIN}.statusmsg\", self.router_client.statusmsg)\n _LOGGER.warning(\"Login failed: {0}:{1}@{2}\".format(self.router_client.username, self.router_client.password,self.router_client.host))\n self.router_client.logout()\n return devices\n\n devices_json = self.router_client.get_devices_response()\n finally:\n self.router_client.logout()\n\n self.hass.states.set(f\"{DOMAIN}.scanning\", devices_json != False)\n\n if devices_json != False:\n for device in devices_json:\n # _LOGGER.debug(\"Device: {0}\".format(device))\n dev = Device(\n device['HostName'].replace('未知设备', 'Unknown'),\n device['IPAddress'],\n device['MACAddress'],\n device['Active'],\n ICONS.get(device['IconType'])\n )\n # _LOGGER.debug(\"Device: {0}\".format(dev))\n devices.append(dev)\n return devices\n else:\n return []","def get_inventory(self, context):\n # See below some example code demonstrating how to return the resource structure\n # and attributes. In real life, of course, if the actual values are not static,\n # this code would be preceded by some SNMP/other calls to get the actual resource information\n '''\n # Add sub resources details\n sub_resources = [ AutoLoadResource(model ='Generic Chassis',name= 'Chassis 1', relative_address='1'),\n AutoLoadResource(model='Generic Module',name= 'Module 1',relative_address= '1/1'),\n AutoLoadResource(model='Generic Port',name= 'Port 1', relative_address='1/1/1'),\n AutoLoadResource(model='Generic Port', name='Port 2', relative_address='1/1/2'),\n AutoLoadResource(model='Generic Power Port', name='Power Port', relative_address='1/PP1')]\n\n\n attributes = [ AutoLoadAttribute(relative_address='', attribute_name='Location', attribute_value='Santa Clara Lab'),\n AutoLoadAttribute('', 'Model', 'Catalyst 3850'),\n AutoLoadAttribute('', 'Vendor', 'Cisco'),\n AutoLoadAttribute('1', 'Serial Number', 'JAE053002JD'),\n AutoLoadAttribute('1', 'Model', 'WS-X4232-GB-RJ'),\n AutoLoadAttribute('1/1', 'Model', 'WS-X4233-GB-EJ'),\n AutoLoadAttribute('1/1', 'Serial Number', 'RVE056702UD'),\n AutoLoadAttribute('1/1/1', 'MAC Address', 'fe80::e10c:f055:f7f1:bb7t16'),\n AutoLoadAttribute('1/1/1', 'IPv4 Address', '192.168.10.7'),\n AutoLoadAttribute('1/1/2', 'MAC Address', 'te67::e40c:g755:f55y:gh7w36'),\n AutoLoadAttribute('1/1/2', 'IPv4 Address', '192.168.10.9'),\n AutoLoadAttribute('1/PP1', 'Model', 'WS-X4232-GB-RJ'),\n AutoLoadAttribute('1/PP1', 'Port Description', 'Power'),\n AutoLoadAttribute('1/PP1', 'Serial Number', 'RVE056702UD')]\n\n return AutoLoadDetails(sub_resources,attributes)\n '''\n\n self._log(context, 'Begin autoload')\n resources = []\n attributes = []\n\n\n attributes.append(AutoLoadAttribute('', 'replication_address', self.get_replication_address(context)))\n attributes.append(AutoLoadAttribute('', 'connection_key', self.get_connection_key(context)))\n\n networks = self._get_newtork_interfaces(context)\n self._log(context, 'got networks')\n\n controllers = self._get_controllers(context)\n self._log(context, 'got controllers')\n ports = self._get_ports(context)\n\n model = None\n for controller in controllers:\n self._log(context, 'Processing ctrlt: ' + controller['name'] + ':' + controller['model'])\n resources.append(AutoLoadResource(model='Generic Storage Controller', name=controller['name'],\n relative_address=controller['name']))\n if model is None:\n model = controller['model']\n\n attributes.append(AutoLoadAttribute('', 'Model', model))\n\n for network in networks:\n self._log(context, 'Processing netwk: ' + network['name'] + ':' + str(network['address']))\n net_name = network['name']\n controller = net_name.split('.')[0]\n if 'vir0' in controller or 'vir1' in controller:\n attributes.append(AutoLoadAttribute('',str(controller + '_address'), str(network['address'])))\n continue\n if 'vir' in controller:\n continue\n if 'management' not in network['services']:\n continue\n resources.append(AutoLoadResource(model='Storage Network Port', name=net_name,\n relative_address=controller.upper() + '/' + str(network['address'])))\n\n for port in ports:\n if port['iqn'] is not None:\n port_name = port['name']\n controller = port_name.split('.')[0]\n resources.append(AutoLoadResource(model='iSCSI Storage Port', name=port['name'],\n relative_address=controller + '/' + port['portal']))\n attributes.append(AutoLoadAttribute(controller + '/' + port['portal'], 'iqn', port['iqn']))\n elif port['wwn'] is not None:\n port_name = port['name']\n controller = port_name.split('.')[0]\n resources.append(AutoLoadResource(model='FC Storage Port', name=port['name'],\n relative_address=controller + '/' + port['name'].split('.')[1]))\n attributes.append(AutoLoadAttribute(controller + '/' + port['name'].split('.')[1], 'wwn', port['wwn']))\n\n return AutoLoadDetails(resources, attributes)","def amtool_brief(self, mess, args):\n helper = AmtoolHelper(\n alertmanager_address=self.config['server_address'])\n result = helper.get_alerts()\n return result","def getData(language=None):","def main(self, name):\n\t\tapi_results = [] \n\t\tparams = self.get_search_parameters(name)\n\t\tapi_results.append(self.api_connect(params))\n\t\ttime.sleep(1.0)\n\t\tkey = api_results[0]['businesses'][0]\n\t\tbusiness_information = [key['name'], self.phone_number_organizer(key), key['rating'],\\\n\t\tkey['review_count']]\n\t\treturn business_information","def _get_network_utilization(self):\n options = self.scenario_cfg[\"options\"]\n interval = options.get('interval', 1)\n count = options.get('count', 1)\n\n cmd = \"sudo sar -n DEV %d %d\" % (interval, count)\n\n raw_result = self._execute_command(cmd)\n result = self._filtrate_result(raw_result)\n\n return result","def get_oauth_data():","def probe_api():\n\n info = loads(get(url).text)\n return info","def get():"],"string":"[\n \"async def __getDataFromApplianceUsage(self, account, lastBilledDate) -> dict:\\n _LOGGER.info(\\\"Getting appliance usage data\\\")\\n\\n JSON = {\\\"startDate\\\": str(lastBilledDate.strftime(\\\"%m%d%Y\\\"))}\\n data = {}\\n\\n try:\\n async with async_timeout.timeout(TIMEOUT):\\n response = await self.session.post(\\n URL_APPLIANCE_USAGE.format(account=account), json=JSON\\n )\\n if response.status == 200:\\n electric = (await response.json())[\\\"data\\\"][\\\"electric\\\"]\\n\\n full = 100\\n for e in electric:\\n rr = round(float(e[\\\"percentageDollar\\\"]))\\n if rr < full:\\n full = full - rr\\n else:\\n rr = full\\n data[e[\\\"category\\\"].replace(\\\" \\\", \\\"_\\\")] = rr\\n except Exception as e:\\n _LOGGER.error(e)\\n\\n return {\\\"energy_percent_by_applicance\\\": data}\",\n \"def getUsageInfo(self):\\n return self.jsonRequest(\\\"/api/v1/usage\\\", { \\\"apiKey\\\": self._apiKey })\",\n \"def get_application_api_usage_get(self, applicationId, end, start):\\n # TODO: Assuming first server is good - need to make fallback logic\\n return self.session.get_any(\\\"{base}{request_url}\\\".format(base=self.servers[0],\\n request_url=F\\\"/App/ApiUsage/{applicationId}/\\\"))\",\n \"def get_usage_data(username, password):\\n usage_req = XfinityUsage(username, password, browser_name=\\\"firefox-headless\\\")\\n return usage_req.run()\",\n \"def test_getusage(self):\\n ret = {\\\"message\\\": \\\"No Random.org api key or api version found.\\\", \\\"res\\\": False}\\n self.assertDictEqual(random_org.getUsage(), ret)\\n\\n self.assertDictEqual(\\n random_org.getUsage(api_key=\\\"peW\\\", api_version=\\\"1\\\"),\\n {\\n \\\"bitsLeft\\\": None,\\n \\\"requestsLeft\\\": None,\\n \\\"res\\\": True,\\n \\\"totalBits\\\": None,\\n \\\"totalRequests\\\": None,\\n },\\n )\",\n \"def retr_devices_by_app( app ) :\\n\\n\\t\\t\\t_logger.info( '...retr_devices_by_app...' )\\n\\t\\t\\toutput = []\\n\\t\\t\\ttry :\\n\\t\\t\\t\\tdb = mongo.db.auth_devices\\n\\t\\t\\t\\tfor device in db.find( { 'app_tags' : app } ) :\\n\\t\\t\\t\\t\\toutput.append({'moniker' : device['moniker'] ,\\n\\t\\t\\t\\t\\t\\t\\t\\t 'description' : device['description'] ,\\n\\t\\t\\t\\t\\t\\t\\t\\t 'active' : device['active'] ,\\n\\t\\t\\t\\t\\t\\t\\t\\t 'device_id' : device['device_id'] ,\\n\\t\\t\\t\\t\\t\\t\\t\\t 'enlisted' : device['enlisted'] ,\\n\\t\\t\\t\\t\\t\\t\\t\\t 'last_kown_remote_ip' : device['last_known_remote_ip'] ,\\n\\t\\t\\t\\t\\t\\t\\t\\t 'engaged' : device['engaged'] ,\\n\\t\\t\\t\\t\\t\\t\\t\\t 'canononical_user' : device['canonical_user'] ,\\n\\t\\t\\t\\t\\t\\t\\t\\t 'scope' : device['scope'] ,\\n\\t\\t\\t\\t\\t\\t\\t\\t 'segment' : device['segment']\\n\\t\\t\\t\\t\\t})\\n\\t\\t\\texcept Exception as e :\\n\\t\\t\\t\\t _logger.error( '...retr_devices_by_app %s' % e.message )\\n\\t\\t\\treturn jsonify({'result' : output})\",\n \"def get_data():\\n pass\",\n \"def get_info():\\n global PERF_APP\\n archs = None\\n best_arch = None\\n cipher_algos = None\\n hash_algos = None\\n aead_algos = None\\n\\n cmd = PERF_APP + ' --print-info'\\n\\n try:\\n res = subprocess.run(cmd, stdout=subprocess.PIPE, \\\\\\n stderr=subprocess.STDOUT, \\\\\\n env=ENVS, shell=True, check=True)\\n output = res.stdout.decode('utf-8')\\n except subprocess.CalledProcessError as e:\\n print(\\\"Error (\\\" + str(e.returncode) + \\\")\\\")\\n print(e.output.decode('utf-8'))\\n sys.exit(1)\\n\\n lines = output.rstrip().split('\\\\n')\\n try:\\n for line in lines:\\n info = line.split(':')\\n if info[0] == 'Supported architectures':\\n archs = info[1].split()\\n if info[0] == 'Best architecture':\\n best_arch = info[1].split()\\n if info[0] == 'Supported cipher algorithms':\\n cipher_algos = info[1].split()\\n if info[0] == 'Supported hash algorithms':\\n hash_algos = info[1].split()\\n if info[0] == 'Supported aead algorithms':\\n aead_algos = info[1].split()\\n except:\\n print(\\\"Error parsing --print-info output:\\\\n\\\" \\\\\\n \\\"{}\\\".format(output), file=sys.stderr)\\n\\n if archs is None or best_arch is None or cipher_algos is None \\\\\\n or hash_algos is None or aead_algos is None:\\n print(\\\"Error parsing system and app information\\\", file=sys.stderr)\\n sys.exit(1)\\n\\n return archs, best_arch, cipher_algos, hash_algos, aead_algos\",\n \"def usage(self, host):\",\n \"def getInfo():\",\n \"def print_app_data(self):\\n print(\\\"===================================\\\")\\n print(\\\"== RESULTS: ==\\\")\\n print(\\\"===================================\\\")\\n\\n # Analog application results\\n print(\\\"--------------------------\\\")\\n print(\\\"-- Analog applications --\\\")\\n print(\\\"--------------------------\\\")\\n print(\\\"Number of analog application processed: {}\\\".format(len(self.analog_apps)))\\n if (self.verbose):\\n for app in self.analog_apps:\\n print(\\\" Application data:\\\")\\n print(\\\" - - - - - - - - - - - - -\\\")\\n print(' - EPICS PREFIX: MPLN:{}:{}:{}'.format(app[\\\"link_node_area\\\"].upper(), app[\\\"link_node_location\\\"].upper(), app[\\\"card_index\\\"]))\\n print(\\\" - App ID : {}\\\".format(app[\\\"app_id\\\"]))\\n print(\\\" - Cpu name : {}\\\".format(app[\\\"cpu_name\\\"]))\\n print(\\\" - Crate ID : {}\\\".format(app[\\\"crate_id\\\"]))\\n print(\\\" - Slot number : {}\\\".format(app[\\\"slot_number\\\"]))\\n print(\\\" - Link node name : {}\\\".format(app[\\\"link_node_name\\\"]))\\n print(\\\" - Link node area : {}\\\".format(app[\\\"link_node_area\\\"]))\\n print(\\\" - Link node location : {}\\\".format(app[\\\"link_node_location\\\"]))\\n print(\\\" - Card index : {}\\\".format(app[\\\"card_index\\\"]))\\n print(\\\" - Number of devices : {}\\\".format(len(app[\\\"devices\\\"])))\\n for device in app[\\\"devices\\\"]:\\n print(\\\" Device data:\\\")\\n print(\\\" .....................\\\")\\n print(\\\" - EPICS PREFIX: {}:{}:{}\\\".format(device[\\\"type_name\\\"], device[\\\"area\\\"], device[\\\"position\\\"]))\\n print(\\\" - Type name : {}\\\".format(device[\\\"type_name\\\"]))\\n print(\\\" - Bay number : {}\\\".format(device[\\\"bay_number\\\"]))\\n print(\\\" - Channel number : {}\\\".format(device[\\\"channel_number\\\"]))\\n print(\\\" - Area : {}\\\".format(device[\\\"area\\\"]))\\n print(\\\" - Position : {}\\\".format(device[\\\"position\\\"]))\\n print(\\\" - Number of faults : {}\\\".format(len(device[\\\"faults\\\"])))\\n for fault_id,fault_data in device[\\\"faults\\\"].items():\\n print(\\\" Fault data:\\\")\\n print(\\\" . . . . . . . . . . . . \\\")\\n print(\\\" - EPICS PREFIX: {}_T{}\\\".format(fault_data[\\\"name\\\"], fault_data[\\\"bit_positions\\\"][0]))\\n print(\\\" - ID : {}\\\".format(fault_id))\\n print(\\\" - Name : {}\\\".format(fault_data[\\\"name\\\"]))\\n print(\\\" - Description : {}\\\".format(fault_data[\\\"description\\\"]))\\n print(\\\" - Bit positions : {}\\\".format(fault_data[\\\"bit_positions\\\"]))\\n print(\\\" . . . . . . . . . . . . \\\")\\n print(\\\" .....................\\\")\\n print(\\\" - - - - - - - - - - - - -\\\")\\n print(\\\"\\\")\\n print(\\\"--------------------------\\\")\\n\\n # Digital application result\\n print(\\\"----------------------------\\\")\\n print(\\\"-- Digital applications --\\\")\\n print(\\\"----------------------------\\\")\\n print(\\\"Number of digital application processed: {}\\\".format(len(self.digital_apps)))\\n if (self.verbose):\\n for app in self.digital_apps:\\n print(\\\" Application data:\\\")\\n print(\\\" - - - - - - - - - - - - -\\\")\\n print(' - EPICS PREFIX: MPLN:{}:{}:{}'.format(app[\\\"link_node_area\\\"].upper(), app[\\\"link_node_location\\\"].upper(), app[\\\"card_index\\\"]))\\n print(\\\" - App ID : {}\\\".format(app[\\\"app_id\\\"]))\\n print(\\\" - Cpu name : {}\\\".format(app[\\\"cpu_name\\\"]))\\n print(\\\" - Crate ID : {}\\\".format(app[\\\"crate_id\\\"]))\\n print(\\\" - Slot number : {}\\\".format(app[\\\"slot_number\\\"]))\\n print(\\\" - Link node name : {}\\\".format(app[\\\"link_node_name\\\"]))\\n print(\\\" - Link node area : {}\\\".format(app[\\\"link_node_area\\\"]))\\n print(\\\" - Link node location : {}\\\".format(app[\\\"link_node_location\\\"]))\\n print(\\\" - Card index : {}\\\".format(app[\\\"card_index\\\"]))\\n print(\\\" - Number of devices : {}\\\".format(len(app[\\\"devices\\\"])))\\n for device in app[\\\"devices\\\"]:\\n print(\\\" Device data:\\\")\\n print(\\\" .....................\\\")\\n print(\\\" - EPICS PREFIX: {}:{}:{}\\\".format(device[\\\"type_name\\\"], device[\\\"area\\\"], device[\\\"position\\\"]))\\n print(\\\" - Type name : {}\\\".format(device[\\\"type_name\\\"]))\\n print(\\\" - Area : {}\\\".format(device[\\\"area\\\"]))\\n print(\\\" - Position : {}\\\".format(device[\\\"position\\\"]))\\n print(\\\" - Number of inputs : {}\\\".format(len(device[\\\"inputs\\\"])))\\n for input in device[\\\"inputs\\\"]:\\n print(\\\" Input data:\\\")\\n print(\\\" . . . . . . . . . . . . \\\")\\n print(\\\" - EPICS PREFIX: {}\\\".format(input[\\\"name\\\"]))\\n print(\\\" - Name : {}\\\".format(input[\\\"name\\\"]))\\n print(\\\" - Bit position : {}\\\".format(input[\\\"bit_position\\\"]))\\n print(\\\" - Zero name : {}\\\".format(input[\\\"zero_name\\\"]))\\n print(\\\" - One name : {}\\\".format(input[\\\"one_name\\\"]))\\n print(\\\" - Alarm state : {}\\\".format(input[\\\"alarm_state\\\"]))\\n print(\\\" - Debounce : {}\\\".format(input[\\\"debounce\\\"]))\\n print(\\\" . . . . . . . . . . . . \\\")\\n print(\\\" .....................\\\")\\n print(\\\" - - - - - - - - - - - - -\\\")\\n print(\\\"\\\")\\n print(\\\"----------------------------\\\")\\n\\n\\n print(\\\"===================================\\\")\\n\\n print('Found {} link nodes:'.format(len(self.link_nodes)))\\n for k,v in self.link_nodes.items():\\n print('{}: {}'.format(k, v['type']))\",\n \"def get_apk(self):\",\n \"def get_discovery_summary():\\n pass\",\n \"def usage_information(self):\\n return self._usage_information\",\n \"def gather_metric(self):\\n result = self._shell.run(self.ADB_COMMAND)\\n stdout = result.stdout.splitlines()\\n adb_version = stdout[0].split()[-1]\\n # Revision information will always be in next line\\n adb_revision = stdout[1].split()[1]\\n\\n response = {\\n self.ADB_VERSION: adb_version,\\n self.ADB_REVISION: adb_revision\\n }\\n return response\",\n \"def device_overview(self):\\r\\n data = {}\\r\\n\\r\\n # GET DATA\\r\\n token = request.headers.get('token')\\r\\n userid = request.headers.get('userid')\\r\\n vessel_id = request.args.get('vessel_id')\\r\\n epoch_format = request.args.get('format')\\r\\n\\r\\n # CHECK TOKEN\\r\\n if not self.validate_token(token, userid):\\r\\n data['alert'] = \\\"Invalid Token\\\"\\r\\n data['status'] = 'Failed'\\r\\n return self.return_data(data)\\r\\n\\r\\n alarm_types = self.get_alarm_types()\\r\\n\\r\\n ats = self.get_alarm_trigger()\\r\\n\\r\\n devices = self.couch_query.get_all_devices(vessel_id)\\r\\n\\r\\n standard_time = self.epoch_day(time.time())\\r\\n\\r\\n epoch_time = time.time()\\r\\n\\r\\n temp_data = []\\r\\n\\r\\n start_date = self.get_start_date(epoch_format)\\r\\n\\r\\n if not start_date and epoch_format not in [\\\"day\\\", \\\"hours\\\"]:\\r\\n\\r\\n data['alert'] = \\\"Invalid format!\\\"\\r\\n data['status'] = 'Failed'\\r\\n\\r\\n return self.return_data(data)\\r\\n\\r\\n for device in devices:\\r\\n\\r\\n if device['doc']['device'] in ['PARAMETERS', 'NTWCONF', 'NTWPERF1']:\\r\\n\\r\\n continue\\r\\n\\r\\n row = {}\\r\\n row['device'] = device['doc']['device']\\r\\n row['name'] = device['doc']['device']\\r\\n row['Alert'] = 0\\r\\n row['Critical'] = 0\\r\\n row['Warning'] = 0\\r\\n row['Info'] = 0\\r\\n row['Debug'] = 0\\r\\n for atrigger in ats:\\r\\n\\r\\n trigger_type = self.get_alarm_type_name(alarm_types, atrigger['alarm_type_id'])\\r\\n\\r\\n at_id = atrigger['alarm_trigger_id']\\r\\n device_id = device['id']\\r\\n\\r\\n datas = self.calc.calculate_trigger([at_id], standard_time,\\r\\n epoch_time, vessel_id=vessel_id,\\r\\n device_id=device_id)\\r\\n\\r\\n if not datas == \\\"No Alarm Trigger found.\\\":\\r\\n\\r\\n datas_index_0 = datas[0]\\r\\n len_datas = datas_index_0['results']\\r\\n if len_datas:\\r\\n\\r\\n row[trigger_type] = 1\\r\\n\\r\\n if epoch_format in ['week', 'month', \\\"quarter\\\", 'annual']:\\r\\n\\r\\n sql_str = \\\"SELECT COUNT(alarm_trigger_id) FROM alarm_data \\\"\\r\\n sql_str += \\\"WHERE device_id='{0}' \\\".format(device_id)\\r\\n sql_str += \\\"AND epoch_date > {0} \\\".format(start_date)\\r\\n sql_str += \\\"AND epoch_date < {0}\\\".format(epoch_time)\\r\\n\\r\\n res = self.postgres.query_fetch_one(sql_str)\\r\\n\\r\\n row[trigger_type] = row[trigger_type] + res['count']\\r\\n\\r\\n temp_data.append(row)\\r\\n\\r\\n final_data = {}\\r\\n final_data['data'] = temp_data\\r\\n final_data['status'] = 'ok'\\r\\n\\r\\n return self.return_data(final_data)\",\n \"def get_devices_summary():\\n\\n # This function was created to replace get_devices_information\\n # because it wasn't detecting virtual systems in Palo Alto Virtual Systems\\n global nipper_xml\\n devices = {}\\n headings = []\\n\\n # Add the table headings to a list\\n for h in nipper_xml.findall(\\\"./summary/table/[@ref='SCOPE.AUDITDEVICELIST.TABLE']/headings/heading\\\"):\\n if h not in headings:\\n headings.append(h.text)\\n\\n for device in nipper_xml.findall(\\\"./summary/table/[@ref='SCOPE.AUDITDEVICELIST.TABLE']/tablebody/tablerow\\\"):\\n values = []\\n for i in device.findall('./tablecell/item'):\\n if i not in values:\\n values.append(i.text)\\n if DEBUG:\\n print \\\"\\\\t\\\" + note + \\\"%s: %s\\\" % (headings[headings.index('Name')], values[headings.index('Name')])\\n print \\\"\\\\t\\\" + note + \\\"%s: %s\\\" % (headings[headings.index('Device')], values[headings.index('Device')])\\n print \\\"\\\\t\\\" + note + \\\"%s: %s\\\" % (headings[headings.index('OS')], values[headings.index('OS')].split(\\\" \\\")[0])\\n print \\\"\\\\t\\\" + note + \\\"%s: %s\\\" % (headings[headings.index('OS')], values[headings.index('OS')].split(\\\" \\\")[1])\\n devices[values[headings.index('Name')]] = {'name': values[headings.index('Name')],\\n 'type': values[headings.index('Device')],\\n 'os': values[headings.index('OS')].split(' ')[0],\\n 'osversion': values[headings.index('OS')].split(' ')[1]\\n }\\n\\n if DEBUG:\\n print info + \\\"Device Object:\\\"\\n print devices\\n raw_input(warn + \\\"Press enter to continue\\\")\\n return devices\",\n \"def getEnergyUsage():\\n energy_data = asyncio.run(plug.get_emeter_realtime())\\n\\n return energy_data\",\n \"def get_data():\\n return\",\n \"def data_setup_appliances():\\n appliance_list = []\\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_BASIC, \\\"appliance1\\\", gpio_pin_id=None))\\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_BASIC, \\\"appliance2\\\", gpio_pin_id=None))\\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_BASIC, \\\"appliance3\\\", gpio_pin_id=None))\\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_BASIC, \\\"appliance4\\\", gpio_pin_id=None))\\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_BASIC, \\\"appliance5\\\", gpio_pin_id=None))\\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_RELAY, \\\"gpio_appliance1\\\", gpio_pin_id=13))\\n appliance_list.append(helper_setup_appliances(APPLIANCE_TYPE_NAME_RELAY, \\\"gpio_appliance2\\\", gpio_pin_id=15))\\n return appliance_list\",\n \"def get_data(self):\",\n \"def _get_data(self):\\n c = Connector(self.host, self.username, self.password)\\n return c.getLanDevices()\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def user_sends_get_call_to_the_devices():\\n web_app.list_devices()\",\n \"def info_equipment_get():\\n equipment = _equipment_by_group()\\n return equipment, 200\",\n \"def get(self):\\n try:\\n log.debug(\\\"Device info : \\\")\\n #get the payload to influx DB\\n url = \\\"http://localhost:8086/query\\\"\\n querystring = {\\\"pretty\\\": \\\"true\\\", \\\"db\\\": \\\"IOT\\\",\\n \\\"q\\\":\\\"SELECT DISTINCT(deviceId) FROM(SELECT deviceId,q1 FROM \\\\\\\"ttd_devices\\\\\\\" ) \\\" }\\n response = requests.request(\\\"GET\\\", url, params=querystring)\\n r_d=json.loads(response.text)\\n result_d=[]\\n for rec in r_d['results'][0]['series']:\\n for element in rec['values']:\\n result_d.append(element[1])\\n result={}\\n result['status'] = 1\\n result['message']=result_d\\n return_status = 200\\n except ValueError as e:\\n result = {}\\n log.exception('Value Exception while fetching device list')\\n result['status'] = 0\\n return_status = 400\\n result['message'] = e.args[0]\\n except :\\n result = {}\\n log.exception('Exception while fetching the device data')\\n return_status = 500\\n result['status'] = 0\\n result['message'] = 'Internal Error has occurred while fetching devie data'\\n finally:\\n resp = Response(json.dumps(result), status=return_status, mimetype=\\\"application/json\\\")\\n return resp\",\n \"def retrieve_dial_data(app_name):\\n # NOTE: the reference code store the file in the application folder, we read the file in our data folder\\n # perhaps other changes will be needed to allow USE_ADDITIONAL_DATA feature to work\\n file_path = 'dial_data/' + app_name + '.json'\\n if not fileops.file_exists(file_path):\\n return {}\\n data = fileops.load_file_def(file_path)\\n return json.loads(data)\",\n \"def show(ctx, appeui):\\n if '.' in appeui:\\n appeui = str(hexStringInt(str(appeui)))\\n \\n # Form the url and payload\\n server = ctx.obj['server']\\n payload = {'token': ctx.obj['token']}\\n url = 'http://{}/api/v{}'.format(server, str(version))\\n url += '/apps' if appeui == 'all' else '/app/{}'.format(appeui)\\n \\n # Make the request\\n data = restRequest(server, url, 'get', payload, 200)\\n if data is None:\\n return\\n \\n # Single application\\n if appeui != 'all':\\n a = data\\n indent = ' ' * 10\\n if a['appinterface_id'] == 0:\\n a['appinterface_id'] = '-'\\n if a['domain'] is None:\\n a['domain'] = '-'\\n click.echo('Application EUI: ' + euiString(a['appeui']))\\n click.echo('{}name: {}'.format(indent, a['name']))\\n click.echo('{}domain: {}'.format(indent, a['domain']))\\n click.echo('{}fport: {}'.format(indent, a['fport']))\\n click.echo('{}interface: {}'.format(indent, a['appinterface_id']))\\n if a['appinterface_id'] != '-':\\n click.echo('{}Properties:'.format(indent))\\n properties = sorted(a['properties'].values(), key=lambda k: k['port'])\\n for p in properties:\\n click.echo('{} {} {}:{}'.format(indent, p['port'], p['name'], p['type']))\\n return\\n \\n # All applications\\n click.echo('{:14}'.format('Application') + \\\\\\n '{:24}'.format('AppEUI') + \\\\\\n '{:15}'.format('Domain') + \\\\\\n '{:6}'.format('Fport') + \\\\\\n '{:10}'.format('Interface'))\\n for i,a in data.iteritems():\\n if a['appinterface_id'] == 0:\\n a['appinterface_id'] = '-'\\n if a['domain'] is None:\\n a['domain'] = '-'\\n click.echo('{:13.13}'.format(a['name']) + ' ' + \\\\\\n '{:23}'.format(euiString(a['appeui'])) + ' ' + \\\\\\n '{:14.14}'.format(a['domain']) + ' ' + \\\\\\n '{:5.5}'.format(str(a['fport'])) + ' ' + \\\\\\n '{:10}'.format(str(a['appinterface_id'])))\",\n \"def get_usage_data(self):\\n with self._lock:\\n data_copy = self._data.copy()\\n return data_copy\",\n \"def get_listing_information():\\n\\n #getting the guidebox_id variable from show_page.html\\n guidebox_id = request.args.get(\\\"guidebox_id\\\")\\n\\n #get the show from the database\\n show = Show.find_show_with_guidebox_id(guidebox_id)\\n\\n #get show title from Guidebox so it can be used in the OnConnect title search url \\n show_title = str(show.title)\\n\\n #get OnConnect seriesId\\n series_id = onconnect_search_series_id(show_title)\\n\\n #obtaining listing information for a 24 hour period from the current time\\n airings = onconnect_search_airings(series_id)\\n\\n return jsonify(airings)\",\n \"def available(self, app):\\n return self.xlist(\\\"testfor\\\", app)[0]\",\n \"def GetData(self):\\r\\n if self.Error == False:\\r\\n Extra = {}\\r\\n try:\\r\\n result = {}\\r\\n temp = self.ScrapeMainWebpage()\\r\\n if temp != None:\\r\\n result.update(temp)\\r\\n temp = self.ScrapeParameters1Webpage()\\r\\n if temp != None:\\r\\n result.update(temp)\\r\\n temp = self.ScrapeParameters2Webpage()\\r\\n if temp != None:\\r\\n result.update(temp)\\r\\n temp = self.ScrapeStatusWebpage()\\r\\n if temp != None:\\r\\n result.update(temp)\\r\\n sqlArray = {}\\r\\n sqlArray[self.deviceDescr] = {}\\r\\n sqlArray[self.deviceDescr][self.devNumber] = {}\\r\\n sqlArray[self.deviceDescr][self.devNumber][\\\"General\\\"] = result\\r\\n sqlArray[self.deviceDescr][self.devNumber][\\\"_ExtractInfo\\\"] = {}\\r\\n sqlArray[self.deviceDescr][self.devNumber][\\\"_ExtractInfo\\\"][\\\"ExtractTime\\\"] = time.time()\\r\\n sqlArray[\\\"ReadError\\\"] = False \\r\\n return sqlArray\\r\\n \\r\\n except Exception as e: \\r\\n self.log.printError(\\\"ERROR in Retreiving Seatel VSAT Data,%s Module Error\\\" % sys._getframe().f_code.co_name) \\r\\n self.log.printError( str(e))\\r\\n self.Error = True\\r\\n Extra[\\\"ReadError\\\"] = True\\r\\n return Extra\\r\\n else:\\r\\n self.log.printWarning(\\\"%s skipped due to previous failure\\\" % sys._getframe().f_code.co_name)\\r\\n return None\",\n \"def __get_data_from_store(term):\\n url_search = PLAY_STORE_URL + \\\"/search\\\"\\n response = requests.get(url_search, {'c': 'apps', 'q': term})\\n soup = BeautifulSoup(response.content, \\\"html.parser\\\")\\n apps = soup.find_all(\\\"div\\\", {\\\"class\\\": \\\"card no-rationale square-cover apps small\\\"})\\n\\n result = []\\n print(result)\\n for i, app in enumerate(apps):\\n app_details_basic = app.find(\\\"div\\\", {\\\"class\\\": \\\"details\\\"})\\n app_id = app['data-docid']\\n app_data = {\\n 'uid': app_id,\\n 'name': app_details_basic.find(\\\"a\\\", {\\\"class\\\": \\\"title\\\"})['title'].strip().encode('utf-8'),\\n 'dev_name': app_details_basic.find(\\\"a\\\", {\\\"class\\\": \\\"subtitle\\\"})['title'].strip(),\\n 'icon_url': \\\"http://\\\" + app.find(\\n \\\"div\\\", {\\\"class\\\": \\\"cover-inner-align\\\"}).img['data-cover-large'].strip(\\\"//\\\")\\n }\\n\\n url_app_detail = PLAY_STORE_URL + \\\"/apps/details\\\"\\n response = requests.get(url_app_detail, {'id': app_id})\\n soup = BeautifulSoup(response.content, \\\"html.parser\\\")\\n\\n app_data.update({\\n 'category': soup.find(\\\"a\\\", {\\\"itemprop\\\": \\\"genre\\\"}).text,\\n 'description': soup.find(\\\"div\\\", {\\\"itemprop\\\": \\\"description\\\"}).text.strip().encode('utf-8'),\\n \\n })\\n\\n \\n dev_links = soup.find_all(\\\"a\\\", {\\\"class\\\": \\\"dev-link\\\", \\\"rel\\\": \\\"nofollow\\\"})\\n if dev_links:\\n for dev_link in dev_links:\\n if \\\"mailto\\\" in dev_link['href']:\\n app_data['dev_email'] = dev_link['href'].replace(\\\"mailto:\\\", \\\"\\\")\\n break\\n\\n result.append(app_data)\\n\\n if i + 1 == SEARCH_RESULT_COUNT:\\n break\\n print(result)\\n return result\",\n \"def get_usage(self):\\r\\n return self.box_usage\",\n \"async def get_device_data(self):\\n pass\",\n \"def getatt(self):\\n err = True\\n retry = 0\\n while err and retry<2:\\n try:\\n r = requests.get(self.url+'ATT?\\\\n')\\n res = float(r.text)\\n err = False\\n except:\\n err = True\\n time.sleep(1)\\n retry += 1\\n res = nan\\n return res\",\n \"def get_data(self):\\n pass\",\n \"def get_data(self):\\n pass\",\n \"def application_list(p_engine, p_username, format, appname):\\n\\n ret = 0\\n\\n enginelist = get_list_of_engines(p_engine, p_username)\\n\\n if enginelist is None:\\n return 1\\n\\n data = DataFormatter()\\n data_header = [\\n (\\\"Engine name\\\", 30),\\n (\\\"Application name\\\", 30),\\n ]\\n data.create_header(data_header)\\n data.format_type = format\\n for engine_tuple in enginelist:\\n engine_obj = DxMaskingEngine(engine_tuple)\\n if engine_obj.get_session():\\n continue\\n applist = DxApplicationList()\\n # load all objects\\n applist.LoadApplications()\\n\\n if appname is None:\\n applications = applist.get_allref()\\n else:\\n applications = applist.get_applicationId_by_name(appname)\\n if len(applications) == 0:\\n ret = ret + 1\\n\\n for appref in applications:\\n appobj = applist.get_by_ref(appref)\\n data.data_insert(\\n engine_tuple[0],\\n appobj.application_name\\n )\\n\\n print(\\\"\\\")\\n print (data.data_output(False))\\n print(\\\"\\\")\\n \\n \\n return ret\",\n \"def get_usage(self, start=None, end=None):\\n return self.manager.get_usage(self, start=start, end=end)\",\n \"def _get_dapall_from_api(self):\\n\\n url = marvin.config.urlmap['api']['dapall']['url']\\n\\n url_full = url.format(name=self.plateifu,\\n bintype=self.bintype.name,\\n template=self.template.name)\\n\\n try:\\n response = self._toolInteraction(url_full)\\n except Exception as ee:\\n raise MarvinError('found a problem while getting DAPall: {0}'.format(str(ee)))\\n\\n if response.results['error'] is not None:\\n raise MarvinError('found a problem while getting DAPall: {}'\\n .format(str(response.results['error'])))\\n\\n data = response.getData()\\n\\n return data['dapall_data']\",\n \"def usage():\\n return _usage\",\n \"def summary(app):\\n click.echo(get_summary(app))\",\n \"def test_duo_application_get(self):\\n pass\",\n \"def get_data(self):\\r\\n pass\",\n \"def usage(where=sys.stdout):\\n print('Gather Holding IDs via REST using a list of MMS IDs.',\\n file=where) \\n print('Usage:', file=where)\\n print(' west2_gather_Holding_IDs.py <file.txt> <APIKEY>', file=where)\\n print('Where:', file=where)\\n print(' file.txt List of MSS IDs (one / line)',\\n file=where)\\n print(' APIKEY API key for accessing Alma REST APIs',\\n file=where)\\n print('Output:', file=where)\\n print(' Generates a datestamped text file: holding-and-mss-ids.<date>.txt',\\n file=where)\\n print(' consisting of lines holding_id<tab>mms_id', file=where)\",\n \"def get_usages(self):\\n return self.client._perform_json(\\\"GET\\\", \\\"/projects/%s/managedfolders/%s/usages\\\" % (self.project_key, self.odb_id))\",\n \"def get_usage(self):\\n return self.box_usage\",\n \"def get_appliances(self):\\n if self.appliances is not None:\\n return self.appliances\\n self.appliances = Appliance.objects.filter(user=self.request.user)\\n return self.appliances\",\n \"def usage():\\r\\n print 'Usage: collect_logs.py testrun \\\"env1, env2,...\\\" \\\"oscounters, applogs, gclogs, traces\\\"'\\r\\n print \\\"testrun = Name of the test execution e.g. 12032713\\\"\\r\\n print \\\"environments = Name of the environment defined in the environments.ini file\\\"\\r\\n print \\\"logtypes = List types of logfiles to collect\\\"\",\n \"def AcquiredData (self) :\\n\\t\\treturn self.run(\\\"AcquiredData\\\")\",\n \"def get(category, page=1, per_page=5):\\r\\n\\r\\n count = n_count(category)\\r\\n\\r\\n sql = text('''SELECT app.id, app.name, app.short_name, app.description,\\r\\n app.info, app.created, app.category_id, \\\"user\\\".fullname AS owner,\\r\\n featured.app_id as featured\\r\\n FROM \\\"user\\\", task, app\\r\\n LEFT OUTER JOIN category ON app.category_id=category.id\\r\\n LEFT OUTER JOIN featured ON app.id=featured.app_id\\r\\n WHERE\\r\\n category.short_name=:category\\r\\n AND app.hidden=0\\r\\n AND \\\"user\\\".id=app.owner_id\\r\\n AND app.info LIKE('%task_presenter%')\\r\\n AND task.app_id=app.id\\r\\n GROUP BY app.id, \\\"user\\\".id, featured.app_id ORDER BY app.name\\r\\n OFFSET :offset\\r\\n LIMIT :limit;''')\\r\\n\\r\\n offset = (page - 1) * per_page\\r\\n results = db.engine.execute(sql, category=category, limit=per_page, offset=offset)\\r\\n apps = []\\r\\n for row in results:\\r\\n app = dict(id=row.id,\\r\\n name=row.name, short_name=row.short_name,\\r\\n created=row.created,\\r\\n description=row.description,\\r\\n owner=row.owner,\\r\\n featured=row.featured,\\r\\n last_activity=pretty_date(last_activity(row.id)),\\r\\n last_activity_raw=last_activity(row.id),\\r\\n overall_progress=overall_progress(row.id),\\r\\n info=dict(json.loads(row.info)))\\r\\n apps.append(app)\\r\\n return apps, count\",\n \"def extract_programs():\\n if settings.XPRO_CATALOG_API_URL:\\n return requests.get(settings.XPRO_CATALOG_API_URL, timeout=20).json()\\n return []\",\n \"def getStockData():\\n pass\",\n \"def data():\\n return volumes_fetchers.get_json_data()\",\n \"def get_antivirus_info():\\n query = {\\n \\\"type\\\": \\\"op\\\",\\n \\\"cmd\\\": \\\"<request><anti-virus><upgrade><info></info></upgrade></anti-virus></request>\\\",\\n }\\n\\n return __proxy__[\\\"panos.call\\\"](query)\",\n \"def test_mock_datasource_usages(self):\\n account1 = self.test_data.accounts[0]\\n meter = account1.meters[0]\\n usage = meter.usages[0]\\n self.assertIsInstance(usage, Usage)\\n self.assertEqual(usage.PK, 6)\\n self.assertEqual(usage.UsageActualName, \\\"test_usage\\\")\\n self.assertEqual(usage.UsageAmount, Decimal(50.0))\\n self.assertEqual(usage.RateComponent, \\\"test_rate_component\\\")\\n self.assertEqual(usage.EnergyUnit, \\\"test_energy_unit\\\")\\n self.assertEqual(usage.IntervalStart, date(2016, 1, 1))\\n self.assertEqual(usage.IntervalEnd, date(2016, 2, 1))\",\n \"def get_data_qos(args):\\n diff_data(args, \\\"qos\\\")\",\n \"def getAppInfo(self):\\n data = self._client.Application.find(self.app_id)\\n return data\",\n \"def get_device_info(target_project_arn):\\n try:\\n device_info = device_farm.list_devices(\\n arn=target_project_arn,\\n filters=[\\n {\\n \\\"attribute\\\": \\\"PLATFORM\\\",\\n \\\"operator\\\": \\\"EQUALS\\\",\\n \\\"values\\\": ['ANDROID', ]\\n },\\n {\\n \\\"attribute\\\": \\\"OS_VERSION\\\",\\n \\\"operator\\\": \\\"GREATER_THAN_OR_EQUALS\\\",\\n \\\"values\\\": ['9', ]\\n },\\n {\\n \\\"attribute\\\": \\\"MANUFACTURER\\\",\\n \\\"operator\\\": \\\"EQUALS\\\",\\n \\\"values\\\": ['Google', ]\\n },\\n {\\n \\\"attribute\\\": \\\"AVAILABILITY\\\",\\n \\\"operator\\\": \\\"EQUALS\\\",\\n \\\"values\\\": ['HIGHLY_AVAILABLE', ]\\n },\\n {\\n \\\"attribute\\\": \\\"FLEET_TYPE\\\",\\n \\\"operator\\\": \\\"EQUALS\\\",\\n \\\"values\\\": ['PUBLIC', ]\\n }\\n ])['devices']\\n\\n if device_info is not None:\\n device_arn = device_info[0]['arn']\\n device_name = device_info[0]['name']\\n device_manufacture = device_info[0]['manufacturer']\\n device_model = device_info[0]['model']\\n device_model_id = device_info[0]['modelId']\\n device_type = device_info[0]['formFactor']\\n device_platform = device_info[0]['platform']\\n device_os = device_info[0]['os']\\n device_visibility = device_info[0]['fleetType']\\n device_availability = device_info[0]['availability']\\n\\n print('Device Name - {} with Manufacture {}, model {}, modelId {} & type {}'.format(\\n device_name,\\n device_manufacture,\\n device_model,\\n device_model_id,\\n device_type\\n )\\n )\\n print('Device Platform {} with OS {}, visibility {} & availability - {} '.format(\\n device_platform,\\n device_os,\\n device_visibility,\\n device_availability\\n )\\n )\\n\\n if device_availability == TARGET_AVAILABILITY:\\n print('AWS setup is complete')\\n else:\\n print('Problem, device is not available')\\n else:\\n print('Problem finding device info')\\n\\n except IndexError:\\n print('Problem finding device from pool {}'.format(device_info))\",\n \"def access():\",\n \"def stats(self):\\r\\n\\t\\tdata = self._get('global/', query=None)\\r\\n\\t\\treturn data\",\n \"def main():\\n results = []\\n results.extend(check_mounts())\\n results.extend(diskusage())\\n return results\",\n \"def get_app(self, app_name, ns_name):\\n\\n status, _ = self.helm_client.status(app_name, namespace=ns_name)\\n values, _ = self.helm_client.get_values(app_name, namespace=ns_name)\\n release_data = {\\\"status\\\": status, \\\"values\\\": values}\\n\\n schema_path = Path(\\\"%s/%s/values.schema.json\\\"\\n % (self._get_ns_dir(ns_name), app_name))\\n if schema_path.exists():\\n schema = json.loads(schema_path.read_text())\\n release_data[\\\"schema\\\"] = schema\\n\\n return release_data\",\n \"def query(self):\\n self._measurements[self.KEY_USAGE].df = self.fetch_data_usage()\",\n \"def diagnostics(self, oid):\\n path = '/servers/%s/diagnostics' % oid\\n res = self.client.call(path, 'GET', data='', token=self.manager.identity.token)\\n self.logger.debug('Shows basic usage data for server %s: %s' % \\n (oid, truncate(res)))\\n return res[0]\",\n \"def test_get_us_daily_data(self):\\n dag = self.dagbag.get_dag(self.dag_id)\\n extract_task = dag.get_task('extract')\\n resp = self.extract.getDailyUSDataFromAPI()\\n self.assertIsNotNone(resp)\\n self.assertEqual(type(resp), list)\",\n \"def getDeviceInfo():\\n url = \\\"https://api.roblox.com/reference/deviceinfo\\\"\\n r = requests.get(url)\\n j = json.loads(r.text)\\n return j\",\n \"def who():\\n cleanup()\\n return {'available': userlist(), 'eta': data['etas'], 'etd': data['etds'], 'lastlocation': data['lastlocation'], 'ceitloch': ceitloch(), 'reminder': data['reminder']}\",\n \"def get_app_info(self, name):\\n with hide(\\\"output\\\", \\\"running\\\"):\\n result = local(\\\"redis-cli -h {host} -p 6379 -n {db} hgetall {name}\\\".format(\\n host=self.host, name=name, db=REDIS_APPLICATION_DB_NUM), capture=True)\\n\\n if len(result.stdout) > 0:\\n splits = result.stdout.split(\\\"\\\\n\\\")\\n fmt_result = dict([(splits[i], splits[i+1])\\n for i in range(0, len(splits), 2)])\\n pp = pprint.PrettyPrinter(indent=2)\\n pp.pprint(fmt_result)\\n return fmt_result\\n else:\\n warn(\\\"Application \\\\\\\"%s\\\\\\\" not found\\\" % name)\\n return None\",\n \"def get_patient_status():\\n r = requests.get(\\\"http://vcm-7474.vm.duke.edu:5000/api/heart_rate/3\\\")\\n print(r.text)\",\n \"def usage(self):\\r\\n return usage.Usage(self)\",\n \"def get_info(self):\\n pass\",\n \"def get_info(self):\\n pass\",\n \"def getTheData(self, dev):\\n if self.debugLevel >= 2 and self.debug:\\n self.debugLog(u\\\"getTheData FrontViewAPI method called.\\\")\\n\\n # dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\\\"Download\\\")\\n try:\\n url = 'http://' + dev.pluginProps['sourceXML'] + '/FrontView'\\n r = requests.get(url,timeout=5)\\n result = r.json()\\n if self.debugLevel >= 2 and self.debug:\\n self.debugLog(u\\\"Result:\\\" + unicode(result))\\n self.WaitInterval = 1\\n dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\\\"Online\\\")\\n dev.setErrorStateOnServer(None)\\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\\n return result\\n\\n except Exception as error:\\n\\n indigo.server.log(u\\\"Error connecting to Device:\\\" + dev.name)\\n self.WaitInterval = 60\\n if self.debugLevel >= 2 and self.debug:\\n self.debugLog(u\\\"Device is offline. No data to return. \\\")\\n dev.updateStateOnServer('deviceIsOnline', value=False, uiValue=\\\"Offline\\\")\\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\\n dev.setErrorStateOnServer(u'Offline')\\n result = \\\"\\\"\\n return result\",\n \"def device_count():\\n apipath = \\\"/targets/devices\\\"\\n url = SERVER + apipath\\n params = {\\n 'q': '(deviceType:ASA)',\\n 'agg': 'count'}\\n headers = {\\n 'Accept': \\\"application/json\\\",\\n 'Content-Type': \\\"application/json\\\",\\n 'Authorization': \\\"bearer {}\\\".format(token)}\\n response = requests.get(url, verify=False, stream=True, headers=headers, params=params)\\n getstatuscode = response.status_code\\n getresponse = response.json()\\n if getstatuscode == 200:\\n return getresponse\\n else:\\n response.raise_for_status()\",\n \"def appdata(appname):\\n z = Zap(appname)\\n z.appdata(stdout=True)\",\n \"def test_retrieve_1_by_all(self):\\n swa = frontend.SupplyWinApi()\\n query_dict = dict(\\n dev=\\\"rrenaud\\\",\\n targets=\\\"Council Room\\\",\\n interaction=\\\"\\\",\\n unconditional=\\\"true\\\",\\n )\\n\\n card_stats = swa.retrieve_data(query_dict)\\n\\n self.assertEquals(len(card_stats), 1)\\n\\n self.assertEquals(card_stats[0]['card_name'], 'Council Room')\\n self.assertEquals(len(card_stats[0]['condition']), 0)\\n\\n json = swa.readable_json_card_stats(card_stats)\\n self.assertEquals(json[0:14], '[{\\\"card_name\\\":')\",\n \"def games_usage(parsed_args):\\n if parsed_args.verb == \\\"GET\\\":\\n filter_dict = {\\n \\\"game_type\\\": parsed_args.game_type,\\n \\\"genre\\\": parsed_args.genre,\\n \\\"keywords\\\": parsed_args.keywords,\\n \\\"mechanic\\\": parsed_args.mechanic\\n }\\n df = get_games(parsed_args.id, filter_dict)\\n if parsed_args.function == \\\"FILTERS\\\":\\n df = get_game_filters(df)\\n else:\\n df = post_games(df, parsed_args.sort_by, parsed_args.weighting)\\n return df\",\n \"def get_data(self, label):\\n self.application.get_data(label)\",\n \"def get_usage_stats(self) -> UsageStats:\\n return self._usage\",\n \"def get(cls, service, name=\\\"\\\", option_=\\\"\\\") :\\n\\t\\ttry :\\n\\t\\t\\tobj = audit_stats()\\n\\t\\t\\tif not name :\\n\\t\\t\\t\\tresponse = obj.stat_resources(service, option_)\\n\\t\\t\\treturn response\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise e\",\n \"def get(self, request, *args, **kwargs):\\n device = Device.objects.get(name=kwargs[\\\"device_name\\\"])\\n global_settings = GoldenConfigSettings.objects.get(id=\\\"aaaaaaaa-0000-0000-0000-000000000001\\\")\\n status_code, data = graph_ql_query(request, device, global_settings.sot_agg_query)\\n data = json.loads(json.dumps(data))\\n return Response(GraphQLSerializer(data=data).initial_data, status=status_code)\",\n \"def _get_values(self, app_name, chart_dir):\\n\\n raw, _ = self.helm_client.show_info(app_name, \\\"values\\\",\\n chart_dir=chart_dir)\\n return yaml.load(raw, yaml.SafeLoader)\",\n \"def healthcare():\",\n \"def getAPData(ap, timePerRange=3*settings.SNMPAPLAP, \\n\\tstartTime=None,\\n\\tendTime=None):\\n\\n\\tCOUNTERTOSPEED = ['ethernetRxTotalBytes','ethernetTxTotalBytes']\\n\\tGETMAX = []\\n\\t\\n\\tresult = []\\n\\ttry:\\n\\n\\t\\tif startTime == None:\\n\\t\\t\\tstartTime = APSnapshot.objects.aggregate(Min(\\\"date\\\"))[\\\"date__min\\\"]\\n\\t\\tif endTime == None:\\n\\t\\t\\tendTime = APSnapshot.objects.aggregate(Max(\\\"date\\\"))[\\\"date__max\\\"]\\n\\n\\n\\t\\tsnapshots = APSnapshot.objects.filter(ap=ap, date__gte=startTime, date__lte=endTime).order_by('date')\\n\\t\\tstartAt = snapshots[0].date\\n\\t\\t\\n\\t\\tvalues = {}\\n\\t\\tfor data in snapshots[0].apsnapshotdata_set.all():\\n\\t\\t\\tvalues[data.name] = [data.value]\\n\\n\\t\\tfor snap in snapshots[1:]:\\n\\t\\t\\t# Get the data of the period\\n\\t\\t\\tif snap.date < (startAt + timePerRange):\\n\\t\\t\\t\\tfor data in snap.apsnapshotdata_set.all():\\n\\t\\t\\t\\t\\tif data.name in values:\\n\\t\\t\\t\\t\\t\\tvalues[data.name].append(data.value)\\n\\n\\t\\t\\t# Aggregate and reset the period\\n\\t\\t\\telse:\\n\\t\\t\\t\\tdata = {}\\n\\t\\t\\t\\tfor attr, value in values.items():\\n\\t\\t\\t\\t\\tif attr in COUNTERTOSPEED:\\n\\t\\t\\t\\t\\t\\tdata[attr] = getSpeed(value[0], value[-1], timePerRange)\\n\\t\\t\\t\\t\\telif attr in GETMAX:\\n\\t\\t\\t\\t\\t\\tdata[attr] = max(value)\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tdata[attr] = sum(value)/float(len(value))\\n\\n\\t\\t\\t\\tresult.append({'date':timezone.localtime(startAt + timePerRange), 'data': data})\\n\\n\\t\\t\\t\\t# Start new period\\n\\t\\t\\t\\tstartAt = snap.date\\n\\t\\t\\t\\tvalues = {}\\n\\t\\t\\t\\tfor data in snap.apsnapshotdata_set.all():\\n\\t\\t\\t\\t\\tvalues[data.name] = [data.value]\\n\\n\\texcept Exception as e:\\n\\t\\tOperationalError(source=\\\"getAPData\\\", error=str(e)).save()\\n\\t\\traise e\\n\\n\\treturn result\",\n \"def get_patient_average():\\n r = requests.get(\\\"http://vcm-7474.vm.duke.edu:5000/api/heart_rate/average/2\\\")\\n print(r.text)\",\n \"def measurements_lookup(client, database):\\n client.switch_database(database)\\n mlist_dict = client.get_list_measurements()\\n # print(\\\"def measurements_lookup 010:\\\", mlist_dict[:10])\\n return mlist_dict\",\n \"def get_meter_info(apt_no):\\n if apt_no in ['102A', 102]:\\n apt_no = '102A'\\n payload = (\\\"select uuid, Metadata/Instrument/SupplyType \\\"\\n \\\"where Metadata/LoadLocation/FlatNumber ='\\\" + str(apt_no) + \\\"' and \\\"\\n \\\"Metadata/Extra/PhysicalParameter='Power'\\\")\\n\\n r = requests.post(url, data=payload)\\n # logger.debug (\\\"%s\\\",r)\\n payload_body = r.json()\\n # logger.debug (\\\"Payload:\\\\n%s\\\", payload_body)\\n\\n meters = []\\n for i in range(0, len(payload_body)):\\n meter = payload_body[i]\\n\\n meters.append({'uuid': meter['uuid'], 'type': meter[\\n 'Metadata']['Instrument']['SupplyType']})\\n\\n return meters\",\n \"def _get_data(self):\\n devices = []\\n try:\\n if not self.router_client.login():\\n self.hass.states.set(f\\\"{DOMAIN}.statusmsg\\\", self.router_client.statusmsg)\\n _LOGGER.warning(\\\"Login failed: {0}:{1}@{2}\\\".format(self.router_client.username, self.router_client.password,self.router_client.host))\\n self.router_client.logout()\\n return devices\\n\\n devices_json = self.router_client.get_devices_response()\\n finally:\\n self.router_client.logout()\\n\\n self.hass.states.set(f\\\"{DOMAIN}.scanning\\\", devices_json != False)\\n\\n if devices_json != False:\\n for device in devices_json:\\n # _LOGGER.debug(\\\"Device: {0}\\\".format(device))\\n dev = Device(\\n device['HostName'].replace('未知设备', 'Unknown'),\\n device['IPAddress'],\\n device['MACAddress'],\\n device['Active'],\\n ICONS.get(device['IconType'])\\n )\\n # _LOGGER.debug(\\\"Device: {0}\\\".format(dev))\\n devices.append(dev)\\n return devices\\n else:\\n return []\",\n \"def get_inventory(self, context):\\n # See below some example code demonstrating how to return the resource structure\\n # and attributes. In real life, of course, if the actual values are not static,\\n # this code would be preceded by some SNMP/other calls to get the actual resource information\\n '''\\n # Add sub resources details\\n sub_resources = [ AutoLoadResource(model ='Generic Chassis',name= 'Chassis 1', relative_address='1'),\\n AutoLoadResource(model='Generic Module',name= 'Module 1',relative_address= '1/1'),\\n AutoLoadResource(model='Generic Port',name= 'Port 1', relative_address='1/1/1'),\\n AutoLoadResource(model='Generic Port', name='Port 2', relative_address='1/1/2'),\\n AutoLoadResource(model='Generic Power Port', name='Power Port', relative_address='1/PP1')]\\n\\n\\n attributes = [ AutoLoadAttribute(relative_address='', attribute_name='Location', attribute_value='Santa Clara Lab'),\\n AutoLoadAttribute('', 'Model', 'Catalyst 3850'),\\n AutoLoadAttribute('', 'Vendor', 'Cisco'),\\n AutoLoadAttribute('1', 'Serial Number', 'JAE053002JD'),\\n AutoLoadAttribute('1', 'Model', 'WS-X4232-GB-RJ'),\\n AutoLoadAttribute('1/1', 'Model', 'WS-X4233-GB-EJ'),\\n AutoLoadAttribute('1/1', 'Serial Number', 'RVE056702UD'),\\n AutoLoadAttribute('1/1/1', 'MAC Address', 'fe80::e10c:f055:f7f1:bb7t16'),\\n AutoLoadAttribute('1/1/1', 'IPv4 Address', '192.168.10.7'),\\n AutoLoadAttribute('1/1/2', 'MAC Address', 'te67::e40c:g755:f55y:gh7w36'),\\n AutoLoadAttribute('1/1/2', 'IPv4 Address', '192.168.10.9'),\\n AutoLoadAttribute('1/PP1', 'Model', 'WS-X4232-GB-RJ'),\\n AutoLoadAttribute('1/PP1', 'Port Description', 'Power'),\\n AutoLoadAttribute('1/PP1', 'Serial Number', 'RVE056702UD')]\\n\\n return AutoLoadDetails(sub_resources,attributes)\\n '''\\n\\n self._log(context, 'Begin autoload')\\n resources = []\\n attributes = []\\n\\n\\n attributes.append(AutoLoadAttribute('', 'replication_address', self.get_replication_address(context)))\\n attributes.append(AutoLoadAttribute('', 'connection_key', self.get_connection_key(context)))\\n\\n networks = self._get_newtork_interfaces(context)\\n self._log(context, 'got networks')\\n\\n controllers = self._get_controllers(context)\\n self._log(context, 'got controllers')\\n ports = self._get_ports(context)\\n\\n model = None\\n for controller in controllers:\\n self._log(context, 'Processing ctrlt: ' + controller['name'] + ':' + controller['model'])\\n resources.append(AutoLoadResource(model='Generic Storage Controller', name=controller['name'],\\n relative_address=controller['name']))\\n if model is None:\\n model = controller['model']\\n\\n attributes.append(AutoLoadAttribute('', 'Model', model))\\n\\n for network in networks:\\n self._log(context, 'Processing netwk: ' + network['name'] + ':' + str(network['address']))\\n net_name = network['name']\\n controller = net_name.split('.')[0]\\n if 'vir0' in controller or 'vir1' in controller:\\n attributes.append(AutoLoadAttribute('',str(controller + '_address'), str(network['address'])))\\n continue\\n if 'vir' in controller:\\n continue\\n if 'management' not in network['services']:\\n continue\\n resources.append(AutoLoadResource(model='Storage Network Port', name=net_name,\\n relative_address=controller.upper() + '/' + str(network['address'])))\\n\\n for port in ports:\\n if port['iqn'] is not None:\\n port_name = port['name']\\n controller = port_name.split('.')[0]\\n resources.append(AutoLoadResource(model='iSCSI Storage Port', name=port['name'],\\n relative_address=controller + '/' + port['portal']))\\n attributes.append(AutoLoadAttribute(controller + '/' + port['portal'], 'iqn', port['iqn']))\\n elif port['wwn'] is not None:\\n port_name = port['name']\\n controller = port_name.split('.')[0]\\n resources.append(AutoLoadResource(model='FC Storage Port', name=port['name'],\\n relative_address=controller + '/' + port['name'].split('.')[1]))\\n attributes.append(AutoLoadAttribute(controller + '/' + port['name'].split('.')[1], 'wwn', port['wwn']))\\n\\n return AutoLoadDetails(resources, attributes)\",\n \"def amtool_brief(self, mess, args):\\n helper = AmtoolHelper(\\n alertmanager_address=self.config['server_address'])\\n result = helper.get_alerts()\\n return result\",\n \"def getData(language=None):\",\n \"def main(self, name):\\n\\t\\tapi_results = [] \\n\\t\\tparams = self.get_search_parameters(name)\\n\\t\\tapi_results.append(self.api_connect(params))\\n\\t\\ttime.sleep(1.0)\\n\\t\\tkey = api_results[0]['businesses'][0]\\n\\t\\tbusiness_information = [key['name'], self.phone_number_organizer(key), key['rating'],\\\\\\n\\t\\tkey['review_count']]\\n\\t\\treturn business_information\",\n \"def _get_network_utilization(self):\\n options = self.scenario_cfg[\\\"options\\\"]\\n interval = options.get('interval', 1)\\n count = options.get('count', 1)\\n\\n cmd = \\\"sudo sar -n DEV %d %d\\\" % (interval, count)\\n\\n raw_result = self._execute_command(cmd)\\n result = self._filtrate_result(raw_result)\\n\\n return result\",\n \"def get_oauth_data():\",\n \"def probe_api():\\n\\n info = loads(get(url).text)\\n return info\",\n \"def get():\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68421215","0.6543652","0.64636284","0.6203195","0.61375993","0.5911429","0.58880204","0.5845489","0.5802097","0.57885844","0.57432395","0.57148707","0.5710095","0.5646816","0.56286925","0.5616645","0.5614922","0.56103456","0.56019914","0.55968064","0.55946743","0.5585468","0.55528677","0.55528677","0.55528677","0.55059457","0.5441368","0.54404444","0.5439524","0.5438029","0.54107","0.5409626","0.5395171","0.5392969","0.5366013","0.53489035","0.53362995","0.5335913","0.5322384","0.5322384","0.5321443","0.5308198","0.53058976","0.52944","0.5292505","0.52906495","0.52821016","0.5280711","0.52647436","0.5263888","0.52638495","0.5257619","0.5257518","0.5228837","0.52274376","0.5226846","0.5221803","0.5218312","0.52136624","0.521233","0.5211371","0.52088434","0.52060896","0.52023757","0.51923317","0.51891965","0.5188599","0.518666","0.5153769","0.5150233","0.5148587","0.51196384","0.51187587","0.5115817","0.51095563","0.51095563","0.5106701","0.51058","0.5105605","0.51042444","0.5100568","0.5095127","0.5090872","0.508169","0.50781566","0.5074861","0.5072838","0.5071839","0.50645113","0.5062994","0.5061628","0.5054738","0.50506854","0.50483835","0.5042703","0.50411904","0.5033789","0.5032017","0.50249046","0.5024781"],"string":"[\n \"0.68421215\",\n \"0.6543652\",\n \"0.64636284\",\n \"0.6203195\",\n \"0.61375993\",\n \"0.5911429\",\n \"0.58880204\",\n \"0.5845489\",\n \"0.5802097\",\n \"0.57885844\",\n \"0.57432395\",\n \"0.57148707\",\n \"0.5710095\",\n \"0.5646816\",\n \"0.56286925\",\n \"0.5616645\",\n \"0.5614922\",\n \"0.56103456\",\n \"0.56019914\",\n \"0.55968064\",\n \"0.55946743\",\n \"0.5585468\",\n \"0.55528677\",\n \"0.55528677\",\n \"0.55528677\",\n \"0.55059457\",\n \"0.5441368\",\n \"0.54404444\",\n \"0.5439524\",\n \"0.5438029\",\n \"0.54107\",\n \"0.5409626\",\n \"0.5395171\",\n \"0.5392969\",\n \"0.5366013\",\n \"0.53489035\",\n \"0.53362995\",\n \"0.5335913\",\n \"0.5322384\",\n \"0.5322384\",\n \"0.5321443\",\n \"0.5308198\",\n \"0.53058976\",\n \"0.52944\",\n \"0.5292505\",\n \"0.52906495\",\n \"0.52821016\",\n \"0.5280711\",\n \"0.52647436\",\n \"0.5263888\",\n \"0.52638495\",\n \"0.5257619\",\n \"0.5257518\",\n \"0.5228837\",\n \"0.52274376\",\n \"0.5226846\",\n \"0.5221803\",\n \"0.5218312\",\n \"0.52136624\",\n \"0.521233\",\n \"0.5211371\",\n \"0.52088434\",\n \"0.52060896\",\n \"0.52023757\",\n \"0.51923317\",\n \"0.51891965\",\n \"0.5188599\",\n \"0.518666\",\n \"0.5153769\",\n \"0.5150233\",\n \"0.5148587\",\n \"0.51196384\",\n \"0.51187587\",\n \"0.5115817\",\n \"0.51095563\",\n \"0.51095563\",\n \"0.5106701\",\n \"0.51058\",\n \"0.5105605\",\n \"0.51042444\",\n \"0.5100568\",\n \"0.5095127\",\n \"0.5090872\",\n \"0.508169\",\n \"0.50781566\",\n \"0.5074861\",\n \"0.5072838\",\n \"0.5071839\",\n \"0.50645113\",\n \"0.5062994\",\n \"0.5061628\",\n \"0.5054738\",\n \"0.50506854\",\n \"0.50483835\",\n \"0.5042703\",\n \"0.50411904\",\n \"0.5033789\",\n \"0.5032017\",\n \"0.50249046\",\n \"0.5024781\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5929427"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":7298,"cells":{"query":{"kind":"string","value":"Return the default form class used for user registration."},"document":{"kind":"string","value":"def get_form_class(self, request):\n return RegistrationForm"},"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_form_class(self, request):\n\t\treturn RegistrationForm","def get_form_class(self):\n return self.form_class","def get_form_class(self):\n if self.form_class:\n return self.form_class\n else:\n raise ImproperlyConfigured(\n \"在定义类视图%s的时候,你必须明确指定一个form_class.\"%self.__class__.__name__)","def get_form_class(self):\r\n return modelform_factory(self.model)","def get_form(self, form_class=None):\n\t\tif form_class is None:\n\t\t\tform_class = self.get_form_class()\n\t\treturn form_class(self.request.user, **self.get_form_kwargs())","def get_token_form_class(self):\n from two_factor.forms import AuthenticationTokenForm\n\n return AuthenticationTokenForm","def get_form_class():\n return RazorPaymentForm","def get_form_class(self):\n form_options = self.get_form_options()\n # If a custom form class was passed to the EditHandler, use it.\n # Otherwise, use the base_form_class from the model.\n # If that is not defined, use WagtailAdminModelForm.\n model_form_class = getattr(self.model, \"base_form_class\", WagtailAdminModelForm)\n base_form_class = self.base_form_class or model_form_class\n\n return get_form_for_model(\n self.model,\n form_class=base_form_class,\n **form_options,\n )","def get_form():\n global form_class\n from fluent_comments import appsettings\n\n if form_class is None:\n if appsettings.FLUENT_COMMENTS_FORM_CLASS:\n from django.utils.module_loading import import_string\n\n form_class = import_string(appsettings.FLUENT_COMMENTS_FORM_CLASS)\n else:\n from fluent_comments.forms import FluentCommentForm\n\n form_class = FluentCommentForm\n\n return form_class","def get_form_class(self, form_key):\n return self.get_form_classes()[form_key]","def get_form_class(self):\n\t\treturn formset_factory(super(FormsetMixin, self).get_form_class(), **self.get_formset_kwargs())","def get_default_form(self, display=False):\n form_selector = display_form_selector if display else county_form_selector\n return form_selector.get_combined_form_class(counties=[self.county.slug])","def get_form_class(self):\n return get_review_form(review=self.get_object(), user=self.request.user)","def get_form_classes(self):\n return {\n **self.form_classes\n }","def get_form(self, form_class):\n return form_class(**self.get_form_kwargs())","def get_form(self, form_class=None):\n if form_class is None:\n form_class = self.get_form_class()\n return form_class(\n token=self.request.session.get('token', False),\n aiid=self.kwargs['aiid'],\n **self.get_form_kwargs()\n )","def get_form(self):\n kwargs = {\n \"instance\": self.profile if self.form_object == \"profile\" else self.user,\n \"prefix\": self.name,\n }\n\n if self.request.method == \"POST\":\n return self.form_class(self.request.POST, self.request.FILES, **kwargs)\n else:\n return self.form_class(**kwargs)","def signup_form(request):\n return {'signup_form': UserForm()}","def _get_bulk_change_form_class(self):\n return BulkChangeFormWizardHandlerPluginsForm","def _get_bulk_change_form_class(self):\n return BulkChangeFormElementPluginsForm","def get_form_class(self):\n login_try_count = self.request.session.get('login_try_count', 0)\n\n # If the form has been submitted...\n if self.request.method == \"POST\":\n self.request.session['login_try_count'] = login_try_count + 1\n\n if login_try_count >= 20:\n return CaptchaAuthenticationForm\n\n return super(LoginView, self).get_form_class()","def register_form(self):\n f = Form()\n self.forms = f\n return f","def _get_bulk_change_form_class(self):\n return BulkChangeFormHandlerPluginsForm","def get_form_class(self):\n \n \"\"\"\n Construct a form class that has all the fields and formsets named in\n the children of this edit handler. \n \"\"\"\n if not hasattr(self, 'model'):\n raise AttributeError(\n '%s is not bound to a model yet. Use `.bind_to(model=model)` '\n 'before using this method.' % self.__class__.__name__)\n # If a custom form class was passed to the EditHandler, use it.\n # Otherwise, use the rai_base_form_class from the model.\n # If that is not defined, use RAIAdminModelForm.\n model_form_class = getattr(self.model, 'rai_base_form_class',\n RAIAdminModelForm)\n base_form_class = self.base_form_class or model_form_class\n\n formsets = self.required_formsets()\n\n form_class = rai_modelform_factory(\n self.decorator.get_rai_model(),\n form_class=base_form_class,\n fields=self.required_internal_fields(),\n formsets=formsets,\n widgets=self.widget_overrides())\n form_class.readonly_fields = self.readonly_fields()\n return form_class","def name(self) -> Text:\n\n return \"user_form\"","def get_form_class(self):\n if self.survey.get_requires_payment():\n return AuthorizenetSurveyPurchaseForm\n return super(AuthorizenetSurveyPurchaseCreate, self).get_form_class()","def get_form(self, form_class):\n if self.get_locked_form(form_class):\n return None\n return form_class(**self.get_form_kwargs())","def get_basic_form(self):\n return self.basic_form","def _form_for_type(request, C, defn, add_id_and_rev=False):\n form = build(defn, C, add_id_and_rev=add_id_and_rev,\n widget_registry=_widget_registry(request))\n form.renderer = request.environ['restish.templating'].renderer\n return form","def get_form(self, form_class=None):\n # 设置初始值\n if self.request.method == \"GET\":\n return SecondMenuModelForm(initial={'menu': self.menu_obj})\n else:\n # post提交的时候，不要忘记设置data\n return SecondMenuModelForm(data=self.request.POST)","def _create_forms_py(self, form_class_name):\n return '''\n \"\"\"Configuration forms for the extension.\"\"\"\n\n from django import forms\n from djblets.extensions.forms import SettingsForm\n\n\n class %(form_class_name)s(SettingsForm):\n my_field_1 = forms.CharField()\n my_field_2 = forms.BooleanField()\n ''' % {\n 'form_class_name': form_class_name,\n }","def get_form(self):\n return self.form","def get_form(self):\n return self.form","def get_form(self, form_class=None):\n if self._form_instance:\n return self._form_instance\n self._form_instance = super().get_form(form_class)\n return self.get_form(form_class)","def get_form(self, request, obj=None, **kwargs):\n defaults = {}\n if obj is None:\n defaults['form'] = self.add_form\n defaults.update(kwargs)\n return super(UserAdmin, self).get_form(request, obj, **defaults)","def formfield(self, form_class=RadioSelectField, **kwargs):\n defaults = {\n 'required': not self.blank,\n 'label': capfirst(self.verbose_name),\n 'help_text': self.help_text,\n 'html_attrs': self.html_attrs\n }\n\n if self.has_default():\n defaults['initial'] = self.default\n\n if self.choices:\n # Fields with choices get special treatment.\n include_blank = (self.blank or\n not (self.has_default() or 'initial' in kwargs))\n defaults['choices'] = self.get_choices(include_blank=include_blank)\n defaults['coerce'] = self.to_python\n if self.null:\n defaults['empty_value'] = \"\"\n defaults.update(kwargs)\n return form_class(**defaults)","def _wrap_form(self, parent_form_class):\n steptitle = pd_mf(u'Add ${name}',\n mapping={'name': self.fti.Title()})\n\n form_class = self._create_form_class(parent_form_class, steptitle)\n\n form_class.__name__ = 'WizardForm: %s' % parent_form_class.__name__\n return form_class","def model_form_factory(base=Form, meta=ModelFormMeta, **defaults):\n\n class ModelForm(six.with_metaclass(meta, base)):\n \"\"\"\n A function that returns SQLAlchemy session. This should be\n assigned if you wish to use Unique validator. If you are using\n Flask-SQLAlchemy along with WTForms-Alchemy you don't need to\n set this.\n \"\"\"\n get_session = None\n\n class Meta:\n model = None\n\n default = None\n\n #: Whether or not to skip unknown types. If this is set to True,\n #: fields with types that are not present in FormGenerator type map\n #: will be silently excluded from the generated form.\n #:\n #: By default this is set to False, meaning unknown types throw\n #: exceptions when encountered.\n skip_unknown_types = defaults.pop('skip_unknown_types', False)\n\n #: Whether or not to assign all fields as optional, useful when\n #: creating update forms for patch requests\n all_fields_optional = defaults.pop('all_fields_optional', False)\n\n validators = defaults.pop('validators', {})\n\n #: A dict with keys as field names and values as field arguments.\n field_args = defaults.pop('field_args', {})\n\n #: A dict with keys as field names and values as widget options.\n widget_options = defaults.pop('widget_options', {})\n\n #: Whether or not to include only indexed fields.\n only_indexed_fields = defaults.pop('only_indexed_fields', False)\n\n #: Whether or not to include primary keys.\n include_primary_keys = defaults.pop('include_primary_keys', False)\n\n #: Whether or not to include foreign keys. By default this is False\n #: indicating that foreign keys are not included in the generated\n #: form.\n include_foreign_keys = defaults.pop('include_foreign_keys', False)\n\n #: Whether or not to strip string fields\n strip_string_fields = defaults.pop('strip_string_fields', False)\n\n #: Whether or not to include datetime columns that have a default\n #: value. A good example is created_at column which has a default\n #: value of datetime.utcnow.\n include_datetimes_with_default = defaults.pop(\n 'include_datetimes_with_default', False\n )\n\n #: The default validator to be used for not nullable columns. Set\n #: this to `None` if you wish to disable it.\n not_null_validator = defaults.pop(\n 'not_null_validator',\n InputRequired()\n )\n\n #: A dictionary that overrides not null validation on type level.\n #: Keys should be valid SQLAlchemy types and values should be valid\n #: WTForms validators.\n not_null_validator_type_map = defaults.pop(\n 'not_null_validator_type_map',\n ClassMap(\n [(sa.String, [InputRequired(), DataRequired()])]\n )\n )\n\n #: Default email validator\n email_validator = Email\n\n #: Default length validator\n length_validator = Length\n\n #: Default unique validator\n unique_validator = Unique\n\n #: Default number range validator\n number_range_validator = NumberRange\n\n #: Default date range validator\n date_range_validator = DateRange\n\n #: Default time range validator\n time_range_validator = TimeRange\n\n #: Default optional validator\n optional_validator = Optional\n\n #: Which form generator to use. Only override this if you have a\n #: valid form generator which you want to use instead of the\n #: default one.\n form_generator = defaults.pop(\n 'form_generator', FormGenerator\n )\n\n #: Default date format\n date_format = defaults.pop('date_format', '%Y-%m-%d')\n\n #: Default datetime format\n datetime_format = defaults.pop(\n 'datetime_format', '%Y-%m-%d %H:%M:%S'\n )\n\n #: Dictionary of SQLAlchemy types as keys and WTForms field classes\n #: as values. The key value pairs of this dictionary override\n #: the key value pairs of FormGenerator.TYPE_MAP.\n #:\n #: Using this configuration option one can easily configure the\n #: type conversion in class level.\n type_map = defaults.pop('type_map', ClassMap())\n\n #: Whether or not to raise InvalidAttributExceptions when invalid\n #: attribute names are given for include / exclude or only\n attr_errors = defaults.pop('attr_errors', True)\n\n #: Additional fields to include in the generated form.\n include = defaults.pop('include', [])\n\n #: List of fields to exclude from the generated form.\n exclude = defaults.pop('exclude', [])\n\n #: List of fields to only include in the generated form.\n only = defaults.pop('only', [])\n\n def __init__(self, *args, **kwargs):\n \"\"\"Sets object as form attribute.\"\"\"\n\n self._obj = kwargs.get('obj', None)\n super(ModelForm, self).__init__(*args, **kwargs)\n\n if defaults:\n raise UnknownConfigurationOption(\n list(defaults.keys())[0]\n )\n\n return ModelForm","def get_form_class(self):\n\t\treturn inlineformset_factory(self.get_model(), self.get_related_model(), **self.get_formset_kwargs())","def _get_bulk_change_form_class(self):\n raise NotImplementedError(\n \"You should implement `get_bulk_change_form_class`\"\n )","def get_job_form_class(self, job_name, request=None, object_id=None, view_name=None, extra_context=None):\n return None","def _get_user_class(self, name):\r\n self._user_classes.setdefault(name, _make_user_class(self, name))\r\n return self._user_classes[name]","def _class_default(self):\n if self.auto_create:\n return self.instance_class\n return utils.undefined","def formfield(self, form_class=MultipleSelectField, **kwargs):\n defaults = {\n 'required': not self.blank,\n 'label': capfirst(self.verbose_name),\n 'help_text': self.help_text,\n 'html_attrs': self.html_attrs\n }\n\n if self.has_default():\n defaults['initial'] = self.default\n\n if self.choices:\n # Fields with choices get special treatment.\n include_blank = (self.blank or\n not (self.has_default() or 'initial' in kwargs))\n defaults['choices'] = self.get_choices(include_blank=include_blank)\n defaults['coerce'] = self.to_python\n if self.null:\n defaults['empty_value'] = \"\"\n defaults.update(kwargs)\n return form_class(**defaults)","def formfield(self, **kwargs): # pylint:disable=arguments-differ\n from .forms import CompositeTypeField\n\n defaults = {\n \"form_class\": CompositeTypeField,\n \"model\": self.Meta.model,\n }\n defaults.update(kwargs)\n\n return super().formfield(**defaults)","def input_class(field):\r\n return field.field.widget.__class__.__name__.lower()","def show_new_user_form():\r\n return render_template('user-form.html')","def login_form(request):\n return {'login_form': LoginForm()}","def form(self):\n\t\treturn self._form","def get_form(self):\n return QuestionForm()","def create_form(self, resource=None, edit_form=False):\n form = UserForm(self.config_models, obj=resource)\n\n form.totp_enabled = self.totp_enabled\n\n session = self.session()\n self.update_form_collection(\n resource, edit_form, form.groups, self.Group, 'sorted_groups',\n 'id', 'name', session\n )\n self.update_form_collection(\n resource, edit_form, form.roles, self.Role, 'sorted_roles', 'id',\n 'name', session\n )\n session.close()\n\n return form","def get_validator_class(self):\n return self.validator_class","def registration_form():\n\n return render_template(\"/registration_form.html\")","def special_class(self, form):\n if not len(form) >= 3:\n raise SyntaxError(\"Not enough forms\")\n bases = form[2]\n doc, code = self._getDocAndCode(form[3:])\n return ast.Class(form[1].name, self.compileForms(bases), doc, code)","def formfield(self, form_class=HstoreCheckboxInput, **kwargs):\n defaults = {\n 'required': not self.blank,\n 'label': capfirst(self.verbose_name),\n 'help_text': self.help_text,\n 'html_attrs': self.html_attrs,\n }\n\n if self.has_default():\n defaults['initial'] = self.default\n\n if self.choices:\n # Fields with choices get special treatment.\n include_blank = (self.blank or\n not (self.has_default() or 'initial' in kwargs))\n defaults['choices'] = self.get_choices(include_blank=include_blank)\n defaults['coerce'] = self.to_python\n if self.null:\n defaults['empty_value'] = \"\"\n\n defaults.update(kwargs)\n formfield = form_class(**defaults)\n\n if self.html_attrs:\n formfield.widget.build_attrs(self.html_attrs)\n\n return formfield","def get_model_cls() -> t.Any:\n return SignupRequest","def get_form(self, request, obj=None, **kwargs):\n defaults = {}\n if obj is None:\n defaults['form'] = self.add_form\n defaults.update(kwargs)\n return super(ProfileAdmin, self).get_form(request, obj, **defaults)","def _get_form_creator(self) -> MapsFormHandler:\n return self._form_creator(columns=self._working_context_service.get_file_columns(),\n shapes=self._document_service.get_supported_shapes(),\n shape_keys=self._document_service.get_supported_shape_keys(),\n colour_palette=self._document_service.get_supported_colours(),\n tiles=self._document_service.get_supported_tiles())","def get_form(self, request, obj=None, **kwargs):\n if not obj:\n kwargs['form'] = VPNCreationForm\n else:\n kwargs['form'] = VPNUpdateForm\n return super().get_form(request, obj, **kwargs)","def __init__(self, *args, **kwargs):\n super(RegisterForm, self).__init__(*args, **kwargs)\n\n self.fields['nick'].widget.attrs.update({\n 'label': 'Přezdívka',\n 'placeholder': 'Mirek'\n })\n\n self.fields['name'].widget.attrs.update({\n 'label': 'Jméno',\n 'placeholder': 'Mirek'\n })\n\n self.fields['surname'].widget.attrs.update({\n 'label': 'Příjmení',\n 'placeholder': 'Dušín'\n })\n\n self.fields['email'].widget.attrs.update({\n 'label': 'E-mail',\n 'placeholder': 'mirek@rychlesipy.cz'\n })\n\n self.fields['age'].widget.attrs.update({'label': 'Věk'})\n self.fields['age'].initial = 18\n\n self.fields['race'].widget.attrs.update({'label': 'Rasa'})\n self.fields['race'].queryset = Race.objects.filter(\n active=True).only('id', 'name')\n\n self.fields['group'].widget.attrs.update({\n 'label': 'Skupina',\n 'placeholder': 'Rychlé Šípy'\n })\n\n for field in self.fields.keys():\n self.fields[field].widget.attrs.update({\n 'required': self.fields[field].required,\n 'title': '',\n 'class': 'form-control'\n })","def get_formset_form(formset: forms.BaseFormSet) -> forms.BaseForm:\n return formset._construct_form(0, **formset.get_form_kwargs(0)) # type: ignore","def test_get_form_class(self):\n # Single label\n self.view.learning_model = TestSingleLabelClassifierModel()\n self.assertEqual(self.view.get_form_class(), SingleLabelClassifierForm)\n\n # Multi label\n self.view.learning_model = TestMultiLabelClassifierModel()\n self.assertEqual(self.view.get_form_class(), MultiLabelClassifierForm)","def get_default(cls):\n return cls.USER","def register_form():\n\n return render_template(\"register-form.html\")","def get_app_form():\n\t\n\treturn render_template(\"application-form.html\")","def register_form():\n\n return render_template(\"register.html\")","def __init__(self, *args, **kwargs):\n super(UserCreationForm, self).__init__(*args, **kwargs)\n self.fields[\"first_name\"].required = True\n self.fields[\"last_name\"].required = True\n self.fields[\"email\"].required = True","def form_for_request(request, FormClass, *args, **kwargs):\n return FormClass(request.POST if request.method == 'POST' else None, *args, **kwargs)","def forms(self):\n from hubspot3.forms import FormsClient\n\n return FormsClient(**self.auth, **self.options)","def QuestionForm(user, *args, **kwargs):\n\n if user.is_anonymous():\n if not settings.ALLOW_ANONYMOUS:\n return None\n else:\n selected_fields = ['name', 'email', 'title', 'body', 'phone_number']\n else:\n selected_fields = ['user', 'title', 'body', 'status', 'phone_number']\n\n if settings.ALERTS:\n selected_fields += ['alert']\n\n class _QuestionForm(forms.ModelForm):\n def __init__(self, *args, **kwargs):\n super(_QuestionForm, self).__init__(*args, **kwargs)\n\n for key in self.fields:\n if not key in OPTIONAL_FIELDS:\n self.fields[key].required = True\n\n # hide the internal status for non-staff\n qf = self.fields.get('status', None)\n if qf and not user.is_staff:\n choices = list(qf.choices)\n choices.remove(('internal', _('Internal')))\n qf.choices = choices\n\n # a bit of a hack...\n # hide a field, and use clean to force\n # a specific value of ours\n for key in ['user']:\n qf = self.fields.get(key, None)\n if qf:\n qf.widget = qf.hidden_widget()\n qf.required = False\n\n # honey pot!\n #phone_number = forms.CharField(label=_('Phone number'), required=False)\n # if user.is_anonymous():\n # captcha = ReCaptchaField(attrs={'theme': 'clean', 'lang': 'ru'})\n\n def clean_user(self):\n return user\n\n class Meta:\n model = Question\n fields = selected_fields\n\n return _QuestionForm(*args, **kwargs)","def create_form_user(self, **kwargs):\n user = User.objects.create_user(\n **kwargs\n )\n return user","def get_validator_class(self):\n validator_class = self.oauth_validator_class\n if validator_class is not None:\n return validator_class\n return oauth_api_settings.DEFAULT_VALIDATOR_CLASS","def formfield(self, **kwargs):\n form_class = kwargs.get('form_class', BitOptionsForm)\n if issubclass(form_class, BitOptionsForm):\n defaults = {\n 'form_class': form_class,\n 'min_value': 0,\n 'max_value': self.options.maximum_value,\n 'options': list(self.options)\n }\n kwargs.pop('widget', None)\n else:\n defaults = {}\n defaults.update(kwargs)\n return super(SimpleBitOptionsField, self).formfield(**defaults)","def make_form(self):","def get_form(self, form_id):\n\t\treturn Form(form_id, self.user_id, self.site_id)","def create_form(data, form_class, instance):\n if instance:\n form = form_class(instance=instance)\n if data:\n form = form_class(data, instance=instance)\n else:\n form = form_class()\n if data:\n form = form_class(data)\n return form","def __init__(self, request=None, *args, **kwargs):\n # self.request = request\n\n super(RegistrationForm, self).__init__(*args, **kwargs)","def register(self, form):\n new_user = self.create_inactive_user(form)\n signals.user_registered.send(\n sender=self.__class__, user=new_user, request=self.request\n )\n return new_user","def get_formset(self, formset_class=None):\n if formset_class is None:\n formset_class = self.get_formset_class()\n return formset_class(**self.get_formset_kwargs())","def formfield(self, **kwargs):\n defaults = {\n 'form_class': LocalizedIntegerFieldForm\n }\n\n defaults.update(kwargs)\n return super().formfield(**defaults)","def user_cls(self):\n return self.get_entity_cls('user')","def get_form(self, request, obj=None, **kwargs):\n if not obj:\n kwargs['form'] = VPNClientCreationForm\n return super().get_form(request, obj, **kwargs)","def name(self): \n return \"search_form\"","def make_new_user():\n return render_template('users/new_user_form.html')","def form_tweaks(self):\n pass","def __init__(self, *args, **kwargs):\n super(SignupForm, self).__init__(*args, **kwargs)\n self.fields['email'].required = True\n self.fields['first_name'].required = True\n self.fields['password'].widget = forms.PasswordInput() \n\n for field in self.fields:\n self.fields[field].widget.attrs.update(\n {\n 'class': 'form-control',\n }\n )","def __init__(self, *args, **kw):\n super(SignupFormExtra, self).__init__(*args, **kw)","def __init__(self, request=None, *args, **kwargs):\n self.request = request\n self.user_cache = None\n super(MyAuthenticationForm, self).__init__(*args, **kwargs)\n\n # Set the label for the \"username\" field.\n UserModel = get_user_model()\n self.email_field = UserModel._meta.get_field(UserModel.USERNAME_FIELD)\n if self.fields['email'].label is None:\n self.fields['email'].label = capfirst(self.email_field.verbose_name)","def get_email_class():\n fields = {\n 'name': models.CharField(max_length=256),\n '__unicode__': lambda self: self.name\n }\n options = {\n 'ordering': ['name'],\n }\n for language_key, language_name in settings.LANGUAGES:\n fields['html_{}'.format(language_key)] = models.TextField(blank=True, null=True)\n return create_model('Email', fields, 'wedding', options=options)","def boots_form(obj):\n\n if isinstance(obj, BaseForm):\n return form(obj)\n\n elif isinstance(obj, BoundField):\n return boots_field(obj)\n\n else:\n raise Exception, 'Bootstrap template tag recieved a non form or field object'","def __init__(self, *args, **kwargs):\n super(UserForm, self).__init__(*args, **kwargs)\n\n self.fields[\"groups\"].label = \"roles\"","def get_class(self):\n\t\treturn self.CLASS","def __init__(self, *args, **kwargs):\n user = None\n if 'user' in kwargs:\n user = kwargs.pop('user')\n super(PersonForm, self).__init__(*args, **kwargs)\n if user:\n self.fields['username'].initial = user.username\n self.fields['first_name'].initial = user.first_name\n self.fields['last_name'].initial = user.last_name\n self.fields['email_address'].initial = user.email\n self.fields.keyOrder = [\n 'id', 'username', 'first_name', 'middle_name', 'last_name',\n 'email_address', 'gender',\n 'new_password', 'confirm_new_password', 'signature',\n 'signature_html', 'time_zone', 'language', 'show_signatures',\n 'avatar', 'autosubscribe', 'comment'\n ]","def form(self):\n return security.get_field_storage()","def class_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"class_name\")","def get_form_for_model(\n model,\n form_class=WagtailAdminModelForm,\n **kwargs,\n):\n\n # This is really just Django's modelform_factory, tweaked to accept arbitrary kwargs.\n\n meta_class_attrs = kwargs\n meta_class_attrs[\"model\"] = model\n\n # The kwargs passed here are expected to come from EditHandler.get_form_options, which collects\n # them by descending the tree of child edit handlers. If there are no edit handlers that\n # specify form fields, this can legitimately result in both 'fields' and 'exclude' being\n # absent, which ModelForm doesn't normally allow. In this case, explicitly set fields to [].\n if \"fields\" not in meta_class_attrs and \"exclude\" not in meta_class_attrs:\n meta_class_attrs[\"fields\"] = []\n\n # Give this new form class a reasonable name.\n class_name = model.__name__ + \"Form\"\n bases = (form_class.Meta,) if hasattr(form_class, \"Meta\") else ()\n Meta = type(\"Meta\", bases, meta_class_attrs)\n form_class_attrs = {\"Meta\": Meta}\n\n metaclass = type(form_class)\n return metaclass(class_name, (form_class,), form_class_attrs)","def listfield_formfield_method(self, **kwargs):\r\n #Largely lifted straight from Field.formfield() in django.models.__init__.py\r\n defaults = {'required': not self.blank, 'label': capfirst(self.verbose_name), 'help_text': self.help_text}\r\n if self.has_default(): #No idea what this does\r\n if callable(self.default):\r\n True\r\n defaults['initial'] = self.default\r\n defaults['show_hidden_initial'] = True\r\n else:\r\n defaults['initial'] = self.get_default()\r\n #if self.choices:\r\n if self.choices:\r\n form_field_class = forms.MultipleChoiceField\r\n defaults['choices'] = self.choices\r\n else:\r\n form_field_class = ListFormField\r\n defaults.update(**kwargs)\r\n return form_field_class(**defaults)","def show_register_form():\n return render_template(\"register-form.html\")","def __init__(self, request=None, *args, **kwargs):\r\n self.request = request\r\n self.user_cache = None\r\n super(CustomizeAuthenticationForm, self).__init__(*args, **kwargs)\r\n\r\n # Set the label for the \"username\" field.\r\n UserModel = get_user_model()\r\n self.username_field = UserModel._meta.get_field(UserModel.USERNAME_FIELD)\r\n if self.fields['username'].label is None:\r\n self.fields['username'].label = capfirst(self.username_field.verbose_name)","def registrationView(request):\n \n form = SmellerModelForm()\n form2 = SmellerModelForm2()\n \n return render(request, 'SmellGuessTemplate/registration.html', {'current_date': datetime.now(), 'form': form, 'form2': form2})"],"string":"[\n \"def get_form_class(self, request):\\n\\t\\treturn RegistrationForm\",\n \"def get_form_class(self):\\n return self.form_class\",\n \"def get_form_class(self):\\n if self.form_class:\\n return self.form_class\\n else:\\n raise ImproperlyConfigured(\\n \\\"在定义类视图%s的时候,你必须明确指定一个form_class.\\\"%self.__class__.__name__)\",\n \"def get_form_class(self):\\r\\n return modelform_factory(self.model)\",\n \"def get_form(self, form_class=None):\\n\\t\\tif form_class is None:\\n\\t\\t\\tform_class = self.get_form_class()\\n\\t\\treturn form_class(self.request.user, **self.get_form_kwargs())\",\n \"def get_token_form_class(self):\\n from two_factor.forms import AuthenticationTokenForm\\n\\n return AuthenticationTokenForm\",\n \"def get_form_class():\\n return RazorPaymentForm\",\n \"def get_form_class(self):\\n form_options = self.get_form_options()\\n # If a custom form class was passed to the EditHandler, use it.\\n # Otherwise, use the base_form_class from the model.\\n # If that is not defined, use WagtailAdminModelForm.\\n model_form_class = getattr(self.model, \\\"base_form_class\\\", WagtailAdminModelForm)\\n base_form_class = self.base_form_class or model_form_class\\n\\n return get_form_for_model(\\n self.model,\\n form_class=base_form_class,\\n **form_options,\\n )\",\n \"def get_form():\\n global form_class\\n from fluent_comments import appsettings\\n\\n if form_class is None:\\n if appsettings.FLUENT_COMMENTS_FORM_CLASS:\\n from django.utils.module_loading import import_string\\n\\n form_class = import_string(appsettings.FLUENT_COMMENTS_FORM_CLASS)\\n else:\\n from fluent_comments.forms import FluentCommentForm\\n\\n form_class = FluentCommentForm\\n\\n return form_class\",\n \"def get_form_class(self, form_key):\\n return self.get_form_classes()[form_key]\",\n \"def get_form_class(self):\\n\\t\\treturn formset_factory(super(FormsetMixin, self).get_form_class(), **self.get_formset_kwargs())\",\n \"def get_default_form(self, display=False):\\n form_selector = display_form_selector if display else county_form_selector\\n return form_selector.get_combined_form_class(counties=[self.county.slug])\",\n \"def get_form_class(self):\\n return get_review_form(review=self.get_object(), user=self.request.user)\",\n \"def get_form_classes(self):\\n return {\\n **self.form_classes\\n }\",\n \"def get_form(self, form_class):\\n return form_class(**self.get_form_kwargs())\",\n \"def get_form(self, form_class=None):\\n if form_class is None:\\n form_class = self.get_form_class()\\n return form_class(\\n token=self.request.session.get('token', False),\\n aiid=self.kwargs['aiid'],\\n **self.get_form_kwargs()\\n )\",\n \"def get_form(self):\\n kwargs = {\\n \\\"instance\\\": self.profile if self.form_object == \\\"profile\\\" else self.user,\\n \\\"prefix\\\": self.name,\\n }\\n\\n if self.request.method == \\\"POST\\\":\\n return self.form_class(self.request.POST, self.request.FILES, **kwargs)\\n else:\\n return self.form_class(**kwargs)\",\n \"def signup_form(request):\\n return {'signup_form': UserForm()}\",\n \"def _get_bulk_change_form_class(self):\\n return BulkChangeFormWizardHandlerPluginsForm\",\n \"def _get_bulk_change_form_class(self):\\n return BulkChangeFormElementPluginsForm\",\n \"def get_form_class(self):\\n login_try_count = self.request.session.get('login_try_count', 0)\\n\\n # If the form has been submitted...\\n if self.request.method == \\\"POST\\\":\\n self.request.session['login_try_count'] = login_try_count + 1\\n\\n if login_try_count >= 20:\\n return CaptchaAuthenticationForm\\n\\n return super(LoginView, self).get_form_class()\",\n \"def register_form(self):\\n f = Form()\\n self.forms = f\\n return f\",\n \"def _get_bulk_change_form_class(self):\\n return BulkChangeFormHandlerPluginsForm\",\n \"def get_form_class(self):\\n \\n \\\"\\\"\\\"\\n Construct a form class that has all the fields and formsets named in\\n the children of this edit handler. \\n \\\"\\\"\\\"\\n if not hasattr(self, 'model'):\\n raise AttributeError(\\n '%s is not bound to a model yet. Use `.bind_to(model=model)` '\\n 'before using this method.' % self.__class__.__name__)\\n # If a custom form class was passed to the EditHandler, use it.\\n # Otherwise, use the rai_base_form_class from the model.\\n # If that is not defined, use RAIAdminModelForm.\\n model_form_class = getattr(self.model, 'rai_base_form_class',\\n RAIAdminModelForm)\\n base_form_class = self.base_form_class or model_form_class\\n\\n formsets = self.required_formsets()\\n\\n form_class = rai_modelform_factory(\\n self.decorator.get_rai_model(),\\n form_class=base_form_class,\\n fields=self.required_internal_fields(),\\n formsets=formsets,\\n widgets=self.widget_overrides())\\n form_class.readonly_fields = self.readonly_fields()\\n return form_class\",\n \"def name(self) -> Text:\\n\\n return \\\"user_form\\\"\",\n \"def get_form_class(self):\\n if self.survey.get_requires_payment():\\n return AuthorizenetSurveyPurchaseForm\\n return super(AuthorizenetSurveyPurchaseCreate, self).get_form_class()\",\n \"def get_form(self, form_class):\\n if self.get_locked_form(form_class):\\n return None\\n return form_class(**self.get_form_kwargs())\",\n \"def get_basic_form(self):\\n return self.basic_form\",\n \"def _form_for_type(request, C, defn, add_id_and_rev=False):\\n form = build(defn, C, add_id_and_rev=add_id_and_rev,\\n widget_registry=_widget_registry(request))\\n form.renderer = request.environ['restish.templating'].renderer\\n return form\",\n \"def get_form(self, form_class=None):\\n # 设置初始值\\n if self.request.method == \\\"GET\\\":\\n return SecondMenuModelForm(initial={'menu': self.menu_obj})\\n else:\\n # post提交的时候，不要忘记设置data\\n return SecondMenuModelForm(data=self.request.POST)\",\n \"def _create_forms_py(self, form_class_name):\\n return '''\\n \\\"\\\"\\\"Configuration forms for the extension.\\\"\\\"\\\"\\n\\n from django import forms\\n from djblets.extensions.forms import SettingsForm\\n\\n\\n class %(form_class_name)s(SettingsForm):\\n my_field_1 = forms.CharField()\\n my_field_2 = forms.BooleanField()\\n ''' % {\\n 'form_class_name': form_class_name,\\n }\",\n \"def get_form(self):\\n return self.form\",\n \"def get_form(self):\\n return self.form\",\n \"def get_form(self, form_class=None):\\n if self._form_instance:\\n return self._form_instance\\n self._form_instance = super().get_form(form_class)\\n return self.get_form(form_class)\",\n \"def get_form(self, request, obj=None, **kwargs):\\n defaults = {}\\n if obj is None:\\n defaults['form'] = self.add_form\\n defaults.update(kwargs)\\n return super(UserAdmin, self).get_form(request, obj, **defaults)\",\n \"def formfield(self, form_class=RadioSelectField, **kwargs):\\n defaults = {\\n 'required': not self.blank,\\n 'label': capfirst(self.verbose_name),\\n 'help_text': self.help_text,\\n 'html_attrs': self.html_attrs\\n }\\n\\n if self.has_default():\\n defaults['initial'] = self.default\\n\\n if self.choices:\\n # Fields with choices get special treatment.\\n include_blank = (self.blank or\\n not (self.has_default() or 'initial' in kwargs))\\n defaults['choices'] = self.get_choices(include_blank=include_blank)\\n defaults['coerce'] = self.to_python\\n if self.null:\\n defaults['empty_value'] = \\\"\\\"\\n defaults.update(kwargs)\\n return form_class(**defaults)\",\n \"def _wrap_form(self, parent_form_class):\\n steptitle = pd_mf(u'Add ${name}',\\n mapping={'name': self.fti.Title()})\\n\\n form_class = self._create_form_class(parent_form_class, steptitle)\\n\\n form_class.__name__ = 'WizardForm: %s' % parent_form_class.__name__\\n return form_class\",\n \"def model_form_factory(base=Form, meta=ModelFormMeta, **defaults):\\n\\n class ModelForm(six.with_metaclass(meta, base)):\\n \\\"\\\"\\\"\\n A function that returns SQLAlchemy session. This should be\\n assigned if you wish to use Unique validator. If you are using\\n Flask-SQLAlchemy along with WTForms-Alchemy you don't need to\\n set this.\\n \\\"\\\"\\\"\\n get_session = None\\n\\n class Meta:\\n model = None\\n\\n default = None\\n\\n #: Whether or not to skip unknown types. If this is set to True,\\n #: fields with types that are not present in FormGenerator type map\\n #: will be silently excluded from the generated form.\\n #:\\n #: By default this is set to False, meaning unknown types throw\\n #: exceptions when encountered.\\n skip_unknown_types = defaults.pop('skip_unknown_types', False)\\n\\n #: Whether or not to assign all fields as optional, useful when\\n #: creating update forms for patch requests\\n all_fields_optional = defaults.pop('all_fields_optional', False)\\n\\n validators = defaults.pop('validators', {})\\n\\n #: A dict with keys as field names and values as field arguments.\\n field_args = defaults.pop('field_args', {})\\n\\n #: A dict with keys as field names and values as widget options.\\n widget_options = defaults.pop('widget_options', {})\\n\\n #: Whether or not to include only indexed fields.\\n only_indexed_fields = defaults.pop('only_indexed_fields', False)\\n\\n #: Whether or not to include primary keys.\\n include_primary_keys = defaults.pop('include_primary_keys', False)\\n\\n #: Whether or not to include foreign keys. By default this is False\\n #: indicating that foreign keys are not included in the generated\\n #: form.\\n include_foreign_keys = defaults.pop('include_foreign_keys', False)\\n\\n #: Whether or not to strip string fields\\n strip_string_fields = defaults.pop('strip_string_fields', False)\\n\\n #: Whether or not to include datetime columns that have a default\\n #: value. A good example is created_at column which has a default\\n #: value of datetime.utcnow.\\n include_datetimes_with_default = defaults.pop(\\n 'include_datetimes_with_default', False\\n )\\n\\n #: The default validator to be used for not nullable columns. Set\\n #: this to `None` if you wish to disable it.\\n not_null_validator = defaults.pop(\\n 'not_null_validator',\\n InputRequired()\\n )\\n\\n #: A dictionary that overrides not null validation on type level.\\n #: Keys should be valid SQLAlchemy types and values should be valid\\n #: WTForms validators.\\n not_null_validator_type_map = defaults.pop(\\n 'not_null_validator_type_map',\\n ClassMap(\\n [(sa.String, [InputRequired(), DataRequired()])]\\n )\\n )\\n\\n #: Default email validator\\n email_validator = Email\\n\\n #: Default length validator\\n length_validator = Length\\n\\n #: Default unique validator\\n unique_validator = Unique\\n\\n #: Default number range validator\\n number_range_validator = NumberRange\\n\\n #: Default date range validator\\n date_range_validator = DateRange\\n\\n #: Default time range validator\\n time_range_validator = TimeRange\\n\\n #: Default optional validator\\n optional_validator = Optional\\n\\n #: Which form generator to use. Only override this if you have a\\n #: valid form generator which you want to use instead of the\\n #: default one.\\n form_generator = defaults.pop(\\n 'form_generator', FormGenerator\\n )\\n\\n #: Default date format\\n date_format = defaults.pop('date_format', '%Y-%m-%d')\\n\\n #: Default datetime format\\n datetime_format = defaults.pop(\\n 'datetime_format', '%Y-%m-%d %H:%M:%S'\\n )\\n\\n #: Dictionary of SQLAlchemy types as keys and WTForms field classes\\n #: as values. The key value pairs of this dictionary override\\n #: the key value pairs of FormGenerator.TYPE_MAP.\\n #:\\n #: Using this configuration option one can easily configure the\\n #: type conversion in class level.\\n type_map = defaults.pop('type_map', ClassMap())\\n\\n #: Whether or not to raise InvalidAttributExceptions when invalid\\n #: attribute names are given for include / exclude or only\\n attr_errors = defaults.pop('attr_errors', True)\\n\\n #: Additional fields to include in the generated form.\\n include = defaults.pop('include', [])\\n\\n #: List of fields to exclude from the generated form.\\n exclude = defaults.pop('exclude', [])\\n\\n #: List of fields to only include in the generated form.\\n only = defaults.pop('only', [])\\n\\n def __init__(self, *args, **kwargs):\\n \\\"\\\"\\\"Sets object as form attribute.\\\"\\\"\\\"\\n\\n self._obj = kwargs.get('obj', None)\\n super(ModelForm, self).__init__(*args, **kwargs)\\n\\n if defaults:\\n raise UnknownConfigurationOption(\\n list(defaults.keys())[0]\\n )\\n\\n return ModelForm\",\n \"def get_form_class(self):\\n\\t\\treturn inlineformset_factory(self.get_model(), self.get_related_model(), **self.get_formset_kwargs())\",\n \"def _get_bulk_change_form_class(self):\\n raise NotImplementedError(\\n \\\"You should implement `get_bulk_change_form_class`\\\"\\n )\",\n \"def get_job_form_class(self, job_name, request=None, object_id=None, view_name=None, extra_context=None):\\n return None\",\n \"def _get_user_class(self, name):\\r\\n self._user_classes.setdefault(name, _make_user_class(self, name))\\r\\n return self._user_classes[name]\",\n \"def _class_default(self):\\n if self.auto_create:\\n return self.instance_class\\n return utils.undefined\",\n \"def formfield(self, form_class=MultipleSelectField, **kwargs):\\n defaults = {\\n 'required': not self.blank,\\n 'label': capfirst(self.verbose_name),\\n 'help_text': self.help_text,\\n 'html_attrs': self.html_attrs\\n }\\n\\n if self.has_default():\\n defaults['initial'] = self.default\\n\\n if self.choices:\\n # Fields with choices get special treatment.\\n include_blank = (self.blank or\\n not (self.has_default() or 'initial' in kwargs))\\n defaults['choices'] = self.get_choices(include_blank=include_blank)\\n defaults['coerce'] = self.to_python\\n if self.null:\\n defaults['empty_value'] = \\\"\\\"\\n defaults.update(kwargs)\\n return form_class(**defaults)\",\n \"def formfield(self, **kwargs): # pylint:disable=arguments-differ\\n from .forms import CompositeTypeField\\n\\n defaults = {\\n \\\"form_class\\\": CompositeTypeField,\\n \\\"model\\\": self.Meta.model,\\n }\\n defaults.update(kwargs)\\n\\n return super().formfield(**defaults)\",\n \"def input_class(field):\\r\\n return field.field.widget.__class__.__name__.lower()\",\n \"def show_new_user_form():\\r\\n return render_template('user-form.html')\",\n \"def login_form(request):\\n return {'login_form': LoginForm()}\",\n \"def form(self):\\n\\t\\treturn self._form\",\n \"def get_form(self):\\n return QuestionForm()\",\n \"def create_form(self, resource=None, edit_form=False):\\n form = UserForm(self.config_models, obj=resource)\\n\\n form.totp_enabled = self.totp_enabled\\n\\n session = self.session()\\n self.update_form_collection(\\n resource, edit_form, form.groups, self.Group, 'sorted_groups',\\n 'id', 'name', session\\n )\\n self.update_form_collection(\\n resource, edit_form, form.roles, self.Role, 'sorted_roles', 'id',\\n 'name', session\\n )\\n session.close()\\n\\n return form\",\n \"def get_validator_class(self):\\n return self.validator_class\",\n \"def registration_form():\\n\\n return render_template(\\\"/registration_form.html\\\")\",\n \"def special_class(self, form):\\n if not len(form) >= 3:\\n raise SyntaxError(\\\"Not enough forms\\\")\\n bases = form[2]\\n doc, code = self._getDocAndCode(form[3:])\\n return ast.Class(form[1].name, self.compileForms(bases), doc, code)\",\n \"def formfield(self, form_class=HstoreCheckboxInput, **kwargs):\\n defaults = {\\n 'required': not self.blank,\\n 'label': capfirst(self.verbose_name),\\n 'help_text': self.help_text,\\n 'html_attrs': self.html_attrs,\\n }\\n\\n if self.has_default():\\n defaults['initial'] = self.default\\n\\n if self.choices:\\n # Fields with choices get special treatment.\\n include_blank = (self.blank or\\n not (self.has_default() or 'initial' in kwargs))\\n defaults['choices'] = self.get_choices(include_blank=include_blank)\\n defaults['coerce'] = self.to_python\\n if self.null:\\n defaults['empty_value'] = \\\"\\\"\\n\\n defaults.update(kwargs)\\n formfield = form_class(**defaults)\\n\\n if self.html_attrs:\\n formfield.widget.build_attrs(self.html_attrs)\\n\\n return formfield\",\n \"def get_model_cls() -> t.Any:\\n return SignupRequest\",\n \"def get_form(self, request, obj=None, **kwargs):\\n defaults = {}\\n if obj is None:\\n defaults['form'] = self.add_form\\n defaults.update(kwargs)\\n return super(ProfileAdmin, self).get_form(request, obj, **defaults)\",\n \"def _get_form_creator(self) -> MapsFormHandler:\\n return self._form_creator(columns=self._working_context_service.get_file_columns(),\\n shapes=self._document_service.get_supported_shapes(),\\n shape_keys=self._document_service.get_supported_shape_keys(),\\n colour_palette=self._document_service.get_supported_colours(),\\n tiles=self._document_service.get_supported_tiles())\",\n \"def get_form(self, request, obj=None, **kwargs):\\n if not obj:\\n kwargs['form'] = VPNCreationForm\\n else:\\n kwargs['form'] = VPNUpdateForm\\n return super().get_form(request, obj, **kwargs)\",\n \"def __init__(self, *args, **kwargs):\\n super(RegisterForm, self).__init__(*args, **kwargs)\\n\\n self.fields['nick'].widget.attrs.update({\\n 'label': 'Přezdívka',\\n 'placeholder': 'Mirek'\\n })\\n\\n self.fields['name'].widget.attrs.update({\\n 'label': 'Jméno',\\n 'placeholder': 'Mirek'\\n })\\n\\n self.fields['surname'].widget.attrs.update({\\n 'label': 'Příjmení',\\n 'placeholder': 'Dušín'\\n })\\n\\n self.fields['email'].widget.attrs.update({\\n 'label': 'E-mail',\\n 'placeholder': 'mirek@rychlesipy.cz'\\n })\\n\\n self.fields['age'].widget.attrs.update({'label': 'Věk'})\\n self.fields['age'].initial = 18\\n\\n self.fields['race'].widget.attrs.update({'label': 'Rasa'})\\n self.fields['race'].queryset = Race.objects.filter(\\n active=True).only('id', 'name')\\n\\n self.fields['group'].widget.attrs.update({\\n 'label': 'Skupina',\\n 'placeholder': 'Rychlé Šípy'\\n })\\n\\n for field in self.fields.keys():\\n self.fields[field].widget.attrs.update({\\n 'required': self.fields[field].required,\\n 'title': '',\\n 'class': 'form-control'\\n })\",\n \"def get_formset_form(formset: forms.BaseFormSet) -> forms.BaseForm:\\n return formset._construct_form(0, **formset.get_form_kwargs(0)) # type: ignore\",\n \"def test_get_form_class(self):\\n # Single label\\n self.view.learning_model = TestSingleLabelClassifierModel()\\n self.assertEqual(self.view.get_form_class(), SingleLabelClassifierForm)\\n\\n # Multi label\\n self.view.learning_model = TestMultiLabelClassifierModel()\\n self.assertEqual(self.view.get_form_class(), MultiLabelClassifierForm)\",\n \"def get_default(cls):\\n return cls.USER\",\n \"def register_form():\\n\\n return render_template(\\\"register-form.html\\\")\",\n \"def get_app_form():\\n\\t\\n\\treturn render_template(\\\"application-form.html\\\")\",\n \"def register_form():\\n\\n return render_template(\\\"register.html\\\")\",\n \"def __init__(self, *args, **kwargs):\\n super(UserCreationForm, self).__init__(*args, **kwargs)\\n self.fields[\\\"first_name\\\"].required = True\\n self.fields[\\\"last_name\\\"].required = True\\n self.fields[\\\"email\\\"].required = True\",\n \"def form_for_request(request, FormClass, *args, **kwargs):\\n return FormClass(request.POST if request.method == 'POST' else None, *args, **kwargs)\",\n \"def forms(self):\\n from hubspot3.forms import FormsClient\\n\\n return FormsClient(**self.auth, **self.options)\",\n \"def QuestionForm(user, *args, **kwargs):\\n\\n if user.is_anonymous():\\n if not settings.ALLOW_ANONYMOUS:\\n return None\\n else:\\n selected_fields = ['name', 'email', 'title', 'body', 'phone_number']\\n else:\\n selected_fields = ['user', 'title', 'body', 'status', 'phone_number']\\n\\n if settings.ALERTS:\\n selected_fields += ['alert']\\n\\n class _QuestionForm(forms.ModelForm):\\n def __init__(self, *args, **kwargs):\\n super(_QuestionForm, self).__init__(*args, **kwargs)\\n\\n for key in self.fields:\\n if not key in OPTIONAL_FIELDS:\\n self.fields[key].required = True\\n\\n # hide the internal status for non-staff\\n qf = self.fields.get('status', None)\\n if qf and not user.is_staff:\\n choices = list(qf.choices)\\n choices.remove(('internal', _('Internal')))\\n qf.choices = choices\\n\\n # a bit of a hack...\\n # hide a field, and use clean to force\\n # a specific value of ours\\n for key in ['user']:\\n qf = self.fields.get(key, None)\\n if qf:\\n qf.widget = qf.hidden_widget()\\n qf.required = False\\n\\n # honey pot!\\n #phone_number = forms.CharField(label=_('Phone number'), required=False)\\n # if user.is_anonymous():\\n # captcha = ReCaptchaField(attrs={'theme': 'clean', 'lang': 'ru'})\\n\\n def clean_user(self):\\n return user\\n\\n class Meta:\\n model = Question\\n fields = selected_fields\\n\\n return _QuestionForm(*args, **kwargs)\",\n \"def create_form_user(self, **kwargs):\\n user = User.objects.create_user(\\n **kwargs\\n )\\n return user\",\n \"def get_validator_class(self):\\n validator_class = self.oauth_validator_class\\n if validator_class is not None:\\n return validator_class\\n return oauth_api_settings.DEFAULT_VALIDATOR_CLASS\",\n \"def formfield(self, **kwargs):\\n form_class = kwargs.get('form_class', BitOptionsForm)\\n if issubclass(form_class, BitOptionsForm):\\n defaults = {\\n 'form_class': form_class,\\n 'min_value': 0,\\n 'max_value': self.options.maximum_value,\\n 'options': list(self.options)\\n }\\n kwargs.pop('widget', None)\\n else:\\n defaults = {}\\n defaults.update(kwargs)\\n return super(SimpleBitOptionsField, self).formfield(**defaults)\",\n \"def make_form(self):\",\n \"def get_form(self, form_id):\\n\\t\\treturn Form(form_id, self.user_id, self.site_id)\",\n \"def create_form(data, form_class, instance):\\n if instance:\\n form = form_class(instance=instance)\\n if data:\\n form = form_class(data, instance=instance)\\n else:\\n form = form_class()\\n if data:\\n form = form_class(data)\\n return form\",\n \"def __init__(self, request=None, *args, **kwargs):\\n # self.request = request\\n\\n super(RegistrationForm, self).__init__(*args, **kwargs)\",\n \"def register(self, form):\\n new_user = self.create_inactive_user(form)\\n signals.user_registered.send(\\n sender=self.__class__, user=new_user, request=self.request\\n )\\n return new_user\",\n \"def get_formset(self, formset_class=None):\\n if formset_class is None:\\n formset_class = self.get_formset_class()\\n return formset_class(**self.get_formset_kwargs())\",\n \"def formfield(self, **kwargs):\\n defaults = {\\n 'form_class': LocalizedIntegerFieldForm\\n }\\n\\n defaults.update(kwargs)\\n return super().formfield(**defaults)\",\n \"def user_cls(self):\\n return self.get_entity_cls('user')\",\n \"def get_form(self, request, obj=None, **kwargs):\\n if not obj:\\n kwargs['form'] = VPNClientCreationForm\\n return super().get_form(request, obj, **kwargs)\",\n \"def name(self): \\n return \\\"search_form\\\"\",\n \"def make_new_user():\\n return render_template('users/new_user_form.html')\",\n \"def form_tweaks(self):\\n pass\",\n \"def __init__(self, *args, **kwargs):\\n super(SignupForm, self).__init__(*args, **kwargs)\\n self.fields['email'].required = True\\n self.fields['first_name'].required = True\\n self.fields['password'].widget = forms.PasswordInput() \\n\\n for field in self.fields:\\n self.fields[field].widget.attrs.update(\\n {\\n 'class': 'form-control',\\n }\\n )\",\n \"def __init__(self, *args, **kw):\\n super(SignupFormExtra, self).__init__(*args, **kw)\",\n \"def __init__(self, request=None, *args, **kwargs):\\n self.request = request\\n self.user_cache = None\\n super(MyAuthenticationForm, self).__init__(*args, **kwargs)\\n\\n # Set the label for the \\\"username\\\" field.\\n UserModel = get_user_model()\\n self.email_field = UserModel._meta.get_field(UserModel.USERNAME_FIELD)\\n if self.fields['email'].label is None:\\n self.fields['email'].label = capfirst(self.email_field.verbose_name)\",\n \"def get_email_class():\\n fields = {\\n 'name': models.CharField(max_length=256),\\n '__unicode__': lambda self: self.name\\n }\\n options = {\\n 'ordering': ['name'],\\n }\\n for language_key, language_name in settings.LANGUAGES:\\n fields['html_{}'.format(language_key)] = models.TextField(blank=True, null=True)\\n return create_model('Email', fields, 'wedding', options=options)\",\n \"def boots_form(obj):\\n\\n if isinstance(obj, BaseForm):\\n return form(obj)\\n\\n elif isinstance(obj, BoundField):\\n return boots_field(obj)\\n\\n else:\\n raise Exception, 'Bootstrap template tag recieved a non form or field object'\",\n \"def __init__(self, *args, **kwargs):\\n super(UserForm, self).__init__(*args, **kwargs)\\n\\n self.fields[\\\"groups\\\"].label = \\\"roles\\\"\",\n \"def get_class(self):\\n\\t\\treturn self.CLASS\",\n \"def __init__(self, *args, **kwargs):\\n user = None\\n if 'user' in kwargs:\\n user = kwargs.pop('user')\\n super(PersonForm, self).__init__(*args, **kwargs)\\n if user:\\n self.fields['username'].initial = user.username\\n self.fields['first_name'].initial = user.first_name\\n self.fields['last_name'].initial = user.last_name\\n self.fields['email_address'].initial = user.email\\n self.fields.keyOrder = [\\n 'id', 'username', 'first_name', 'middle_name', 'last_name',\\n 'email_address', 'gender',\\n 'new_password', 'confirm_new_password', 'signature',\\n 'signature_html', 'time_zone', 'language', 'show_signatures',\\n 'avatar', 'autosubscribe', 'comment'\\n ]\",\n \"def form(self):\\n return security.get_field_storage()\",\n \"def class_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"class_name\\\")\",\n \"def get_form_for_model(\\n model,\\n form_class=WagtailAdminModelForm,\\n **kwargs,\\n):\\n\\n # This is really just Django's modelform_factory, tweaked to accept arbitrary kwargs.\\n\\n meta_class_attrs = kwargs\\n meta_class_attrs[\\\"model\\\"] = model\\n\\n # The kwargs passed here are expected to come from EditHandler.get_form_options, which collects\\n # them by descending the tree of child edit handlers. If there are no edit handlers that\\n # specify form fields, this can legitimately result in both 'fields' and 'exclude' being\\n # absent, which ModelForm doesn't normally allow. In this case, explicitly set fields to [].\\n if \\\"fields\\\" not in meta_class_attrs and \\\"exclude\\\" not in meta_class_attrs:\\n meta_class_attrs[\\\"fields\\\"] = []\\n\\n # Give this new form class a reasonable name.\\n class_name = model.__name__ + \\\"Form\\\"\\n bases = (form_class.Meta,) if hasattr(form_class, \\\"Meta\\\") else ()\\n Meta = type(\\\"Meta\\\", bases, meta_class_attrs)\\n form_class_attrs = {\\\"Meta\\\": Meta}\\n\\n metaclass = type(form_class)\\n return metaclass(class_name, (form_class,), form_class_attrs)\",\n \"def listfield_formfield_method(self, **kwargs):\\r\\n #Largely lifted straight from Field.formfield() in django.models.__init__.py\\r\\n defaults = {'required': not self.blank, 'label': capfirst(self.verbose_name), 'help_text': self.help_text}\\r\\n if self.has_default(): #No idea what this does\\r\\n if callable(self.default):\\r\\n True\\r\\n defaults['initial'] = self.default\\r\\n defaults['show_hidden_initial'] = True\\r\\n else:\\r\\n defaults['initial'] = self.get_default()\\r\\n #if self.choices:\\r\\n if self.choices:\\r\\n form_field_class = forms.MultipleChoiceField\\r\\n defaults['choices'] = self.choices\\r\\n else:\\r\\n form_field_class = ListFormField\\r\\n defaults.update(**kwargs)\\r\\n return form_field_class(**defaults)\",\n \"def show_register_form():\\n return render_template(\\\"register-form.html\\\")\",\n \"def __init__(self, request=None, *args, **kwargs):\\r\\n self.request = request\\r\\n self.user_cache = None\\r\\n super(CustomizeAuthenticationForm, self).__init__(*args, **kwargs)\\r\\n\\r\\n # Set the label for the \\\"username\\\" field.\\r\\n UserModel = get_user_model()\\r\\n self.username_field = UserModel._meta.get_field(UserModel.USERNAME_FIELD)\\r\\n if self.fields['username'].label is None:\\r\\n self.fields['username'].label = capfirst(self.username_field.verbose_name)\",\n \"def registrationView(request):\\n \\n form = SmellerModelForm()\\n form2 = SmellerModelForm2()\\n \\n return render(request, 'SmellGuessTemplate/registration.html', {'current_date': datetime.now(), 'form': form, 'form2': form2})\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8111784","0.770102","0.74282926","0.72233987","0.71631217","0.7097246","0.7082445","0.696311","0.692484","0.6767896","0.67418265","0.66456175","0.66020036","0.64767134","0.64665145","0.64210325","0.63494134","0.6314577","0.62687373","0.6240669","0.6233663","0.6218351","0.6175523","0.6134979","0.6127915","0.611254","0.5986515","0.5926572","0.58976483","0.5886312","0.5872859","0.58338857","0.58338857","0.5832761","0.5804261","0.5803808","0.57744175","0.5755462","0.5754948","0.57470006","0.5722564","0.5707954","0.5704913","0.5694639","0.5609122","0.5601415","0.55768293","0.556893","0.55426854","0.5536171","0.5517594","0.5489994","0.5458909","0.5457085","0.5422828","0.54221654","0.5414593","0.54130596","0.53964347","0.53803694","0.5366187","0.5362144","0.5358248","0.5346385","0.5309946","0.53081924","0.5306183","0.5282719","0.52780885","0.5271509","0.5253488","0.5252767","0.5246927","0.52323854","0.5224555","0.52168226","0.5215213","0.521193","0.5209969","0.5206189","0.5187087","0.51803064","0.5173953","0.51705986","0.51682484","0.5149056","0.5149011","0.5142962","0.5134487","0.5130868","0.51293796","0.51283216","0.5118006","0.5114531","0.5091923","0.5070309","0.506654","0.5060644","0.50499016","0.5047768"],"string":"[\n \"0.8111784\",\n \"0.770102\",\n \"0.74282926\",\n \"0.72233987\",\n \"0.71631217\",\n \"0.7097246\",\n \"0.7082445\",\n \"0.696311\",\n \"0.692484\",\n \"0.6767896\",\n \"0.67418265\",\n \"0.66456175\",\n \"0.66020036\",\n \"0.64767134\",\n \"0.64665145\",\n \"0.64210325\",\n \"0.63494134\",\n \"0.6314577\",\n \"0.62687373\",\n \"0.6240669\",\n \"0.6233663\",\n \"0.6218351\",\n \"0.6175523\",\n \"0.6134979\",\n \"0.6127915\",\n \"0.611254\",\n \"0.5986515\",\n \"0.5926572\",\n \"0.58976483\",\n \"0.5886312\",\n \"0.5872859\",\n \"0.58338857\",\n \"0.58338857\",\n \"0.5832761\",\n \"0.5804261\",\n \"0.5803808\",\n \"0.57744175\",\n \"0.5755462\",\n \"0.5754948\",\n \"0.57470006\",\n \"0.5722564\",\n \"0.5707954\",\n \"0.5704913\",\n \"0.5694639\",\n \"0.5609122\",\n \"0.5601415\",\n \"0.55768293\",\n \"0.556893\",\n \"0.55426854\",\n \"0.5536171\",\n \"0.5517594\",\n \"0.5489994\",\n \"0.5458909\",\n \"0.5457085\",\n \"0.5422828\",\n \"0.54221654\",\n \"0.5414593\",\n \"0.54130596\",\n \"0.53964347\",\n \"0.53803694\",\n \"0.5366187\",\n \"0.5362144\",\n \"0.5358248\",\n \"0.5346385\",\n \"0.5309946\",\n \"0.53081924\",\n \"0.5306183\",\n \"0.5282719\",\n \"0.52780885\",\n \"0.5271509\",\n \"0.5253488\",\n \"0.5252767\",\n \"0.5246927\",\n \"0.52323854\",\n \"0.5224555\",\n \"0.52168226\",\n \"0.5215213\",\n \"0.521193\",\n \"0.5209969\",\n \"0.5206189\",\n \"0.5187087\",\n \"0.51803064\",\n \"0.5173953\",\n \"0.51705986\",\n \"0.51682484\",\n \"0.5149056\",\n \"0.5149011\",\n \"0.5142962\",\n \"0.5134487\",\n \"0.5130868\",\n \"0.51293796\",\n \"0.51283216\",\n \"0.5118006\",\n \"0.5114531\",\n \"0.5091923\",\n \"0.5070309\",\n \"0.506654\",\n \"0.5060644\",\n \"0.50499016\",\n \"0.5047768\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7956627"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":7299,"cells":{"query":{"kind":"string","value":"Creates the sum tree data structure for the given replay capacity."},"document":{"kind":"string","value":"def __init__(self, capacity):\n assert isinstance(capacity, int)\n if capacity <= 0:\n raise ValueError(\n 'Sum tree capacity should be positive. Got: {}'.format(capacity))\n\n self.nodes = []\n self.depth = int(np.ceil(np.log2(capacity)))\n self.low_idx = (2**self.depth) - 1 # pri_idx + low_idx -> tree_idx\n self.high_idx = capacity + self.low_idx\n self.nodes = np.zeros(2**(self.depth + 1) - 1) # Double precision.\n self.capacity = capacity\n\n self.highest_set = 0\n\n self.max_recorded_priority = 1.0"},"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 __init__(self, capacity, tuple, alpha=0.6, beta=0.4):\n self.tree = SumTree(capacity)\n self.capacity = capacity\n self.alpha = alpha\n self.beta = beta\n self.tuple = tuple","def __init__(self, memory_size, batch_size, alpha):\n self.tree = sum_tree.SumTree(memory_size)\n self.memory_size = memory_size\n self.batch_size = batch_size\n self.alpha = alpha","def __init__(self, capacity=100):\n \n self.capacity = capacity\n self.size = 0\n self._keys = []\n self._entry = [[] for _ in range(capacity)]","def __init__(self, capacity=4):\n self.capacity = capacity\n self.size = 0\n self.table = [None] * capacity","def __init__(self, capacity: int):\n self._pax_with_carry_on = PaxStack()\n self._pax_without_carry_on = PaxStack()\n self._capacity = capacity\n self._current_pax = 0","def __init__(self, capacity):\n self.capacity = capacity\n self.map = {}\n self.head = self.Node(0, 0)\n self.tail = self.Node(0, 0)\n self.head.next = self.tail\n self.tail.pre = self.head\n self.cnt = 0","def __init__(self, memory_size, alpha):\n self.tree = SumTree(memory_size)\n self.memory_size = memory_size\n self.alpha = alpha\n self.bonus_priority = 999 # add bonus priority for transitions that were never sampled\n self.epsilon_priority = 0.000001\n if self.alpha == 0: # revert to full uniform\n self.bonus_priority = 0","def __init__(self, capacity):\n self.experiences = RingBuf(capacity)","def __init__(self, size):\n self.size = size\n self.queue = []\n self.sum = 0","def __init__(self, size):\n\n self._root = Node()\n size_left = int(size/2)\n # Initialization of the tree\n self._root.left = self._createSubtree(self._root, 0, size_left) # [a,b[\n self._root.right = self._createSubtree(self._root, size_left, size)\n self._max_priority = 1","def __init__(self, capacity=4):\n self.capacity = capacity\n self.size = 0\n self.data = [None] * capacity\n self.head = 0\n self.tail = 0","def __init__(self, size: int):\n self.size = size\n self.queue = deque()\n self.widowSum = 0","def __init__(self, size):\n self.sum = 0\n self.nums = 0\n self.size = size\n self.deq = collections.deque()","def __init__(self, memory_size, batch_size, alpha, mu, seed):\n self.tree = SumTree(memory_size)\n self.memory_size = memory_size\n self.batch_size = batch_size\n self.alpha = alpha\n self.__e = 0.01\n self.__mu = mu\n np.random.seed(seed)","def __init__(self, size: int):\n self.size = size \n self.tracker = deque()\n self.sum = 0","def __init__(self, size):\n self.size = size\n self.queue = deque([])\n self.cur_sum = 0","def __init__ (self, size: int):\n self.size = size\n self.queue = []\n self.sum = 0","def __init__(self, capacity=2):\r\n self._capacity = capacity\r\n self._data = [0] * self._capacity\r\n self._size = 0","def nocache_create_equal_size_subtrees():\n N = len(self)\n subTrees = [set(range(i, N, numSubTrees)) for i in range(numSubTrees)]\n totalCost = N\n return subTrees, totalCost","def __init__(self, buffer_size, batch_size, random_seed=1234):\n self.tree = PER.sum_tree.SumTree(buffer_size)\n self.batch_size = batch_size\n self.s_prev, self.s_ori_prev, self.a_prev, self.r_prev = None, None, None, None\n\n # p_i = (p + e)^a\n self.e = 0.00000001\n self.a = 0.6 # values suggested by authors\n self.beta = 0.4 # to 1 - values suggested by authors\n\n self.previous_index = None # TODO\n self.prevQ_s_t_a_t_ = None\n random.seed(random_seed)","def __init__(self, capacity, initial):\n\t\tself.capacity = capacity\n\t\tself.amount = initial","def create_subtrees(maxCost, maxCostRate=0, costMetric=\"size\"):\n\n if costMetric == \"applys\":\n def cost_fn(rem): return len(rem) # length of remainder = #-apply ops needed\n elif costMetric == \"size\":\n def cost_fn(rem): return 1 # everything costs 1 in size of tree\n else: raise ValueError(\"Uknown cost metric: %s\" % costMetric)\n\n subTrees = []\n curSubTree = set([evalOrder[0]])\n curTreeCost = cost_fn(self[evalOrder[0]][1]) # remainder length of 0th evaluant\n totalCost = 0\n cacheIndices = [None] * self.cache_size()\n\n for k in evalOrder:\n iStart, remainder, iCache = self[k]\n\n if iCache is not None:\n cacheIndices[iCache] = k\n\n #compute the cost (additional #applies) which results from\n # adding this element to the current tree.\n cost = cost_fn(remainder)\n inds = set([k])\n\n if iStart is not None and cacheIndices[iStart] not in curSubTree:\n #we need to add the tree elements traversed by\n #following iStart\n j = iStart # index into cache\n while j is not None:\n iStr = cacheIndices[j] # cacheIndices[ iStart ]\n inds.add(iStr)\n cost += cost_fn(self[iStr][1]) # remainder\n j = self[iStr][0] # iStart\n\n if curTreeCost + cost < maxCost:\n #Just add current string to current tree\n curTreeCost += cost\n curSubTree.update(inds)\n else:\n #End the current tree and begin a new one\n #print(\"cost %d+%d exceeds %d\" % (curTreeCost,cost,maxCost))\n subTrees.append(curSubTree)\n curSubTree = set([k])\n\n cost = cost_fn(remainder); j = iStart\n while j is not None: # always traverse back iStart\n iStr = cacheIndices[j]\n curSubTree.add(iStr)\n cost += cost_fn(self[iStr][1]) # remainder\n j = self[iStr][0] # iStart\n totalCost += curTreeCost\n curTreeCost = cost\n #print(\"Added new tree w/initial cost %d\" % (cost))\n\n maxCost += maxCostRate\n\n subTrees.append(curSubTree)\n totalCost += curTreeCost\n return subTrees, totalCost","def create_subtrees(maxCost, maxCostRate=0, costMetric=\"size\"):\n\n if costMetric == \"applys\":\n def cost_fn(rem): return len(rem) # length of remainder = #-apply ops needed\n elif costMetric == \"size\":\n def cost_fn(rem): return 1 # everything costs 1 in size of tree\n else: raise ValueError(\"Uknown cost metric: %s\" % costMetric)\n\n subTrees = []\n curSubTree = set([evalOrder[0]])\n curTreeCost = cost_fn(self[evalOrder[0]][1]) # remainder length of 0th evaluant\n totalCost = 0\n cacheIndices = [None] * self.cache_size()\n\n for k in evalOrder:\n iStart, remainder, iCache = self[k]\n\n if iCache is not None:\n cacheIndices[iCache] = k\n\n #compute the cost (additional #applies) which results from\n # adding this element to the current tree.\n cost = cost_fn(remainder)\n inds = set([k])\n\n if iStart is not None and cacheIndices[iStart] not in curSubTree:\n #we need to add the tree elements traversed by\n #following iStart\n j = iStart # index into cache\n while j is not None:\n iStr = cacheIndices[j] # cacheIndices[ iStart ]\n inds.add(iStr)\n cost += cost_fn(self[iStr][1]) # remainder\n j = self[iStr][0] # iStart\n\n if curTreeCost + cost < maxCost:\n #Just add current string to current tree\n curTreeCost += cost\n curSubTree.update(inds)\n else:\n #End the current tree and begin a new one\n #print(\"cost %d+%d exceeds %d\" % (curTreeCost,cost,maxCost))\n subTrees.append(curSubTree)\n curSubTree = set([k])\n\n cost = cost_fn(remainder); j = iStart\n while j is not None: # always traverse back iStart\n iStr = cacheIndices[j]\n curSubTree.add(iStr)\n cost += cost_fn(self[iStr][1]) # remainder\n j = self[iStr][0] # iStart\n totalCost += curTreeCost\n curTreeCost = cost\n #print(\"Added new tree w/initial cost %d\" % (cost))\n\n maxCost += maxCostRate\n\n subTrees.append(curSubTree)\n totalCost += curTreeCost\n return subTrees, totalCost","def grow_tree(self):\n\n decision_node = self.root\n internal_env = copy.copy(self.env)\n\n while (not decision_node.is_final) and decision_node.visits > 1:\n\n a = self.select(decision_node)\n\n new_random_node = decision_node.next_random_node(a, self._hash_action)\n\n (new_decision_node, r) = self.select_outcome(internal_env, new_random_node)\n\n new_decision_node = self.update_decision_node(new_decision_node, new_random_node, self._hash_space)\n\n new_decision_node.reward = r\n new_random_node.reward = r\n\n decision_node = new_decision_node\n\n decision_node.visits += 1\n cumulative_reward = self.evaluate(internal_env)\n\n while not decision_node.is_root:\n random_node = decision_node.father\n cumulative_reward += random_node.reward\n random_node.cumulative_reward += cumulative_reward\n random_node.visits += 1\n decision_node = random_node.father\n decision_node.visits += 1","def __init__(self):\n self.root = RadixTreeNode()\n self.root.key = \"\"\n self.size = 0","def __init__(self):\n self.capacity = 10000\n self.table = [[] for _ in range(self.capacity)]","def __init__(self):\n self._size = 0\n self._array = [None] * BinaryTree.DEFAULT_CAPACITY","def __init__(self, capacity):\n self.memory = deque([], maxlen=capacity)","def __init__(self, size: int):\n self.__data = []\n for i in range(0, size):\n self.__data.append(self.Node(pre_index=i))","def __init__(self, size, alpha):\n super(PrioritizedReplayBuffer, self).__init__(size)\n assert alpha >= 0\n self._alpha = alpha\n\n it_capacity = 1\n while it_capacity < size:\n it_capacity *= 2\n\n self._it_sum = SumSegmentTree(it_capacity)\n self._it_min = MinSegmentTree(it_capacity)\n self._max_priority = 1.0","def __init__(self, capacity: int, function) -> None:\n self.buckets = DynamicArray()\n for _ in range(capacity):\n self.buckets.append(LinkedList())\n self.capacity = capacity\n self.hash_function = function\n self.size = 0","def __init__(self, capacity: int, storage_unit: str = \"timesteps\", **kwargs):\n super().__init__(capacity=capacity, storage_unit=\"timesteps\", **kwargs)\n self.replay_batches = []\n self.replay_index = 0","def __init__(self, capacity=10):\n\n self._board = [None] * capacity # list of 10 None elements\n self._n = 0 # number of actual entries","def __init__(self, buffer_size, batch_size, random_seed=1234):\n self.tree = PER.sum_tree.SumTree(buffer_size)\n self.batch_size = batch_size\n self.episode = []\n self.s_prev, self.s_ori_prev, self.a_prev, self.r_prev, self.v_prev, self.distribution, self.mask = \\\n None, None, None, None, None, None, None\n\n # p_i = (p + e)^a\n self.e = 0.00000001\n self.a = 0.6 # values suggested by authors\n self.beta = 0.4 # to 1 - values suggested by authors\n\n self.previous_index = None # TODO\n random.seed(random_seed)","def expand(self, policy):\n if self.children != {}: return\n actionWeights = policy(self.state)\n for action in actionWeights:\n succ = self.state.succ(self.state.player, action)\n self.children[action] = TreeNode(succ, actionWeights[action], self)","def __init__(self, capacity):\n self.capacity = capacity # Number of buckets in the hash table\n self.storage = [None] * capacity\n self.key_count = 0","def __init__(self, action_size, buffer_size, batch_size, buf_alpha, seed, device):\n\n self.action_size = action_size\n self.memory = []#deque(maxlen=buffer_size)\n self.buffer_size = buffer_size\n self.batch_size = batch_size\n self.next_ndx = 0\n\n assert buf_alpha >= 0\n self.alpha = buf_alpha\n #self.experience =namedtuple(\"Experience\", field_names=[\"state\", \"action\", \"reward\", \"next_state\", \"done\"])\n self.seed =random.seed(seed)\n self.device = device\n\n # Num of nodes of a tree, should be in orders of '2'\n iter_capacity = 1\n while iter_capacity < buffer_size:\n iter_capacity *= 2\n\n self.iter_sum = SumSegmentTree(iter_capacity)\n self.iter_min = MinSegmentTree(iter_capacity)\n self.max_p = 1.0","def __init__(self, parent):\r\n self.parent = parent[:]\r\n self.size = len(self.parent)\r\n self.children = {}\r\n self.data = {}\r\n for i in xrange(self.size):\r\n self.children[i] = []\r\n self.nchildren = [1] * self.size\r\n # iya\r\n for i in xrange(1, self.size):\r\n self.children[self.parent[i]].append(i)\r\n for i in xrange(self.size - 1, 0, -1):\r\n self.nchildren[self.parent[i]] += self.nchildren[i]","def __init__(self, size):\n self.size = size\n self.q = collections.deque()\n self.sum_ = 0","def __init__(self, size = 100):\n\t\tself.__parent = [i for i in range(size)]\n\t\tself.__rank = [0 for _ in range(size)]","def __init__(self, size: int):\n self.size = size\n self.queue = [0] * self.size # queue w/ len of size\n self.head = self.window_sum = 0\n self.count = 0","def knapsack(items, capacity):\r\n pass","def __init__(self, size):\n self.moveSize = size\n self.items = deque()\n self.sum = 0","def __init__(self, capacity, units=0):\n self.capacity = capacity\n self.units = units","def __init__(self, size: int, values: List[int]=None) -> int:\n self.tree = [el for el in values] if values else ([0] * (size + 1))\n self.size = (len(values)) if values else (size + 1)\n\n if values:\n for i in range(1, self.size):\n parent = i + self._lsb(i)\n if parent < self.size:\n self.tree[parent] += self.tree[i]","def __init__(self, size: int):\n self.q = deque()\n self.max_size = size\n self.sum = 0.0","def __init__(self, aggregation_depth, include_bytes=True):\n\n self._prev_stats = {}\n self._aggregation_depth = aggregation_depth\n self._include_bytes = include_bytes\n\n self.init_cur_stats()","def __init__(self):\n INIT_CAPACITY = 8\n LOAD_FACTOR = 2 / 3\n self.capacity = INIT_CAPACITY\n self.size = 0\n self.slots = [None] * INIT_CAPACITY\n self.load_factor = LOAD_FACTOR","def __init__(self, size: int):\n self.nums = deque()\n self.size = size \n self.rsm = 0","def build(self, block_size):","def __init__(self):\n Node.__init__(self)\n self.__counts = 0\n self.__children = dict()\n self.__children_counts = dict()","def __init__(self, size: int, alpha: float):\n super(PrioritizedReplayBuffer, self).__init__(size)\n assert alpha > 0\n self._alpha = alpha\n\n it_capacity = 1\n while it_capacity < size:\n it_capacity *= 2\n\n self._it_sum = SumSegmentTree(it_capacity)\n self._it_min = MinSegmentTree(it_capacity)\n self._max_priority = 1.0\n self._prio_change_stats = WindowStat(\"reprio\", 1000)","def __init__(self,size=100):\n self.__parent = [ i for i in range(size) ]\n self.__size = [ 1 for i in range(size) ]\n self.__rank = [ 0 for i in range(size) ]","def __init__(self, k):\n self.capacity = k\n self.head = None\n self.tail = None\n self.count = 0","def __init__(self, k: int):\n self.front = 0\n self.rear = 0\n self.capacity = k + 1\n self.arr = [0 for _ in range(self.capacity)]","def __init__(self, capacity, fillValue = None):\n \n self._items = list() \n self._fillValue = fillValue\n self._DEFAULT_CAPACITY = capacity\n self._logicalSize = 0 #as required by exercise 1\n \n \n for count in xrange(capacity):\n self._items.append(self._fillValue)","def resize(self, new_capacity):\n # Your code here\n self.capacity = new_capacity\n\n # make new array to store the current self.hash_table\n # update self.hash_table to be array of size new_capacity\n # for each item in our copy array\n # self.put(item) in our newly size self.hash_table\n # if item.next is not None\n # make sure to self.put(item.next) to get all chained nodes\n\n old_storage = self.hash_table\n self.hash_table = [None] * new_capacity\n\n for i, el in enumerate(old_storage):\n if el is not None:\n self.put(el.key, el.value)\n\n curr_node = el\n\n if curr_node is not None:\n # add all chained nodes\n while curr_node.next is not None:\n curr_node = curr_node.next\n if curr_node is not None:\n self.put(curr_node.key, curr_node.value)","def initial_population(self, size):\n return [self.target_tree] + \\\n [self.mutator.mutate(copy.deepcopy(self.target_tree))\n for i in range(size - 1)]","def __init__(self, capacity, fillValue=None):\r\n self._items = list()\r\n self._logicalSize = 0\r\n # Track the capacity and fill value for adjustments later\r\n self._capacity = capacity\r\n self._fillValue = fillValue\r\n for count in range(capacity):\r\n self._items.append(fillValue)","def update(self, probs: torch.Tensor):\n tree, capacity = self._create_tree(probs, self.tree)\n self.tree = tree\n self.capacity = capacity","def _gen_test_tree_4():\n tree = BinaryNode(5)\n tree.left = BinaryNode(3)\n tree.left.left = BinaryNode(2)\n tree.left.right = BinaryNode(10)\n tree.right = BinaryNode(9)\n tree.right.left = BinaryNode(6)\n tree.right.right = BinaryNode(8)\n return tree","def __init__(self, tree):\n self._tree = tree\n self._size = len(tree)\n\n self._tree.reindex()\n self._preprocess()","def __init__(self, estimated_nodes=0, estimated_edges=0, capacity_type=np.int32, jit_build=True):\n flow_type = capacity_type if np.issubdtype(capacity_type, np.floating) else np.int32\n super().__init__(\n estimated_nodes=estimated_nodes,\n estimated_edges=estimated_edges,\n flow_type=flow_type,\n capacity_type=capacity_type,\n arc_index_type=np.int64,\n node_index_type=np.int32,\n jit_build=jit_build,\n )","def __init__(self):\r\n self.bucket = []\r\n for i in range(4096):\r\n self.bucket.append(Node(0,0))","def __init__(self, state, parent, action, path_cost):\n self.state = state\n self.parent = parent\n self.action = action\n self.path_cost = path_cost\n self.depth = 0\n if parent:\n self.depth = parent.depth + 1","def create_binary_tree(depth=3):\n # The only node is root\n max_nodes, nodes = 2 ** depth - 1, 1\n queue = Queue()\n val = IntGenerator()\n root = Node(val=next(val))\n\n queue.enqueue(root)\n while nodes + 2 <= max_nodes:\n current = queue.dequeue()\n\n # Create child nodes until total num is le max_nodes\n # for specified length in binary tree\n if nodes + 2 <= max_nodes: # tree will have +2 nodes after creating children\n current.left = Node(val=next(val))\n current.right = Node(val=next(val))\n queue.enqueue(current.left)\n queue.enqueue(current.right)\n nodes += 2\n\n return root","def build(self):\n #print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))\n #print('self.IDs', self.data)\n self.itime = 0\n self.ielement = 0\n self.itotal = 0\n\n assert self.ntimes > 0, 'ntimes=%s' % self.ntimes\n assert self.nelements > 0, 'nelements=%s' % self.nelements\n assert self.ntotal > 0, 'ntotal=%s' % self.ntotal\n self.nelements //= self.ntimes\n\n dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size, self.analysis_fmt)\n self.node = np.zeros(self.ntotal, dtype=idtype)\n #lxa, lxb, lxc, lya, lyb, lyc, lza, lzb, lzc, sa, sb, sc, epr, ovm\n self.data = np.zeros((self.ntimes, self.ntotal, 14), dtype=fdtype)\n self.location = np.empty(self.ntotal, dtype='U8')\n\n self._times = np.zeros(self.ntimes, dtype=dtype)","def __init__(self, degree):\r\n self.root = Node([], [])\r\n self.min_num_keys = degree - 1 \r\n self.max_num_keys = 2*degree - 1","def __init__(self, k: int):\n self.capacity = k\n self.head = None\n self.tail = None\n self.count = 0","def build(self):\n #print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))\n #print('self.IDs', self.data)\n self.itime = 0\n self.ielement = 0\n self.itotal = 0\n\n assert self.ntimes > 0, 'ntimes=%s' % self.ntimes\n assert self.nelements > 0, 'nelements=%s' % self.nelements\n assert self.ntotal > 0, 'ntotal=%s' % self.ntotal\n #self.names = []\n self.nelements //= self.ntimes\n\n self.node = np.zeros(self.ntotal, dtype='int32')\n #oxx, oyy, ozz, txy, pressure\n self.data = np.zeros((self.ntimes, self.ntotal, 5), dtype='float32')\n self.location = np.empty(self.ntotal, dtype='U8')\n dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size, self.analysis_fmt)\n\n self._times = np.zeros(self.ntimes, dtype=dtype)","def heap_update(self):\n print 'SumTree pre-update:', self.replay.tree[0].sum\n last_ixs = self.replay.last_ixs(True)\n while True:\n if len(last_ixs) == 0:\n break\n if len(last_ixs) < 10000:\n ixs = last_ixs\n last_ixs = []\n else:\n ixs = last_ixs[:10000]\n last_ixs = last_ixs[10000:]\n batch = [self.replay.tree[ix].pointer for ix in ixs]\n delta = self.get_delta(batch)\n self.get_p_weights(delta, batch, ixs)\n print 'SumTree post-update:', self.replay.tree[0].sum\n print 'SumTree updated'","def __init__(self, k: int):\r\n self.capacity = k\r\n self.frontIndex = 0\r\n self.lastIndex = 1\r\n self.deque = [0] * self.capacity\r\n self.size = 0 # current size\r","def capacity_enlarge(self, k):\n count = 0\n idx = self.capacity - 1\n while count < k:\n left = self.tree[idx]\n right = priorityNode(0, None)\n insert_pos = self.tree.shape[0]\n self.tree = np.insert(self.tree, insert_pos, [left,right])\n idx += 1\n count += 1\n\n self.last_capacity = self.capacity # mark down the last capacity for adding operation\n self.capacity += k # Update the value of capacity","def __init__(self):\n self.memory = {}\n self.sum_ = {}","def _new_node(self):\n self._size += 1\n return self._node_factory()","def __init__(self, max_node_capacity=16):\n assert isinstance(max_node_capacity, int)\n assert max_node_capacity > 0\n self.max_node_capacity = max_node_capacity\n self.length = 0\n self.head = None\n self.tail = None","def __init__(self, affinity, game_type, game_space, search_depth, opponent=None):\n\n super().__init__(affinity, game_type, game_space, opponent)\n self.__search_depth = search_depth\n self.nodes_expanded = 0","def __init__(self, affinity, game_type, game_space, search_depth, opponent=None):\n\n super().__init__(affinity, game_type, game_space, opponent)\n self.__search_depth = search_depth\n self.nodes_expanded = 0","def _grow(self):\n self.capacity *= self.factor\n temp = [None] * self.capacity\n for i in range(self.size):\n temp[i] = self.store[i]\n self.store = temp","def _dfs_assign(self, filetree):\n stack = [filetree]\n while stack:\n node = stack.pop()\n if isinstance(node, tuple) and node[0][\"packmode\"] is None:\n # all children have been seen already, assing packmode\n node = node[0] # unpack the actual node\n weights = defaultdict(int)\n for child in node[\"children\"].values():\n weights[child[\"packmode\"]] += child[\"weight\"]\n packmode, weight = max(weights.items(), key=lambda x: x[1])\n node[\"weight\"] = weight\n node[\"packmode\"] = packmode\n elif node[\"children\"]:\n # schedule that node for computation\n stack.append((node,))\n # visit all children first\n for child in node[\"children\"].values():\n stack.append(child)","def __init__(self, k):\n self.queue = [0]*k\n self.headIndex = 0\n self.count = 0\n self.capacity = k","def _make_array(self, capacity):\n return (capacity * ctypes.py_object)()","def new_capacity_rule(mod, prj, prd):\n return 0","def _gen_test_tree_6():\n tree = BinaryNode(20)\n tree.left = BinaryNode(10)\n tree.right = BinaryNode(30)\n tree.left.right = BinaryNode(25)\n return tree","def _gen_test_tree_5():\n tree = BinaryNode(30)\n tree.right = BinaryNode(30)\n return tree","def __init__(self):\n self._root = None\n self._size = 0\n self._my_hash = {'preorder':self.preorder, 'postorder': self.postorder, 'inorder': self.inorder,\n \"breadthfirst\": self.breadthfirst}","def grow(self):\n self.capacity = self.capacity * 2\n self.rehash()","def __init__(self, capacity):\n self.capacity = capacity #this is example for list implementation\n self.head = [None] * capacity #this is example for list implementation\n self.num_items = 0 #this is example for list implementation","def _build_replay_buffer(self):\n return prioritized_replay_buffer.OutOfGraphPrioritizedReplayBuffer(\n observation_shape=self.observation_shape,\n stack_size=self.stack_size,\n update_horizon=self.update_horizon,\n gamma=self.gamma,\n observation_dtype=self.observation_dtype)","def fullIntroduceNew (self, networkSize, numNodes, time) :\n\t\tnodeList = self.createNodes(networkSize)\n\t\tself.addAppRecordDiff(nodeList)\n\t\tsessionInfo = self.sessionsFull(nodeList)\n\t\ttotal = 0\n\t\twhile self.endConditionData(nodeList) :\n\t\t\tif total == time :\n\t\t\t\tfor i in range(networkSize, networkSize + numNodes):\n\t\t\t\t\tnode = Node(str(i))\n\t\t\t\t\tnodeList.append(node)\n\t\t\t\t\tnode.addAppData(\"record\"+str(i),\"data\" + str(i), Node.ALL, Node.ALL )\n \t\t\tnode.serialize((Node.ALL, Node.ALL))\n\t\t\t\t\tsessionInfo = self.sessionsFull(nodeList)\n\t\t\tindex = random.randint(0, len(sessionInfo)-1)\n\t\t\tclient = sessionInfo[index][0]\n\t\t\tserver = sessionInfo[index][1]\n\t\t\tself.fullDBReplication(nodeList[client], sessionInfo[index][2])\n\t\t\ttotal = total + 1\n\t\treturn total","def __init__(self):\n self._root = None\n self._size = 0\n self._curr_idx = 0\n self._depths, self._heights = None, None","def __init__(self):\n self._root = None\n self._size = 0","def __init__(self):\n self._root = None\n self._size = 0","def __init__(self):\n self._root = None\n self._size = 0","def __init__(self):\n self._root = None\n self._size = 0","def __init__(self):\n self._root = None\n self._size = 0","def build(self):\n #print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))\n #print('self.IDs', self.data)\n self.itime = 0\n self.ielement = 0\n self.itotal = 0\n\n assert self.ntimes > 0, 'ntimes=%s' % self.ntimes\n assert self.nelements > 0, 'nelements=%s' % self.nelements\n assert self.ntotal > 0, 'ntotal=%s' % self.ntotal\n self.nelements //= self.ntimes\n\n dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size, self.analysis_fmt)\n self.node = np.zeros(self.ntotal, dtype=idtype)\n #oxx, oyy, txy, angle, major, minor, ovm\n self.data = np.zeros((self.ntimes, self.ntotal, 8), dtype=fdtype)\n self.location = np.empty(self.ntotal, dtype='U8')\n self._times = np.zeros(self.ntimes, dtype=dtype)","def __init__(self, k: int):\n self.queue = [0]*k\n self.headIndex = 0\n self.count = 0\n self.capacity = k","def __init__(self, state, parent=None, action=None, path_cost=0):\n self.state = state\n self.parent = parent\n self.action = action\n self.path_cost = path_cost\n self.depth = 0\n if parent:\n self.depth = parent.depth + 1","def __init__(self, initial, costfn=lambda node: node.path_cost):\n self.heap = []\n self.states = {}\n self.costfn = costfn\n self.add(initial)"],"string":"[\n \"def __init__(self, capacity, tuple, alpha=0.6, beta=0.4):\\n self.tree = SumTree(capacity)\\n self.capacity = capacity\\n self.alpha = alpha\\n self.beta = beta\\n self.tuple = tuple\",\n \"def __init__(self, memory_size, batch_size, alpha):\\n self.tree = sum_tree.SumTree(memory_size)\\n self.memory_size = memory_size\\n self.batch_size = batch_size\\n self.alpha = alpha\",\n \"def __init__(self, capacity=100):\\n \\n self.capacity = capacity\\n self.size = 0\\n self._keys = []\\n self._entry = [[] for _ in range(capacity)]\",\n \"def __init__(self, capacity=4):\\n self.capacity = capacity\\n self.size = 0\\n self.table = [None] * capacity\",\n \"def __init__(self, capacity: int):\\n self._pax_with_carry_on = PaxStack()\\n self._pax_without_carry_on = PaxStack()\\n self._capacity = capacity\\n self._current_pax = 0\",\n \"def __init__(self, capacity):\\n self.capacity = capacity\\n self.map = {}\\n self.head = self.Node(0, 0)\\n self.tail = self.Node(0, 0)\\n self.head.next = self.tail\\n self.tail.pre = self.head\\n self.cnt = 0\",\n \"def __init__(self, memory_size, alpha):\\n self.tree = SumTree(memory_size)\\n self.memory_size = memory_size\\n self.alpha = alpha\\n self.bonus_priority = 999 # add bonus priority for transitions that were never sampled\\n self.epsilon_priority = 0.000001\\n if self.alpha == 0: # revert to full uniform\\n self.bonus_priority = 0\",\n \"def __init__(self, capacity):\\n self.experiences = RingBuf(capacity)\",\n \"def __init__(self, size):\\n self.size = size\\n self.queue = []\\n self.sum = 0\",\n \"def __init__(self, size):\\n\\n self._root = Node()\\n size_left = int(size/2)\\n # Initialization of the tree\\n self._root.left = self._createSubtree(self._root, 0, size_left) # [a,b[\\n self._root.right = self._createSubtree(self._root, size_left, size)\\n self._max_priority = 1\",\n \"def __init__(self, capacity=4):\\n self.capacity = capacity\\n self.size = 0\\n self.data = [None] * capacity\\n self.head = 0\\n self.tail = 0\",\n \"def __init__(self, size: int):\\n self.size = size\\n self.queue = deque()\\n self.widowSum = 0\",\n \"def __init__(self, size):\\n self.sum = 0\\n self.nums = 0\\n self.size = size\\n self.deq = collections.deque()\",\n \"def __init__(self, memory_size, batch_size, alpha, mu, seed):\\n self.tree = SumTree(memory_size)\\n self.memory_size = memory_size\\n self.batch_size = batch_size\\n self.alpha = alpha\\n self.__e = 0.01\\n self.__mu = mu\\n np.random.seed(seed)\",\n \"def __init__(self, size: int):\\n self.size = size \\n self.tracker = deque()\\n self.sum = 0\",\n \"def __init__(self, size):\\n self.size = size\\n self.queue = deque([])\\n self.cur_sum = 0\",\n \"def __init__ (self, size: int):\\n self.size = size\\n self.queue = []\\n self.sum = 0\",\n \"def __init__(self, capacity=2):\\r\\n self._capacity = capacity\\r\\n self._data = [0] * self._capacity\\r\\n self._size = 0\",\n \"def nocache_create_equal_size_subtrees():\\n N = len(self)\\n subTrees = [set(range(i, N, numSubTrees)) for i in range(numSubTrees)]\\n totalCost = N\\n return subTrees, totalCost\",\n \"def __init__(self, buffer_size, batch_size, random_seed=1234):\\n self.tree = PER.sum_tree.SumTree(buffer_size)\\n self.batch_size = batch_size\\n self.s_prev, self.s_ori_prev, self.a_prev, self.r_prev = None, None, None, None\\n\\n # p_i = (p + e)^a\\n self.e = 0.00000001\\n self.a = 0.6 # values suggested by authors\\n self.beta = 0.4 # to 1 - values suggested by authors\\n\\n self.previous_index = None # TODO\\n self.prevQ_s_t_a_t_ = None\\n random.seed(random_seed)\",\n \"def __init__(self, capacity, initial):\\n\\t\\tself.capacity = capacity\\n\\t\\tself.amount = initial\",\n \"def create_subtrees(maxCost, maxCostRate=0, costMetric=\\\"size\\\"):\\n\\n if costMetric == \\\"applys\\\":\\n def cost_fn(rem): return len(rem) # length of remainder = #-apply ops needed\\n elif costMetric == \\\"size\\\":\\n def cost_fn(rem): return 1 # everything costs 1 in size of tree\\n else: raise ValueError(\\\"Uknown cost metric: %s\\\" % costMetric)\\n\\n subTrees = []\\n curSubTree = set([evalOrder[0]])\\n curTreeCost = cost_fn(self[evalOrder[0]][1]) # remainder length of 0th evaluant\\n totalCost = 0\\n cacheIndices = [None] * self.cache_size()\\n\\n for k in evalOrder:\\n iStart, remainder, iCache = self[k]\\n\\n if iCache is not None:\\n cacheIndices[iCache] = k\\n\\n #compute the cost (additional #applies) which results from\\n # adding this element to the current tree.\\n cost = cost_fn(remainder)\\n inds = set([k])\\n\\n if iStart is not None and cacheIndices[iStart] not in curSubTree:\\n #we need to add the tree elements traversed by\\n #following iStart\\n j = iStart # index into cache\\n while j is not None:\\n iStr = cacheIndices[j] # cacheIndices[ iStart ]\\n inds.add(iStr)\\n cost += cost_fn(self[iStr][1]) # remainder\\n j = self[iStr][0] # iStart\\n\\n if curTreeCost + cost < maxCost:\\n #Just add current string to current tree\\n curTreeCost += cost\\n curSubTree.update(inds)\\n else:\\n #End the current tree and begin a new one\\n #print(\\\"cost %d+%d exceeds %d\\\" % (curTreeCost,cost,maxCost))\\n subTrees.append(curSubTree)\\n curSubTree = set([k])\\n\\n cost = cost_fn(remainder); j = iStart\\n while j is not None: # always traverse back iStart\\n iStr = cacheIndices[j]\\n curSubTree.add(iStr)\\n cost += cost_fn(self[iStr][1]) # remainder\\n j = self[iStr][0] # iStart\\n totalCost += curTreeCost\\n curTreeCost = cost\\n #print(\\\"Added new tree w/initial cost %d\\\" % (cost))\\n\\n maxCost += maxCostRate\\n\\n subTrees.append(curSubTree)\\n totalCost += curTreeCost\\n return subTrees, totalCost\",\n \"def create_subtrees(maxCost, maxCostRate=0, costMetric=\\\"size\\\"):\\n\\n if costMetric == \\\"applys\\\":\\n def cost_fn(rem): return len(rem) # length of remainder = #-apply ops needed\\n elif costMetric == \\\"size\\\":\\n def cost_fn(rem): return 1 # everything costs 1 in size of tree\\n else: raise ValueError(\\\"Uknown cost metric: %s\\\" % costMetric)\\n\\n subTrees = []\\n curSubTree = set([evalOrder[0]])\\n curTreeCost = cost_fn(self[evalOrder[0]][1]) # remainder length of 0th evaluant\\n totalCost = 0\\n cacheIndices = [None] * self.cache_size()\\n\\n for k in evalOrder:\\n iStart, remainder, iCache = self[k]\\n\\n if iCache is not None:\\n cacheIndices[iCache] = k\\n\\n #compute the cost (additional #applies) which results from\\n # adding this element to the current tree.\\n cost = cost_fn(remainder)\\n inds = set([k])\\n\\n if iStart is not None and cacheIndices[iStart] not in curSubTree:\\n #we need to add the tree elements traversed by\\n #following iStart\\n j = iStart # index into cache\\n while j is not None:\\n iStr = cacheIndices[j] # cacheIndices[ iStart ]\\n inds.add(iStr)\\n cost += cost_fn(self[iStr][1]) # remainder\\n j = self[iStr][0] # iStart\\n\\n if curTreeCost + cost < maxCost:\\n #Just add current string to current tree\\n curTreeCost += cost\\n curSubTree.update(inds)\\n else:\\n #End the current tree and begin a new one\\n #print(\\\"cost %d+%d exceeds %d\\\" % (curTreeCost,cost,maxCost))\\n subTrees.append(curSubTree)\\n curSubTree = set([k])\\n\\n cost = cost_fn(remainder); j = iStart\\n while j is not None: # always traverse back iStart\\n iStr = cacheIndices[j]\\n curSubTree.add(iStr)\\n cost += cost_fn(self[iStr][1]) # remainder\\n j = self[iStr][0] # iStart\\n totalCost += curTreeCost\\n curTreeCost = cost\\n #print(\\\"Added new tree w/initial cost %d\\\" % (cost))\\n\\n maxCost += maxCostRate\\n\\n subTrees.append(curSubTree)\\n totalCost += curTreeCost\\n return subTrees, totalCost\",\n \"def grow_tree(self):\\n\\n decision_node = self.root\\n internal_env = copy.copy(self.env)\\n\\n while (not decision_node.is_final) and decision_node.visits > 1:\\n\\n a = self.select(decision_node)\\n\\n new_random_node = decision_node.next_random_node(a, self._hash_action)\\n\\n (new_decision_node, r) = self.select_outcome(internal_env, new_random_node)\\n\\n new_decision_node = self.update_decision_node(new_decision_node, new_random_node, self._hash_space)\\n\\n new_decision_node.reward = r\\n new_random_node.reward = r\\n\\n decision_node = new_decision_node\\n\\n decision_node.visits += 1\\n cumulative_reward = self.evaluate(internal_env)\\n\\n while not decision_node.is_root:\\n random_node = decision_node.father\\n cumulative_reward += random_node.reward\\n random_node.cumulative_reward += cumulative_reward\\n random_node.visits += 1\\n decision_node = random_node.father\\n decision_node.visits += 1\",\n \"def __init__(self):\\n self.root = RadixTreeNode()\\n self.root.key = \\\"\\\"\\n self.size = 0\",\n \"def __init__(self):\\n self.capacity = 10000\\n self.table = [[] for _ in range(self.capacity)]\",\n \"def __init__(self):\\n self._size = 0\\n self._array = [None] * BinaryTree.DEFAULT_CAPACITY\",\n \"def __init__(self, capacity):\\n self.memory = deque([], maxlen=capacity)\",\n \"def __init__(self, size: int):\\n self.__data = []\\n for i in range(0, size):\\n self.__data.append(self.Node(pre_index=i))\",\n \"def __init__(self, size, alpha):\\n super(PrioritizedReplayBuffer, self).__init__(size)\\n assert alpha >= 0\\n self._alpha = alpha\\n\\n it_capacity = 1\\n while it_capacity < size:\\n it_capacity *= 2\\n\\n self._it_sum = SumSegmentTree(it_capacity)\\n self._it_min = MinSegmentTree(it_capacity)\\n self._max_priority = 1.0\",\n \"def __init__(self, capacity: int, function) -> None:\\n self.buckets = DynamicArray()\\n for _ in range(capacity):\\n self.buckets.append(LinkedList())\\n self.capacity = capacity\\n self.hash_function = function\\n self.size = 0\",\n \"def __init__(self, capacity: int, storage_unit: str = \\\"timesteps\\\", **kwargs):\\n super().__init__(capacity=capacity, storage_unit=\\\"timesteps\\\", **kwargs)\\n self.replay_batches = []\\n self.replay_index = 0\",\n \"def __init__(self, capacity=10):\\n\\n self._board = [None] * capacity # list of 10 None elements\\n self._n = 0 # number of actual entries\",\n \"def __init__(self, buffer_size, batch_size, random_seed=1234):\\n self.tree = PER.sum_tree.SumTree(buffer_size)\\n self.batch_size = batch_size\\n self.episode = []\\n self.s_prev, self.s_ori_prev, self.a_prev, self.r_prev, self.v_prev, self.distribution, self.mask = \\\\\\n None, None, None, None, None, None, None\\n\\n # p_i = (p + e)^a\\n self.e = 0.00000001\\n self.a = 0.6 # values suggested by authors\\n self.beta = 0.4 # to 1 - values suggested by authors\\n\\n self.previous_index = None # TODO\\n random.seed(random_seed)\",\n \"def expand(self, policy):\\n if self.children != {}: return\\n actionWeights = policy(self.state)\\n for action in actionWeights:\\n succ = self.state.succ(self.state.player, action)\\n self.children[action] = TreeNode(succ, actionWeights[action], self)\",\n \"def __init__(self, capacity):\\n self.capacity = capacity # Number of buckets in the hash table\\n self.storage = [None] * capacity\\n self.key_count = 0\",\n \"def __init__(self, action_size, buffer_size, batch_size, buf_alpha, seed, device):\\n\\n self.action_size = action_size\\n self.memory = []#deque(maxlen=buffer_size)\\n self.buffer_size = buffer_size\\n self.batch_size = batch_size\\n self.next_ndx = 0\\n\\n assert buf_alpha >= 0\\n self.alpha = buf_alpha\\n #self.experience =namedtuple(\\\"Experience\\\", field_names=[\\\"state\\\", \\\"action\\\", \\\"reward\\\", \\\"next_state\\\", \\\"done\\\"])\\n self.seed =random.seed(seed)\\n self.device = device\\n\\n # Num of nodes of a tree, should be in orders of '2'\\n iter_capacity = 1\\n while iter_capacity < buffer_size:\\n iter_capacity *= 2\\n\\n self.iter_sum = SumSegmentTree(iter_capacity)\\n self.iter_min = MinSegmentTree(iter_capacity)\\n self.max_p = 1.0\",\n \"def __init__(self, parent):\\r\\n self.parent = parent[:]\\r\\n self.size = len(self.parent)\\r\\n self.children = {}\\r\\n self.data = {}\\r\\n for i in xrange(self.size):\\r\\n self.children[i] = []\\r\\n self.nchildren = [1] * self.size\\r\\n # iya\\r\\n for i in xrange(1, self.size):\\r\\n self.children[self.parent[i]].append(i)\\r\\n for i in xrange(self.size - 1, 0, -1):\\r\\n self.nchildren[self.parent[i]] += self.nchildren[i]\",\n \"def __init__(self, size):\\n self.size = size\\n self.q = collections.deque()\\n self.sum_ = 0\",\n \"def __init__(self, size = 100):\\n\\t\\tself.__parent = [i for i in range(size)]\\n\\t\\tself.__rank = [0 for _ in range(size)]\",\n \"def __init__(self, size: int):\\n self.size = size\\n self.queue = [0] * self.size # queue w/ len of size\\n self.head = self.window_sum = 0\\n self.count = 0\",\n \"def knapsack(items, capacity):\\r\\n pass\",\n \"def __init__(self, size):\\n self.moveSize = size\\n self.items = deque()\\n self.sum = 0\",\n \"def __init__(self, capacity, units=0):\\n self.capacity = capacity\\n self.units = units\",\n \"def __init__(self, size: int, values: List[int]=None) -> int:\\n self.tree = [el for el in values] if values else ([0] * (size + 1))\\n self.size = (len(values)) if values else (size + 1)\\n\\n if values:\\n for i in range(1, self.size):\\n parent = i + self._lsb(i)\\n if parent < self.size:\\n self.tree[parent] += self.tree[i]\",\n \"def __init__(self, size: int):\\n self.q = deque()\\n self.max_size = size\\n self.sum = 0.0\",\n \"def __init__(self, aggregation_depth, include_bytes=True):\\n\\n self._prev_stats = {}\\n self._aggregation_depth = aggregation_depth\\n self._include_bytes = include_bytes\\n\\n self.init_cur_stats()\",\n \"def __init__(self):\\n INIT_CAPACITY = 8\\n LOAD_FACTOR = 2 / 3\\n self.capacity = INIT_CAPACITY\\n self.size = 0\\n self.slots = [None] * INIT_CAPACITY\\n self.load_factor = LOAD_FACTOR\",\n \"def __init__(self, size: int):\\n self.nums = deque()\\n self.size = size \\n self.rsm = 0\",\n \"def build(self, block_size):\",\n \"def __init__(self):\\n Node.__init__(self)\\n self.__counts = 0\\n self.__children = dict()\\n self.__children_counts = dict()\",\n \"def __init__(self, size: int, alpha: float):\\n super(PrioritizedReplayBuffer, self).__init__(size)\\n assert alpha > 0\\n self._alpha = alpha\\n\\n it_capacity = 1\\n while it_capacity < size:\\n it_capacity *= 2\\n\\n self._it_sum = SumSegmentTree(it_capacity)\\n self._it_min = MinSegmentTree(it_capacity)\\n self._max_priority = 1.0\\n self._prio_change_stats = WindowStat(\\\"reprio\\\", 1000)\",\n \"def __init__(self,size=100):\\n self.__parent = [ i for i in range(size) ]\\n self.__size = [ 1 for i in range(size) ]\\n self.__rank = [ 0 for i in range(size) ]\",\n \"def __init__(self, k):\\n self.capacity = k\\n self.head = None\\n self.tail = None\\n self.count = 0\",\n \"def __init__(self, k: int):\\n self.front = 0\\n self.rear = 0\\n self.capacity = k + 1\\n self.arr = [0 for _ in range(self.capacity)]\",\n \"def __init__(self, capacity, fillValue = None):\\n \\n self._items = list() \\n self._fillValue = fillValue\\n self._DEFAULT_CAPACITY = capacity\\n self._logicalSize = 0 #as required by exercise 1\\n \\n \\n for count in xrange(capacity):\\n self._items.append(self._fillValue)\",\n \"def resize(self, new_capacity):\\n # Your code here\\n self.capacity = new_capacity\\n\\n # make new array to store the current self.hash_table\\n # update self.hash_table to be array of size new_capacity\\n # for each item in our copy array\\n # self.put(item) in our newly size self.hash_table\\n # if item.next is not None\\n # make sure to self.put(item.next) to get all chained nodes\\n\\n old_storage = self.hash_table\\n self.hash_table = [None] * new_capacity\\n\\n for i, el in enumerate(old_storage):\\n if el is not None:\\n self.put(el.key, el.value)\\n\\n curr_node = el\\n\\n if curr_node is not None:\\n # add all chained nodes\\n while curr_node.next is not None:\\n curr_node = curr_node.next\\n if curr_node is not None:\\n self.put(curr_node.key, curr_node.value)\",\n \"def initial_population(self, size):\\n return [self.target_tree] + \\\\\\n [self.mutator.mutate(copy.deepcopy(self.target_tree))\\n for i in range(size - 1)]\",\n \"def __init__(self, capacity, fillValue=None):\\r\\n self._items = list()\\r\\n self._logicalSize = 0\\r\\n # Track the capacity and fill value for adjustments later\\r\\n self._capacity = capacity\\r\\n self._fillValue = fillValue\\r\\n for count in range(capacity):\\r\\n self._items.append(fillValue)\",\n \"def update(self, probs: torch.Tensor):\\n tree, capacity = self._create_tree(probs, self.tree)\\n self.tree = tree\\n self.capacity = capacity\",\n \"def _gen_test_tree_4():\\n tree = BinaryNode(5)\\n tree.left = BinaryNode(3)\\n tree.left.left = BinaryNode(2)\\n tree.left.right = BinaryNode(10)\\n tree.right = BinaryNode(9)\\n tree.right.left = BinaryNode(6)\\n tree.right.right = BinaryNode(8)\\n return tree\",\n \"def __init__(self, tree):\\n self._tree = tree\\n self._size = len(tree)\\n\\n self._tree.reindex()\\n self._preprocess()\",\n \"def __init__(self, estimated_nodes=0, estimated_edges=0, capacity_type=np.int32, jit_build=True):\\n flow_type = capacity_type if np.issubdtype(capacity_type, np.floating) else np.int32\\n super().__init__(\\n estimated_nodes=estimated_nodes,\\n estimated_edges=estimated_edges,\\n flow_type=flow_type,\\n capacity_type=capacity_type,\\n arc_index_type=np.int64,\\n node_index_type=np.int32,\\n jit_build=jit_build,\\n )\",\n \"def __init__(self):\\r\\n self.bucket = []\\r\\n for i in range(4096):\\r\\n self.bucket.append(Node(0,0))\",\n \"def __init__(self, state, parent, action, path_cost):\\n self.state = state\\n self.parent = parent\\n self.action = action\\n self.path_cost = path_cost\\n self.depth = 0\\n if parent:\\n self.depth = parent.depth + 1\",\n \"def create_binary_tree(depth=3):\\n # The only node is root\\n max_nodes, nodes = 2 ** depth - 1, 1\\n queue = Queue()\\n val = IntGenerator()\\n root = Node(val=next(val))\\n\\n queue.enqueue(root)\\n while nodes + 2 <= max_nodes:\\n current = queue.dequeue()\\n\\n # Create child nodes until total num is le max_nodes\\n # for specified length in binary tree\\n if nodes + 2 <= max_nodes: # tree will have +2 nodes after creating children\\n current.left = Node(val=next(val))\\n current.right = Node(val=next(val))\\n queue.enqueue(current.left)\\n queue.enqueue(current.right)\\n nodes += 2\\n\\n return root\",\n \"def build(self):\\n #print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))\\n #print('self.IDs', self.data)\\n self.itime = 0\\n self.ielement = 0\\n self.itotal = 0\\n\\n assert self.ntimes > 0, 'ntimes=%s' % self.ntimes\\n assert self.nelements > 0, 'nelements=%s' % self.nelements\\n assert self.ntotal > 0, 'ntotal=%s' % self.ntotal\\n self.nelements //= self.ntimes\\n\\n dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size, self.analysis_fmt)\\n self.node = np.zeros(self.ntotal, dtype=idtype)\\n #lxa, lxb, lxc, lya, lyb, lyc, lza, lzb, lzc, sa, sb, sc, epr, ovm\\n self.data = np.zeros((self.ntimes, self.ntotal, 14), dtype=fdtype)\\n self.location = np.empty(self.ntotal, dtype='U8')\\n\\n self._times = np.zeros(self.ntimes, dtype=dtype)\",\n \"def __init__(self, degree):\\r\\n self.root = Node([], [])\\r\\n self.min_num_keys = degree - 1 \\r\\n self.max_num_keys = 2*degree - 1\",\n \"def __init__(self, k: int):\\n self.capacity = k\\n self.head = None\\n self.tail = None\\n self.count = 0\",\n \"def build(self):\\n #print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))\\n #print('self.IDs', self.data)\\n self.itime = 0\\n self.ielement = 0\\n self.itotal = 0\\n\\n assert self.ntimes > 0, 'ntimes=%s' % self.ntimes\\n assert self.nelements > 0, 'nelements=%s' % self.nelements\\n assert self.ntotal > 0, 'ntotal=%s' % self.ntotal\\n #self.names = []\\n self.nelements //= self.ntimes\\n\\n self.node = np.zeros(self.ntotal, dtype='int32')\\n #oxx, oyy, ozz, txy, pressure\\n self.data = np.zeros((self.ntimes, self.ntotal, 5), dtype='float32')\\n self.location = np.empty(self.ntotal, dtype='U8')\\n dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size, self.analysis_fmt)\\n\\n self._times = np.zeros(self.ntimes, dtype=dtype)\",\n \"def heap_update(self):\\n print 'SumTree pre-update:', self.replay.tree[0].sum\\n last_ixs = self.replay.last_ixs(True)\\n while True:\\n if len(last_ixs) == 0:\\n break\\n if len(last_ixs) < 10000:\\n ixs = last_ixs\\n last_ixs = []\\n else:\\n ixs = last_ixs[:10000]\\n last_ixs = last_ixs[10000:]\\n batch = [self.replay.tree[ix].pointer for ix in ixs]\\n delta = self.get_delta(batch)\\n self.get_p_weights(delta, batch, ixs)\\n print 'SumTree post-update:', self.replay.tree[0].sum\\n print 'SumTree updated'\",\n \"def __init__(self, k: int):\\r\\n self.capacity = k\\r\\n self.frontIndex = 0\\r\\n self.lastIndex = 1\\r\\n self.deque = [0] * self.capacity\\r\\n self.size = 0 # current size\\r\",\n \"def capacity_enlarge(self, k):\\n count = 0\\n idx = self.capacity - 1\\n while count < k:\\n left = self.tree[idx]\\n right = priorityNode(0, None)\\n insert_pos = self.tree.shape[0]\\n self.tree = np.insert(self.tree, insert_pos, [left,right])\\n idx += 1\\n count += 1\\n\\n self.last_capacity = self.capacity # mark down the last capacity for adding operation\\n self.capacity += k # Update the value of capacity\",\n \"def __init__(self):\\n self.memory = {}\\n self.sum_ = {}\",\n \"def _new_node(self):\\n self._size += 1\\n return self._node_factory()\",\n \"def __init__(self, max_node_capacity=16):\\n assert isinstance(max_node_capacity, int)\\n assert max_node_capacity > 0\\n self.max_node_capacity = max_node_capacity\\n self.length = 0\\n self.head = None\\n self.tail = None\",\n \"def __init__(self, affinity, game_type, game_space, search_depth, opponent=None):\\n\\n super().__init__(affinity, game_type, game_space, opponent)\\n self.__search_depth = search_depth\\n self.nodes_expanded = 0\",\n \"def __init__(self, affinity, game_type, game_space, search_depth, opponent=None):\\n\\n super().__init__(affinity, game_type, game_space, opponent)\\n self.__search_depth = search_depth\\n self.nodes_expanded = 0\",\n \"def _grow(self):\\n self.capacity *= self.factor\\n temp = [None] * self.capacity\\n for i in range(self.size):\\n temp[i] = self.store[i]\\n self.store = temp\",\n \"def _dfs_assign(self, filetree):\\n stack = [filetree]\\n while stack:\\n node = stack.pop()\\n if isinstance(node, tuple) and node[0][\\\"packmode\\\"] is None:\\n # all children have been seen already, assing packmode\\n node = node[0] # unpack the actual node\\n weights = defaultdict(int)\\n for child in node[\\\"children\\\"].values():\\n weights[child[\\\"packmode\\\"]] += child[\\\"weight\\\"]\\n packmode, weight = max(weights.items(), key=lambda x: x[1])\\n node[\\\"weight\\\"] = weight\\n node[\\\"packmode\\\"] = packmode\\n elif node[\\\"children\\\"]:\\n # schedule that node for computation\\n stack.append((node,))\\n # visit all children first\\n for child in node[\\\"children\\\"].values():\\n stack.append(child)\",\n \"def __init__(self, k):\\n self.queue = [0]*k\\n self.headIndex = 0\\n self.count = 0\\n self.capacity = k\",\n \"def _make_array(self, capacity):\\n return (capacity * ctypes.py_object)()\",\n \"def new_capacity_rule(mod, prj, prd):\\n return 0\",\n \"def _gen_test_tree_6():\\n tree = BinaryNode(20)\\n tree.left = BinaryNode(10)\\n tree.right = BinaryNode(30)\\n tree.left.right = BinaryNode(25)\\n return tree\",\n \"def _gen_test_tree_5():\\n tree = BinaryNode(30)\\n tree.right = BinaryNode(30)\\n return tree\",\n \"def __init__(self):\\n self._root = None\\n self._size = 0\\n self._my_hash = {'preorder':self.preorder, 'postorder': self.postorder, 'inorder': self.inorder,\\n \\\"breadthfirst\\\": self.breadthfirst}\",\n \"def grow(self):\\n self.capacity = self.capacity * 2\\n self.rehash()\",\n \"def __init__(self, capacity):\\n self.capacity = capacity #this is example for list implementation\\n self.head = [None] * capacity #this is example for list implementation\\n self.num_items = 0 #this is example for list implementation\",\n \"def _build_replay_buffer(self):\\n return prioritized_replay_buffer.OutOfGraphPrioritizedReplayBuffer(\\n observation_shape=self.observation_shape,\\n stack_size=self.stack_size,\\n update_horizon=self.update_horizon,\\n gamma=self.gamma,\\n observation_dtype=self.observation_dtype)\",\n \"def fullIntroduceNew (self, networkSize, numNodes, time) :\\n\\t\\tnodeList = self.createNodes(networkSize)\\n\\t\\tself.addAppRecordDiff(nodeList)\\n\\t\\tsessionInfo = self.sessionsFull(nodeList)\\n\\t\\ttotal = 0\\n\\t\\twhile self.endConditionData(nodeList) :\\n\\t\\t\\tif total == time :\\n\\t\\t\\t\\tfor i in range(networkSize, networkSize + numNodes):\\n\\t\\t\\t\\t\\tnode = Node(str(i))\\n\\t\\t\\t\\t\\tnodeList.append(node)\\n\\t\\t\\t\\t\\tnode.addAppData(\\\"record\\\"+str(i),\\\"data\\\" + str(i), Node.ALL, Node.ALL )\\n \\t\\t\\tnode.serialize((Node.ALL, Node.ALL))\\n\\t\\t\\t\\t\\tsessionInfo = self.sessionsFull(nodeList)\\n\\t\\t\\tindex = random.randint(0, len(sessionInfo)-1)\\n\\t\\t\\tclient = sessionInfo[index][0]\\n\\t\\t\\tserver = sessionInfo[index][1]\\n\\t\\t\\tself.fullDBReplication(nodeList[client], sessionInfo[index][2])\\n\\t\\t\\ttotal = total + 1\\n\\t\\treturn total\",\n \"def __init__(self):\\n self._root = None\\n self._size = 0\\n self._curr_idx = 0\\n self._depths, self._heights = None, None\",\n \"def __init__(self):\\n self._root = None\\n self._size = 0\",\n \"def __init__(self):\\n self._root = None\\n self._size = 0\",\n \"def __init__(self):\\n self._root = None\\n self._size = 0\",\n \"def __init__(self):\\n self._root = None\\n self._size = 0\",\n \"def __init__(self):\\n self._root = None\\n self._size = 0\",\n \"def build(self):\\n #print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))\\n #print('self.IDs', self.data)\\n self.itime = 0\\n self.ielement = 0\\n self.itotal = 0\\n\\n assert self.ntimes > 0, 'ntimes=%s' % self.ntimes\\n assert self.nelements > 0, 'nelements=%s' % self.nelements\\n assert self.ntotal > 0, 'ntotal=%s' % self.ntotal\\n self.nelements //= self.ntimes\\n\\n dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size, self.analysis_fmt)\\n self.node = np.zeros(self.ntotal, dtype=idtype)\\n #oxx, oyy, txy, angle, major, minor, ovm\\n self.data = np.zeros((self.ntimes, self.ntotal, 8), dtype=fdtype)\\n self.location = np.empty(self.ntotal, dtype='U8')\\n self._times = np.zeros(self.ntimes, dtype=dtype)\",\n \"def __init__(self, k: int):\\n self.queue = [0]*k\\n self.headIndex = 0\\n self.count = 0\\n self.capacity = k\",\n \"def __init__(self, state, parent=None, action=None, path_cost=0):\\n self.state = state\\n self.parent = parent\\n self.action = action\\n self.path_cost = path_cost\\n self.depth = 0\\n if parent:\\n self.depth = parent.depth + 1\",\n \"def __init__(self, initial, costfn=lambda node: node.path_cost):\\n self.heap = []\\n self.states = {}\\n self.costfn = costfn\\n self.add(initial)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6020408","0.5820842","0.5724238","0.55728537","0.55458015","0.5542693","0.5513752","0.5476557","0.53817534","0.53465384","0.53336674","0.53084284","0.5296613","0.5293262","0.5262831","0.5256954","0.5208593","0.519735","0.5179887","0.51658785","0.51624656","0.5124032","0.5124032","0.51225233","0.51113254","0.51065004","0.5095909","0.50948924","0.5094026","0.50869215","0.5079532","0.5079528","0.5072277","0.5051862","0.5044467","0.5039624","0.50225544","0.5008621","0.4997842","0.49854472","0.49834117","0.4982999","0.49746028","0.49639958","0.49519968","0.49395713","0.49366853","0.49109983","0.4910131","0.49088165","0.49000874","0.4888422","0.48638195","0.4849619","0.484711","0.48464805","0.48333806","0.48227507","0.48192292","0.4810541","0.48081967","0.4796131","0.47940937","0.4790346","0.47896418","0.47845325","0.4765943","0.4758157","0.4757919","0.47562143","0.4755983","0.47529817","0.47463545","0.4739974","0.4734465","0.47251427","0.47241658","0.47241658","0.4716732","0.47135222","0.46988487","0.4694798","0.46884847","0.46814907","0.46810135","0.46787104","0.46783796","0.4674046","0.46726173","0.46712068","0.4669191","0.46691796","0.46691796","0.46691796","0.46691796","0.4661859","0.46616843","0.4661375","0.4656472","0.46548703"],"string":"[\n \"0.6020408\",\n \"0.5820842\",\n \"0.5724238\",\n \"0.55728537\",\n \"0.55458015\",\n \"0.5542693\",\n \"0.5513752\",\n \"0.5476557\",\n \"0.53817534\",\n \"0.53465384\",\n \"0.53336674\",\n \"0.53084284\",\n \"0.5296613\",\n \"0.5293262\",\n \"0.5262831\",\n \"0.5256954\",\n \"0.5208593\",\n \"0.519735\",\n \"0.5179887\",\n \"0.51658785\",\n \"0.51624656\",\n \"0.5124032\",\n \"0.5124032\",\n \"0.51225233\",\n \"0.51113254\",\n \"0.51065004\",\n \"0.5095909\",\n \"0.50948924\",\n \"0.5094026\",\n \"0.50869215\",\n \"0.5079532\",\n \"0.5079528\",\n \"0.5072277\",\n \"0.5051862\",\n \"0.5044467\",\n \"0.5039624\",\n \"0.50225544\",\n \"0.5008621\",\n \"0.4997842\",\n \"0.49854472\",\n \"0.49834117\",\n \"0.4982999\",\n \"0.49746028\",\n \"0.49639958\",\n \"0.49519968\",\n \"0.49395713\",\n \"0.49366853\",\n \"0.49109983\",\n \"0.4910131\",\n \"0.49088165\",\n \"0.49000874\",\n \"0.4888422\",\n \"0.48638195\",\n \"0.4849619\",\n \"0.484711\",\n \"0.48464805\",\n \"0.48333806\",\n \"0.48227507\",\n \"0.48192292\",\n \"0.4810541\",\n \"0.48081967\",\n \"0.4796131\",\n \"0.47940937\",\n \"0.4790346\",\n \"0.47896418\",\n \"0.47845325\",\n \"0.4765943\",\n \"0.4758157\",\n \"0.4757919\",\n \"0.47562143\",\n \"0.4755983\",\n \"0.47529817\",\n \"0.47463545\",\n \"0.4739974\",\n \"0.4734465\",\n \"0.47251427\",\n \"0.47241658\",\n \"0.47241658\",\n \"0.4716732\",\n \"0.47135222\",\n \"0.46988487\",\n \"0.4694798\",\n \"0.46884847\",\n \"0.46814907\",\n \"0.46810135\",\n \"0.46787104\",\n \"0.46783796\",\n \"0.4674046\",\n \"0.46726173\",\n \"0.46712068\",\n \"0.4669191\",\n \"0.46691796\",\n \"0.46691796\",\n \"0.46691796\",\n \"0.46691796\",\n \"0.4661859\",\n \"0.46616843\",\n \"0.4661375\",\n \"0.4656472\",\n \"0.46548703\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.70326006"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":72,"numItemsPerPage":100,"numTotalItems":95772,"offset":7200,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6Im1sR1pFYktIVHRVSGRhX1RRdEczQ0N1S3k5ME9Qd25DNHY5elRjM3FVYzgifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4MjY5MzMyMSwianRpIjoiNzc0ZmRiZTgtY2UxYi00NWU5LWFhMmEtMzkwNjdiZjAzMjMzIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODI2OTY5MjEsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.2W2xotsibCnAKQKeF0WKl-67_Z-ul7HWPwZp4X8zhnkf4O0odnfkLXFNJxeybZLskWrIHdUkYEIKZTfSOD9hBw","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 |
|---|---|---|---|---|---|---|
Returns true if the current user is following the desired user | def is_following_by_username(self, id):
return self.followed.filter(followers.c.followed_id == id).count() > 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_user_following(self, user_id):\n return user_id in self.following",
"def is_following(self, you, them):\n if self.filter(from_user=you, to_user=them).count() > 0:\n return True\n return False",
"def is_following(self, user):\n return self.followed.filter_by(\n ... | [
"0.7629707",
"0.75313014",
"0.74600714",
"0.7424218",
"0.7424218",
"0.73141986",
"0.7265916",
"0.7074228",
"0.7049804",
"0.6913712",
"0.6912288",
"0.682332",
"0.6789204",
"0.6776134",
"0.67695856",
"0.67149085",
"0.65792125",
"0.6536938",
"0.6522163",
"0.6520679",
"0.6476891"... | 0.70594585 | 8 |
Returns the username of the desired user | def get_username_by_id(self, id):
return User.query.get(id).username | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def username(self) -> str:",
"def username(self) -> str:",
"def get_username(self):\r\n return self.username",
"def get_username(self):\n return self.username",
"def get_username(self, request):\r\n try:\r\n return request.user.username\r\n except AttributeError:\r\n ... | [
"0.8169498",
"0.8169498",
"0.8081674",
"0.8035194",
"0.8018373",
"0.7989936",
"0.79892623",
"0.798525",
"0.79793316",
"0.79793316",
"0.79586726",
"0.79586726",
"0.79586726",
"0.79513943",
"0.7948783",
"0.7941232",
"0.79404753",
"0.79382294",
"0.7898637",
"0.7894659",
"0.78907... | 0.7294774 | 99 |
Gets the list of banks. | def get_banks() -> List[BankDetails]:
from paynlsdk.api.transaction.getbanks import Request
client = APIClient()
request = Request()
client.perform_request(request)
return request.response.banks | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def banks(self):\n return self.__banks",
"def banks(self):\n return self.__banks",
"def banks(self):\n return self.__banks",
"def banks(self):\n return self.__banks",
"def banks(self):\n return self.__banks",
"def banks(self):\n return self.__banks",
"def banks... | [
"0.83688354",
"0.83688354",
"0.83688354",
"0.83688354",
"0.83688354",
"0.83688354",
"0.83688354",
"0.76620173",
"0.664025",
"0.664025",
"0.664025",
"0.664025",
"0.664025",
"0.664025",
"0.664025",
"0.6498705",
"0.6401011",
"0.63876766",
"0.6261225",
"0.6159119",
"0.6064427",
... | 0.7611785 | 8 |
Refund (part of) a transaction | def refund(transaction_id: str, amount: int=None, description: str=None, process_date: datetime=None):
return Transaction.refund_response(transaction_id, amount, description, process_date) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def refund_payment(self, **kwargs):",
"def refund_payment(self, **kwargs):",
"def refund(self, amount_in_cents=None):\r\n self.require_item()\r\n\r\n url = self.get_url()\r\n params = base.get_params(('amount_in_cents',), locals())\r\n if params:\r\n url = url + '?' + htt... | [
"0.8025384",
"0.8025384",
"0.72545916",
"0.7059862",
"0.6983477",
"0.69578123",
"0.6895562",
"0.68423915",
"0.65162545",
"0.64691937",
"0.6408193",
"0.6375899",
"0.63735026",
"0.6373101",
"0.6268878",
"0.6206176",
"0.61452",
"0.6065676",
"0.606385",
"0.60265565",
"0.5964484",... | 0.7412963 | 2 |
Show portfolio of stocks | def index():
rows=db.execute("SELECT * FROM portofolio WHERE user_id=:s",s=session["user_id"])
row=db.execute("SELECT * FROM users WHERE id=:s",s=session["user_id"])
overall=0
for line in rows:
overall+=line["total"]
overall+=row[0]["cash"]
return render_template("portofolio.html",rows=r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index():\n stocks = []\n username = session.get(\"username\")\n symbol_list = db.execute(\"SELECT stock_symbol FROM history WHERE username=:username GROUP BY stock_symbol\", username=username)\n cash_balance = db.execute(\"SELECT cash FROM users WHERE username=:username\", username=username)[0][\"c... | [
"0.7349525",
"0.7257509",
"0.7092902",
"0.70840114",
"0.70700926",
"0.70322937",
"0.70166755",
"0.6955458",
"0.69515324",
"0.6818638",
"0.67683095",
"0.67541313",
"0.6739686",
"0.66745",
"0.66665316",
"0.6584005",
"0.65794265",
"0.6577333",
"0.6556571",
"0.65012944",
"0.64815... | 0.0 | -1 |
Buy shares of stock | def buy():
if request.method == "POST":
if not request.form.get("symbol") or not lookup(request.form.get("symbol")):
return apology("must provide valid symbol",400)
if not request.form.get("shares") or int(request.form.get("shares")) <= 0:
return apology("shares must be posit... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def buy(self, ctx, name, shares: int):\n\t\tplural = 's' if shares != 1 else ''\n\t\tcurrency = await bank.get_currency_name(ctx.guild)\n\t\tif shares < 1:\n\t\t\tawait ctx.send('You cannot buy less than one share.')\n\t\t\treturn\n\t\tname = name.upper()\n\t\ttry:\n\t\t\tstock_data = await self._get_stock_d... | [
"0.75090504",
"0.73669976",
"0.719782",
"0.7076133",
"0.702035",
"0.70142156",
"0.69631433",
"0.6943623",
"0.6915625",
"0.691014",
"0.6897359",
"0.68731195",
"0.6865242",
"0.68647367",
"0.6850216",
"0.6848369",
"0.6818854",
"0.67891747",
"0.6722476",
"0.6719868",
"0.67188966"... | 0.64506495 | 55 |
Show history of transactions | def history():
user_history=db.execute("SELECT * FROM history WHERE user_id=:u_i",u_i=session["user_id"])
return render_template("history.html",s=user_history) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def history():\n transactions = db.execute(\"SELECT Symbol, Shares, Transacted FROM cash WHERE id=:id\", id=session[\"user_id\"])\n return render_template(\"history.html\", transactions=transactions)",
"def history():\n\n #Query transactions by user id\n trans = Transactions.query.filter_by(owner=ses... | [
"0.82002884",
"0.8140903",
"0.8114919",
"0.8042388",
"0.8033679",
"0.80168986",
"0.79338187",
"0.7822898",
"0.77456313",
"0.77341163",
"0.7718728",
"0.7716838",
"0.7708978",
"0.7628142",
"0.7624304",
"0.7530955",
"0.74965966",
"0.7481556",
"0.74478734",
"0.7423578",
"0.738227... | 0.68055445 | 50 |
Sell shares of stock | def sell():
if request.method == "POST":
dict=lookup(request.form.get("symbol"))
if not request.form.get("symbol") or not request.form.get("shares") or not lookup(request.form.get("symbol")):
return apology("Must provide valid symbol and positive integer",400)
else:
r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sell_stock(self, symbol):\n amount_to_sell = self.get_equity(symbol)\n chirp.order_sell_fractional_by_price(symbol, amount_to_sell)\n self.L.add_line('', symbol, 'SOLD', amount_to_sell)",
"async def sell(self, ctx, name, shares: int):\n\t\tplural = 's' if shares != 1 else ''\n\t\tif shar... | [
"0.76451164",
"0.748746",
"0.7260813",
"0.71164954",
"0.7057435",
"0.70490545",
"0.70268077",
"0.69872165",
"0.6972749",
"0.6966809",
"0.6915586",
"0.68977857",
"0.68829334",
"0.6849716",
"0.68191767",
"0.68124473",
"0.68022114",
"0.6801836",
"0.67799073",
"0.67698354",
"0.67... | 0.6538862 | 39 |
auth_state enabled and available | async def test_auth_state(app, auth_state_enabled):
name = 'kiwi'
user = add_user(app.db, app, name=name)
assert user.encrypted_auth_state is None
cookies = await app.login_user(name)
auth_state = await user.get_auth_state()
assert auth_state == app.authenticator.auth_state | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_auth_state(self):\n raise NotImplementedError()",
"def check_auth():",
"def requires_auth(self):\n return True",
"def get_authorization():\n return True",
"def is_authenticated(self):\n return True #self.authenticated",
"def is_authenticated(self):\n return True",
"de... | [
"0.74882525",
"0.71273947",
"0.6910631",
"0.6909217",
"0.670079",
"0.6680911",
"0.6628001",
"0.65065384",
"0.65065384",
"0.65065384",
"0.65065384",
"0.65065384",
"0.65065384",
"0.65065384",
"0.6505308",
"0.6504012",
"0.64769554",
"0.64769554",
"0.64572227",
"0.64142615",
"0.6... | 0.7185515 | 1 |
admin should be passed through for nonadmin users | async def test_auth_admin_non_admin(app):
name = 'kiwi'
user = add_user(app.db, app, name=name, admin=False)
assert user.admin is False
cookies = await app.login_user(name)
assert user.admin is False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_admin():\n\tif not current_user.is_admin:\n\t\tabort(403)",
"def check_admin():\r\n if not current_user.is_admin:\r\n abort(403)",
"def check_admin():\n if not current_user.is_admin:\n abort(403)",
"def check_admin():\n if not current_user.is_admin:\n abort(403)",
"d... | [
"0.76604193",
"0.76227117",
"0.7580729",
"0.7580729",
"0.74723893",
"0.7399326",
"0.73662555",
"0.72489077",
"0.7212591",
"0.71992993",
"0.7144615",
"0.7074819",
"0.7029829",
"0.7020532",
"0.70080376",
"0.7003052",
"0.7002116",
"0.6998605",
"0.69832844",
"0.6980152",
"0.69801... | 0.0 | -1 |
admin should be passed through for admin users | async def test_auth_admin_is_admin(app):
# Admin user defined in MockPAMAuthenticator.
name = 'admin'
user = add_user(app.db, app, name=name, admin=False)
assert user.admin is False
cookies = await app.login_user(name)
assert user.admin is True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GET_adminon(self):\r\n #check like this because c.user_is_admin is still false\r\n if not c.user.name in g.admins:\r\n return self.abort404()\r\n self.login(c.user, admin = True)\r\n\r\n dest = request.referer or '/'\r\n return self.redirect(dest)",
"def admin_re... | [
"0.76515234",
"0.7589409",
"0.72544324",
"0.7240122",
"0.72308195",
"0.72102034",
"0.72102034",
"0.71380514",
"0.71223193",
"0.71042573",
"0.7030925",
"0.70082307",
"0.6999681",
"0.6966063",
"0.6965032",
"0.6940669",
"0.69357306",
"0.6932168",
"0.6897163",
"0.6887465",
"0.687... | 0.0 | -1 |
admin should be unchanged if authenticator doesn't return admin value | async def test_auth_admin_retained_if_unset(app):
name = 'kiwi'
# Add user as admin.
user = add_user(app.db, app, name=name, admin=True)
assert user.admin is True
# User should remain unchanged.
cookies = await app.login_user(name)
assert user.admin is True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def admin_required(handler):\n def admin_login(self, *args, **kwargs):\n auth = self.auth\n if not auth.get_user_by_session():\n self.redirect('/auth/login', abort=True)\n \n user = auth.get_user_by_session()\n queried_entity = User.get_by_id(user['user_id'])\n ... | [
"0.6545929",
"0.6443032",
"0.6328436",
"0.6289202",
"0.62141764",
"0.62122965",
"0.6134274",
"0.6130718",
"0.6127599",
"0.61198676",
"0.6079004",
"0.60773593",
"0.6006329",
"0.6006329",
"0.59977925",
"0.5994712",
"0.59755987",
"0.5956938",
"0.59537655",
"0.59465075",
"0.59193... | 0.62106174 | 6 |
auth_state enabled at the Authenticator level, but unavailable due to no crypto keys. | def auth_state_unavailable(auth_state_enabled):
crypto.CryptKeeper.instance().keys = []
yield | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_auth_state(self):\n raise NotImplementedError()",
"async def test_auth_state(app, auth_state_enabled):\n name = 'kiwi'\n user = add_user(app.db, app, name=name)\n assert user.encrypted_auth_state is None\n cookies = await app.login_user(name)\n auth_state = await user.get_auth_state... | [
"0.70946044",
"0.6600317",
"0.5862487",
"0.58282715",
"0.577362",
"0.5701615",
"0.5661563",
"0.5567852",
"0.55177164",
"0.55092674",
"0.55005485",
"0.54370195",
"0.5430303",
"0.53735715",
"0.5352972",
"0.53514665",
"0.5348289",
"0.5340672",
"0.5339704",
"0.5333827",
"0.532115... | 0.6792563 | 1 |
Tests whether ``SoundboardSound.__repr__`` works as intended. | def test__SoundboardSound__repr():
available = False
emoji = BUILTIN_EMOJIS['heart']
name = 'rember'
user_id = 202305240032
volume = 0.69
sound_id = 202305240033
guild_id = 202305240034
sound = SoundboardSound.precreate(
sound_id,
guild_id = guild_id,
av... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_repr(self):\n self.assertEqual(repr(self.deck), \"Deck of 52 cards.\")",
"def test_repr(self):\n self.assertEqual(repr(self.card), \"A of Spades\")",
"def test_repr(self):\n dummy = DummyCryptographicObject()\n repr(dummy)",
"def test_repr_show(self):\n self.assert... | [
"0.6914809",
"0.6808723",
"0.66963106",
"0.6534174",
"0.6505421",
"0.64757746",
"0.6391462",
"0.6254702",
"0.6244902",
"0.6209125",
"0.6178",
"0.6166957",
"0.6156544",
"0.6156544",
"0.6156544",
"0.6156544",
"0.6156544",
"0.6116914",
"0.6116562",
"0.6096828",
"0.60628986",
"... | 0.77653193 | 0 |
Tests whether ``SoundboardSound.__hash__`` works as intended. | def test__SoundboardSound__hash():
available = False
emoji = BUILTIN_EMOJIS['heart']
name = 'rember'
user_id = 202305240035
volume = 0.69
sound_id = 202305240036
guild_id = 202305240037
keyword_parameters = {
'available': available,
'emoji': emoji,
'name... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test__SoundboardSound__eq():\n available = False\n emoji = BUILTIN_EMOJIS['heart']\n name = 'rember'\n user_id = 202305240038\n volume = 0.69\n \n sound_id = 202305240039\n guild_id = 202305240040\n \n keyword_parameters = {\n 'available': available,\n 'emoji': emoji... | [
"0.64707255",
"0.63552177",
"0.6180331",
"0.61213714",
"0.6096645",
"0.60493755",
"0.60439104",
"0.603657",
"0.603657",
"0.60337245",
"0.6027019",
"0.6023845",
"0.60236806",
"0.59823734",
"0.5976516",
"0.5973415",
"0.59712046",
"0.59241724",
"0.58853847",
"0.5853793",
"0.5851... | 0.78902173 | 0 |
Tests whether ``SoundboardSound.__eq__`` works as intended. | def test__SoundboardSound__eq():
available = False
emoji = BUILTIN_EMOJIS['heart']
name = 'rember'
user_id = 202305240038
volume = 0.69
sound_id = 202305240039
guild_id = 202305240040
keyword_parameters = {
'available': available,
'emoji': emoji,
'name':... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __eq__(self, other):\n if not isinstance(other, NhlOddsScoringPlay):\n return False\n\n return self.__dict__ == other.__dict__",
"def __eq__(self, other):\n if not isinstance(other, DiarizeAudio):\n return False\n\n return self.__dict__ == other.__dict__",
... | [
"0.7053136",
"0.69082266",
"0.68528724",
"0.6663054",
"0.6607504",
"0.65843195",
"0.65642565",
"0.65642565",
"0.65642565",
"0.65642565",
"0.65642565",
"0.65642565",
"0.65642565",
"0.65642565",
"0.65642565",
"0.65642565",
"0.65642565",
"0.65642565",
"0.65642565",
"0.65642565",
... | 0.7741757 | 0 |
Getter method for usr_ping_count, mapped from YANG variable /mpls_state/statistics_oam/usr_ping_count (uint32) | def _get_usr_ping_count(self):
return self.__usr_ping_count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_usr_ping_count(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"usr-ping-count\", rest_name=\"usr-ping-count\", pa... | [
"0.7919465",
"0.62490904",
"0.5974101",
"0.5872466",
"0.5848729",
"0.5829324",
"0.58061343",
"0.57633376",
"0.5698802",
"0.5670618",
"0.55348474",
"0.54909444",
"0.54774773",
"0.54751647",
"0.54595673",
"0.54140943",
"0.5395396",
"0.5368198",
"0.5319455",
"0.531552",
"0.52972... | 0.6955739 | 1 |
Setter method for usr_ping_count, mapped from YANG variable /mpls_state/statistics_oam/usr_ping_count (uint32) | def _set_usr_ping_count(self, v, load=False):
if hasattr(v, "_utype"):
v = v._utype(v)
try:
t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="usr-ping-count", rest_name="usr-ping-count", parent=self, path... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_usr_ping_count(self):\n return self.__usr_ping_count",
"def _set_usr_traceroute_count(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), ... | [
"0.66030264",
"0.6556253",
"0.5894535",
"0.568632",
"0.56651974",
"0.56644946",
"0.5605921",
"0.5584418",
"0.55039364",
"0.55039364",
"0.5503759",
"0.5493639",
"0.54372156",
"0.53541523",
"0.5247895",
"0.5217682",
"0.5213357",
"0.5187056",
"0.516838",
"0.5158767",
"0.51152784... | 0.8726256 | 0 |
Getter method for usr_traceroute_count, mapped from YANG variable /mpls_state/statistics_oam/usr_traceroute_count (uint32) | def _get_usr_traceroute_count(self):
return self.__usr_traceroute_count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_usr_traceroute_count(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"usr-traceroute-count\", rest_name=\"usr-trac... | [
"0.8096988",
"0.58348656",
"0.5540107",
"0.5337788",
"0.5088764",
"0.50769204",
"0.5072222",
"0.50714403",
"0.5059296",
"0.50581366",
"0.50281113",
"0.49717057",
"0.4894099",
"0.48607355",
"0.48384598",
"0.48260984",
"0.48260832",
"0.48071045",
"0.47291836",
"0.47040775",
"0.... | 0.7333012 | 1 |
Setter method for usr_traceroute_count, mapped from YANG variable /mpls_state/statistics_oam/usr_traceroute_count (uint32) | def _set_usr_traceroute_count(self, v, load=False):
if hasattr(v, "_utype"):
v = v._utype(v)
try:
t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="usr-traceroute-count", rest_name="usr-traceroute-count",... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_usr_traceroute_count(self):\n return self.__usr_traceroute_count",
"def _set_usr_ping_count(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size... | [
"0.69384295",
"0.67749554",
"0.55161387",
"0.5156745",
"0.5149116",
"0.51029897",
"0.506374",
"0.5044057",
"0.5044057",
"0.4962718",
"0.49115133",
"0.49114674",
"0.48995262",
"0.48913693",
"0.48689324",
"0.4850962",
"0.48443764",
"0.4837305",
"0.48038968",
"0.47544253",
"0.46... | 0.88829786 | 0 |
Getter method for echo_req_sent_count, mapped from YANG variable /mpls_state/statistics_oam/echo_req_sent_count (uint32) | def _get_echo_req_sent_count(self):
return self.__echo_req_sent_count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_echo_req_sent_count(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"echo-req-sent-count\", rest_name=\"echo-req-s... | [
"0.7922508",
"0.6860566",
"0.67645717",
"0.65473276",
"0.64664423",
"0.5968414",
"0.5861087",
"0.5787943",
"0.5689521",
"0.56807286",
"0.5430021",
"0.54220355",
"0.5201689",
"0.5130782",
"0.49798772",
"0.4948916",
"0.48980132",
"0.48834348",
"0.4872083",
"0.48253825",
"0.4824... | 0.7223332 | 1 |
Setter method for echo_req_sent_count, mapped from YANG variable /mpls_state/statistics_oam/echo_req_sent_count (uint32) | def _set_echo_req_sent_count(self, v, load=False):
if hasattr(v, "_utype"):
v = v._utype(v)
try:
t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="echo-req-sent-count", rest_name="echo-req-sent-count", pa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_echo_resp_sent_count(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"echo-resp-sent-count\", rest_name=\"echo-res... | [
"0.7546443",
"0.74266785",
"0.69616437",
"0.66970843",
"0.6288053",
"0.6279342",
"0.6064423",
"0.57884806",
"0.5556439",
"0.5305215",
"0.52710307",
"0.5181049",
"0.50654066",
"0.50303006",
"0.50086975",
"0.49919927",
"0.48444322",
"0.4777001",
"0.4770685",
"0.4731099",
"0.468... | 0.86451477 | 0 |
Getter method for echo_req_received_count, mapped from YANG variable /mpls_state/statistics_oam/echo_req_received_count (uint32) | def _get_echo_req_received_count(self):
return self.__echo_req_received_count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_echo_req_received_count(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"echo-req-received-count\", rest_name=\"ec... | [
"0.77231425",
"0.7023055",
"0.6542562",
"0.62707675",
"0.5976226",
"0.5851045",
"0.58174163",
"0.54856044",
"0.54173255",
"0.5317395",
"0.50623125",
"0.5022893",
"0.5022014",
"0.4883163",
"0.4860375",
"0.48226205",
"0.48192063",
"0.4816786",
"0.4814243",
"0.4797339",
"0.46779... | 0.70718306 | 1 |
Setter method for echo_req_received_count, mapped from YANG variable /mpls_state/statistics_oam/echo_req_received_count (uint32) | def _set_echo_req_received_count(self, v, load=False):
if hasattr(v, "_utype"):
v = v._utype(v)
try:
t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="echo-req-received-count", rest_name="echo-req-receive... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_echo_resp_received_count(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"echo-resp-received-count\", rest_name=\"... | [
"0.7757586",
"0.7065394",
"0.68073034",
"0.67364514",
"0.66612166",
"0.62458676",
"0.56309354",
"0.5338627",
"0.52505404",
"0.50096846",
"0.48576525",
"0.48448968",
"0.48185655",
"0.47561345",
"0.4739262",
"0.46860245",
"0.46509308",
"0.46177593",
"0.45707104",
"0.45225346",
... | 0.84776396 | 0 |
Getter method for echo_req_timeout_count, mapped from YANG variable /mpls_state/statistics_oam/echo_req_timeout_count (uint32) | def _get_echo_req_timeout_count(self):
return self.__echo_req_timeout_count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_echo_req_timeout_count(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"echo-req-timeout-count\", rest_name=\"echo... | [
"0.80206865",
"0.6734563",
"0.6540391",
"0.6376731",
"0.61047983",
"0.60804176",
"0.60245043",
"0.5819295",
"0.55777395",
"0.49859354",
"0.49369183",
"0.4863983",
"0.48448384",
"0.48247913",
"0.4788822",
"0.4729328",
"0.47008264",
"0.4682831",
"0.46340755",
"0.46337748",
"0.4... | 0.7347358 | 1 |
Setter method for echo_req_timeout_count, mapped from YANG variable /mpls_state/statistics_oam/echo_req_timeout_count (uint32) | def _set_echo_req_timeout_count(self, v, load=False):
if hasattr(v, "_utype"):
v = v._utype(v)
try:
t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="echo-req-timeout-count", rest_name="echo-req-timeout-c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_echo_req_received_count(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"echo-req-received-count\", rest_name=\"ec... | [
"0.7362202",
"0.7095978",
"0.6999127",
"0.6642217",
"0.64998084",
"0.60558325",
"0.57168615",
"0.5617509",
"0.52749455",
"0.50046265",
"0.4905859",
"0.49030608",
"0.48003668",
"0.4683387",
"0.4644038",
"0.45746693",
"0.45659736",
"0.4561842",
"0.45596886",
"0.4557894",
"0.448... | 0.87411803 | 0 |
Getter method for echo_resp_sent_count, mapped from YANG variable /mpls_state/statistics_oam/echo_resp_sent_count (uint32) | def _get_echo_resp_sent_count(self):
return self.__echo_resp_sent_count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_echo_resp_sent_count(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"echo-resp-sent-count\", rest_name=\"echo-res... | [
"0.7885906",
"0.71892625",
"0.7101065",
"0.69950885",
"0.66274446",
"0.6617462",
"0.635762",
"0.5800941",
"0.577533",
"0.55431056",
"0.5397536",
"0.5257677",
"0.5200311",
"0.5128361",
"0.5111158",
"0.51002544",
"0.50733143",
"0.50320685",
"0.50222456",
"0.4920297",
"0.4917206... | 0.7451523 | 1 |
Setter method for echo_resp_sent_count, mapped from YANG variable /mpls_state/statistics_oam/echo_resp_sent_count (uint32) | def _set_echo_resp_sent_count(self, v, load=False):
if hasattr(v, "_utype"):
v = v._utype(v)
try:
t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="echo-resp-sent-count", rest_name="echo-resp-sent-count",... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_echo_resp_received_count(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"echo-resp-received-count\", rest_name=\"... | [
"0.7872074",
"0.7738624",
"0.7278106",
"0.7268996",
"0.6715367",
"0.65274954",
"0.6379835",
"0.60264504",
"0.5693287",
"0.55500114",
"0.5237852",
"0.515169",
"0.50731426",
"0.5025889",
"0.49551892",
"0.4954932",
"0.4935209",
"0.49100864",
"0.4884356",
"0.48487535",
"0.4827424... | 0.8611856 | 0 |
Getter method for echo_resp_received_count, mapped from YANG variable /mpls_state/statistics_oam/echo_resp_received_count (uint32) | def _get_echo_resp_received_count(self):
return self.__echo_resp_received_count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_echo_resp_received_count(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"echo-resp-received-count\", rest_name=\"... | [
"0.785285",
"0.70278424",
"0.6552268",
"0.64812785",
"0.6124184",
"0.55265635",
"0.5396158",
"0.5115494",
"0.5112692",
"0.50826174",
"0.49409315",
"0.4853131",
"0.4822724",
"0.47961304",
"0.4737998",
"0.47299495",
"0.47204226",
"0.46952853",
"0.46684587",
"0.46589735",
"0.465... | 0.731385 | 1 |
Setter method for echo_resp_received_count, mapped from YANG variable /mpls_state/statistics_oam/echo_resp_received_count (uint32) | def _set_echo_resp_received_count(self, v, load=False):
if hasattr(v, "_utype"):
v = v._utype(v)
try:
t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="echo-resp-received-count", rest_name="echo-resp-rece... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_echo_req_received_count(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"echo-req-received-count\", rest_name=\"ec... | [
"0.76704717",
"0.73230594",
"0.70944583",
"0.6276271",
"0.618727",
"0.6063231",
"0.60443354",
"0.51781255",
"0.5142111",
"0.50479865",
"0.49492952",
"0.48183542",
"0.47569573",
"0.47515997",
"0.47491166",
"0.4727505",
"0.46277964",
"0.45390615",
"0.45219365",
"0.44867164",
"0... | 0.8556093 | 0 |
Getter method for return_codes, mapped from YANG variable /mpls_state/statistics_oam/return_codes (list) | def _get_return_codes(self):
return self.__return_codes | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_return_codes(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=YANGListType(\"number\",return_codes.return_codes, yang_name=\"return-codes\", rest_name=\"return-codes\", parent=self, is_container='list', user_ordered=False, path_helper=se... | [
"0.74746984",
"0.6001439",
"0.5503843",
"0.52020866",
"0.51311105",
"0.5087448",
"0.5053257",
"0.50515985",
"0.49911606",
"0.48414174",
"0.48189038",
"0.46903574",
"0.4685551",
"0.4676945",
"0.46544784",
"0.46471697",
"0.45722067",
"0.45684677",
"0.45653287",
"0.44813254",
"0... | 0.6220025 | 1 |
Setter method for return_codes, mapped from YANG variable /mpls_state/statistics_oam/return_codes (list) | def _set_return_codes(self, v, load=False):
if hasattr(v, "_utype"):
v = v._utype(v)
try:
t = YANGDynClass(v,base=YANGListType("number",return_codes.return_codes, yang_name="return-codes", rest_name="return-codes", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_return_codes(self):\n return self.__return_codes",
"def traffic_statuscodes_cachecodes(self, **kwargs):\n url_path = 'traffic/statuscodes/cachecodes'\n self.logger.debug(f\"Get list of cache codes\")\n body = self._make_body(kwargs)\n return self._common_get(request_path=u... | [
"0.6291366",
"0.614847",
"0.55107534",
"0.54416496",
"0.5277496",
"0.5117377",
"0.50821906",
"0.50539535",
"0.49968654",
"0.4987946",
"0.49695534",
"0.47850552",
"0.47627786",
"0.4757852",
"0.4730072",
"0.4728713",
"0.47217613",
"0.46919942",
"0.46385816",
"0.4602432",
"0.459... | 0.8261662 | 0 |
Assumes binary array of 1 and 0 as input. Calculate longest ranges of 1's. | def count_ranges(a):
ranges = []
count = 0
for i, v in enumerate(a):
if v == 1: # same as previous value
count += 1
else:
if count > 1:
ranges.append([i, count]) # [end, length]
count = 0
return ranges | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solution(N):\n # write your code in Python 3.6\n bin_number = str(bin(N))[2:]\n new_bin_gap = False\n longest_bin_gap = 0\n bin_gap_counter = 0\n for char in bin_number:\n if char == '1':\n if bin_gap_counter > longest_bin_gap:\n longest_bin_gap = bin_gap_coun... | [
"0.6214653",
"0.61803985",
"0.61673665",
"0.6140894",
"0.60812706",
"0.60509235",
"0.60332197",
"0.6032968",
"0.59139353",
"0.5893834",
"0.5799357",
"0.5777712",
"0.57581043",
"0.57554233",
"0.57196367",
"0.56999797",
"0.5694365",
"0.5683879",
"0.56704044",
"0.56537473",
"0.5... | 0.6188714 | 1 |
from range of count_ranges, return the 'howmany' longest ranges | def find_longest_ranges(range, howmany):
range.sort(key=lambda x: x[1]) # sort by length
if howmany > 1:
range = range[-howmany:] # get last few
range.sort(key=lambda x: x[0]) # sorted by starttime
return range
else:
return range[-1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def overlap_len(range1, range2):\n return min(range1[1], range2[1]) - max(range1[0], range2[0])",
"def count_ranges(a):\n ranges = []\n count = 0\n for i, v in enumerate(a):\n if v == 1: # same as previous value\n count += 1\n else:\n if count > 1:\n ... | [
"0.6553023",
"0.63709086",
"0.6276035",
"0.618169",
"0.61786216",
"0.60901237",
"0.60474753",
"0.6026283",
"0.6022194",
"0.6012892",
"0.5978638",
"0.58781105",
"0.58559895",
"0.58521396",
"0.5841774",
"0.58397764",
"0.58287156",
"0.58229816",
"0.5816759",
"0.5807792",
"0.5768... | 0.74052256 | 0 |
Calc all kinds of properties for a line. The line should be an list of arrays. | def calc_output(line, react_cap=None, gen_res_high=225, gen_res_low=50):
# unpack
t, v, i = line
t_diff = t[1] - t[0]
# assert t_diff == 1e-9 # time scale should be 1ns.
# values based on current measurment. Assuming voltage waveform is aligned.
# validation on the real maxima/minima of curren... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_properties_sp(lines):\n\n # TODO Better logging for crashed xtb\n if not read_status(lines):\n return None\n\n keywords = [\n \"final structure:\",\n \":: SUMMARY ::\",\n \"Property Printout \",\n \"ITERATIONS\",\n ]\n... | [
"0.59829354",
"0.58867705",
"0.56100065",
"0.56093836",
"0.53970766",
"0.5322736",
"0.5254309",
"0.5200317",
"0.5133646",
"0.51039666",
"0.5046336",
"0.50146914",
"0.5009376",
"0.4989455",
"0.4974461",
"0.49629325",
"0.4949585",
"0.49364555",
"0.49333733",
"0.49223906",
"0.49... | 0.0 | -1 |
Show dialog of RETRY,SKIP,ABORT | def retryskipabort(message, timeout=20):
root = tk.Tk()
root.geometry("400x200")
root.title("Exception handle")
root.eval('tk::PlaceWindow %s center' % root.winfo_pathname(root.winfo_id()))
root.attributes("-topmost", True)
_kvs = {"result": "abort"}
def cancel_timer(*args):
root.a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def askContinue(parent,message,continueKey,title=_('Warning')):\r\n #--ContinueKey set?\r\n if _settings.get(continueKey): return wx.ID_OK\r\n #--Generate/show dialog\r\n dialog = wx.Dialog(parent,defId,title,size=(350,200),style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER)\r\n icon = wx.StaticBitmap(d... | [
"0.64992744",
"0.63597643",
"0.6132208",
"0.5936326",
"0.5899217",
"0.5896812",
"0.5886796",
"0.5824935",
"0.5818185",
"0.57966095",
"0.5755113",
"0.5753816",
"0.5747904",
"0.5747904",
"0.5747904",
"0.5747384",
"0.574394",
"0.57047844",
"0.5692576",
"0.56602055",
"0.5655979",... | 0.57067364 | 17 |
Retrieves users' notifications based on current `auth_token` | def get_notifications(
self,
all: bool = False,
participating: bool = False,
since: Optional[datetime] = None,
before: Optional[datetime] = None,
per_page: int = 10,
page: int = 1,
) -> List[Notification]:
raw_res = self._notifications(
all... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self):\n user_id = get_jwt_identity()\n user = find_user(user_id)\n\n args = pagination_parser.parse_args()\n return get_notifications(user, args['from_id'])",
"def get_user_notifications(self, login):",
"async def get_user_notifications(self):\n self._old_notificatio... | [
"0.72785807",
"0.70493317",
"0.6741458",
"0.6740879",
"0.638995",
"0.6368157",
"0.62646663",
"0.6193626",
"0.60971195",
"0.6062733",
"0.5904651",
"0.58698857",
"0.58336437",
"0.5826497",
"0.58177674",
"0.5768257",
"0.5741692",
"0.5732743",
"0.5713906",
"0.56797826",
"0.566113... | 0.54637754 | 28 |
API call for getting notifications | def _notifications(
self,
all: bool = False,
participating: bool = False,
since: Optional[datetime] = None,
before: Optional[datetime] = None,
page: int = 1,
per_page: int = 10,
) -> str:
headers = {
"Authorization": "token {}".format(self.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_notifications(self: object, *args, parameters: dict = None, **kwargs) -> dict:\n # [GET] https://assets.falcon.crowdstrike.com/support/api/swagger.html#/recon/GetNotificationsV1\n return process_service_request(\n calling_object=self,\n endpoints=Endpoints,\n ... | [
"0.7631317",
"0.70797265",
"0.7076586",
"0.695784",
"0.6907027",
"0.6840182",
"0.6796614",
"0.6696409",
"0.6680031",
"0.6636662",
"0.6489067",
"0.64789927",
"0.6347963",
"0.6330483",
"0.6290125",
"0.6276469",
"0.62763685",
"0.626309",
"0.6229939",
"0.61899424",
"0.6159832",
... | 0.6299571 | 14 |
Just a Hello World function | def hello():
return 'Hello, World!' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hello_world():\n\n return \"Hello World\"",
"def hello():\r\n return 'Hello World!'",
"def hello():\n print(\"Hello World\")",
"def hello():\n print(\"Hello World.\")",
"def print_hello_world():\n print(\"Hello World\")",
"def hello_world():\n return 'Hello World!'",
"def hello():... | [
"0.8689984",
"0.86293316",
"0.8605817",
"0.8595374",
"0.85618377",
"0.85127413",
"0.85047764",
"0.8472644",
"0.84356874",
"0.84356874",
"0.84356874",
"0.8434335",
"0.838036",
"0.83421856",
"0.833462",
"0.8314161",
"0.8306801",
"0.82825506",
"0.81582916",
"0.805908",
"0.799055... | 0.8384513 | 13 |
Function used to reinject values back into forms for accessing by themes | def build_custom_user_fields(
form_cls,
include_entries=False,
fields_kwargs=None,
field_entries_kwargs=None,
blacklisted_items=(),
):
if fields_kwargs is None:
fields_kwargs = {}
if field_entries_kwargs is None:
field_entries_kwargs = {}
fields = []
new_fields = Use... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def form_tweaks(self):\n pass",
"def _replace_fields(self):\n for name, value in self._cleaned_data.items():\n setattr(self, name, value)",
"def render_form():",
"def get_context_data(self, **kwargs):\n form_context = {}\n for form_key, form_class in self.get_form_class... | [
"0.7147261",
"0.62756866",
"0.5939157",
"0.57501096",
"0.5736135",
"0.57243216",
"0.5698981",
"0.55505884",
"0.55351985",
"0.5531961",
"0.55112284",
"0.54195195",
"0.54063284",
"0.539079",
"0.5381074",
"0.53664094",
"0.53374904",
"0.5327692",
"0.5265599",
"0.5257497",
"0.5251... | 0.0 | -1 |
Function used to attach form fields to wtforms. Not really a great solution but is approved by wtforms. | def attach_custom_user_fields(form_cls, **kwargs):
new_fields = UserFields.query.filter_by(**kwargs).all()
for field in new_fields:
validators = []
if field.required:
validators.append(InputRequired())
if field.field_type == "text":
input_field = StringField(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def form_CustomisedFormLayoutFields(request):\n schema = schemaish.Structure()\n schema.add( 'firstName', schemaish.String())\n schema.add( 'surname', schemaish.String())\n schema.add( 'age', schemaish.Integer())\n schema.add( 'sex', schemaish.String())\n\n form = formish.Form(schema, 'form')\n\n... | [
"0.698078",
"0.6600586",
"0.659325",
"0.6585638",
"0.6533927",
"0.6412825",
"0.6412825",
"0.6412825",
"0.629907",
"0.62634355",
"0.62466544",
"0.6142649",
"0.6102095",
"0.60763484",
"0.60400486",
"0.5991732",
"0.5991732",
"0.5946256",
"0.5897828",
"0.5873216",
"0.58706456",
... | 0.6660687 | 1 |
Build the appropriate field so we can render it via the extra property. Add field_type so Jinja knows how to render it. | def build_registration_code_field(form_cls):
if Configs.registration_code:
field = getattr(form_cls, "registration_code") # noqa B009
field.field_type = "text"
return [field]
else:
return [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render_field(field, bulk_nullable=False, label=None):\n return {\n 'field': field,\n 'label': label or field.label,\n 'bulk_nullable': bulk_nullable,\n }",
"def field_wrapper(field):\n return {'field': field}",
"def build_standard_field(self, field_name, model_field_type):\n ... | [
"0.6215978",
"0.6009022",
"0.5988297",
"0.59636",
"0.5934223",
"0.590157",
"0.5843997",
"0.58085185",
"0.5790124",
"0.5744198",
"0.5619677",
"0.56059074",
"0.5605764",
"0.55969447",
"0.55805063",
"0.55735326",
"0.55544263",
"0.55516434",
"0.55483365",
"0.5527651",
"0.5524747"... | 0.51042384 | 66 |
If we have a registration code required, we attach it to the form similar to attach_custom_user_fields | def attach_registration_code_field(form_cls):
if Configs.registration_code:
setattr( # noqa B010
form_cls,
"registration_code",
StringField(
"Registration Code",
description="Registration code required to create account",
v... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def registration(request, code=None):\n if request.method == \"POST\":\n form = RegistrationForm(request.POST)\n if form.is_valid():\n form.save()\n return redirect(\"confirm.html\")\n else:\n form = RegistrationForm()\n return render(request, 'registration.html'... | [
"0.6838169",
"0.66669655",
"0.6514536",
"0.6208826",
"0.6137646",
"0.6134475",
"0.6013371",
"0.6006505",
"0.6004355",
"0.5999936",
"0.5989894",
"0.5950262",
"0.59496284",
"0.5925366",
"0.59166074",
"0.58668554",
"0.58395535",
"0.5811587",
"0.5776874",
"0.5757824",
"0.57516545... | 0.78658634 | 0 |
Custom init to persist the obj parameter to the rest of the form | def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
obj = kwargs.get("obj")
if obj:
self.obj = obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs):\n\n self._obj = kwargs.get('obj', None)\n super(ModelForm, self).__init__(*args, **kwargs)",
"def __init__(self, obj, attribs):\n self.obj = obj\n self.attribs = attribs\n if self.obj:\n self._save()",
"def __init__(self... | [
"0.81270677",
"0.7214874",
"0.6869673",
"0.66981107",
"0.66653264",
"0.66653264",
"0.6648626",
"0.65440965",
"0.6481102",
"0.6445112",
"0.6415407",
"0.6336561",
"0.6326652",
"0.63131803",
"0.6255758",
"0.6211104",
"0.6211104",
"0.62063265",
"0.6182554",
"0.613536",
"0.6123644... | 0.7258114 | 1 |
Present the first document in the queue for labeling | def main():
return render_template('doc.html', docid=queue.pop(0)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def first(self):\n\t\tif self.is_empty():\n\t\t\traise Empty('Queue is empty')\n\t\treturn self._head._element",
"def first(self):\n if self.is_empty():\n raise ValueError('Queue is empty!')\n return self.root().element().value()",
"def first(self):\r\n if self.is_empty():\r\n ... | [
"0.59403706",
"0.5902959",
"0.57828766",
"0.5667334",
"0.56622183",
"0.5638245",
"0.56327254",
"0.5631978",
"0.5631978",
"0.56066155",
"0.56028295",
"0.55972004",
"0.55730265",
"0.5565737",
"0.55282176",
"0.55227655",
"0.55021554",
"0.5459005",
"0.545217",
"0.54516345",
"0.54... | 0.5553572 | 14 |
Present a particular document for labeling | def contract(docid):
return render_template('doc.html', docid=docid) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def XCAFDoc_DocumentTool_DocLabel(*args):\n return _XCAFDoc.XCAFDoc_DocumentTool_DocLabel(*args)",
"def DocLabel(*args):\n return _XCAFDoc.XCAFDoc_DocumentTool_DocLabel(*args)",
"def document(self):\n ...",
"def doc(docid):\n\t\n\tdata = {'id':docid,\n\t\t\t'text':\"Some made up text for class... | [
"0.6995251",
"0.6902461",
"0.6584978",
"0.63693833",
"0.6363506",
"0.6272244",
"0.6196975",
"0.59724045",
"0.59635377",
"0.58901525",
"0.586877",
"0.58180165",
"0.581586",
"0.5797789",
"0.57909936",
"0.5767639",
"0.57195663",
"0.5712125",
"0.5709976",
"0.5680226",
"0.5668638"... | 0.0 | -1 |
Build a queue of docs to be labeled Exclude those doc_cloud_ids that have already been labeled | def get_queue(filename):
build_queue = [q.replace("\n", "") for q in open(filename)]
build_queue = [l for l in build_queue\
if not os.path.exists(SETTINGS.XML_LOCATION + l + ".xml")]
build_queue = list(set(build_queue)) # dedupe
build_queue.sort(key=sort_have_labels)
return build_queu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_docs():\n docs = []\n for base_id in range(DOCUMENTS_PER_LEVEL):\n d = jina_pb2.Document()\n d.granularity = 0\n d.adjacency = 0\n d.id = base_id\n docs.append(d)\n iterate_build(d, 0, 2, 0, 2)\n return docs",
"def keep_documents(self, idx):\n p... | [
"0.56112474",
"0.5495247",
"0.53238213",
"0.52911776",
"0.52044696",
"0.5167606",
"0.51129067",
"0.5092232",
"0.5007754",
"0.5002671",
"0.50004286",
"0.49999186",
"0.4982563",
"0.4973685",
"0.49599707",
"0.4940291",
"0.49395326",
"0.4921682",
"0.4908651",
"0.49044877",
"0.489... | 0.51931 | 5 |
Labeled tokens come back from the UI as JSON. This method pulls them from the json and dumps | def get_labels():
json_request = request.json # get the json from the server
keys = sort_keys(json_request.keys()) # sort the keys (i.e. the token ids)
labels = []
for k in keys:
# get the labels that the user input to the UI
val = (json_request[k]['text'], json_request[k]['value'])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tokens_json(self):\n token_id, secret = self.decoded_token\n token_row = self.unauthenticated_token_row\n tokens_encoded = Fernet(secret).decrypt(\n token_row.tokens_fernet.encode('ascii'))\n return json.loads(tokens_encoded.decode('ascii'))",
"def tokens():\n pass",... | [
"0.5711956",
"0.55669457",
"0.5513183",
"0.54622537",
"0.52287966",
"0.5219712",
"0.5186664",
"0.51845807",
"0.5176791",
"0.5157778",
"0.5122742",
"0.51104176",
"0.5076709",
"0.5054146",
"0.50533843",
"0.5040823",
"0.5034359",
"0.502462",
"0.50213176",
"0.49873635",
"0.497497... | 0.65568817 | 0 |
The UI is requesting parserator's tags. If they've been processed, send them to client side Else, send a bunch of blank tags | def tags(docid):
page = request.args.get('page')
filename = SETTINGS.LABELED_LOCATION + '/' + docid
page_text = get_document_page(docid, page)
if not os.path.isfile(filename):
return spanify(page_text, page)
else:
with open(filename) as tokens_file:
labels = json.load(tok... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_tag_list(self, taglist):\r\n self.do_before()\r\n for tag in taglist:\r\n self.feed(tag)\r\n self.do_after()",
"def get_all_tags():\n try:\n data = ReadTag().run()\n except Exception as ex:\n return jsonify({'code': '500','message':'Internal server ... | [
"0.594429",
"0.57760024",
"0.57655793",
"0.5725321",
"0.5628237",
"0.56022376",
"0.55851656",
"0.55792296",
"0.5511034",
"0.55045795",
"0.54749936",
"0.545959",
"0.545458",
"0.5436897",
"0.54287684",
"0.54231405",
"0.5336545",
"0.52850664",
"0.5254251",
"0.5225636",
"0.522103... | 0.0 | -1 |
The UI is sending tagged tokens back to the server. Save them to train parserator | def tokens_dump(docid):
tagged_strings = set()
labels = get_labels()
tagged_sequence = labels # replacing prep_inputs method. still works?
tagged_strings.add(tuple(tagged_sequence))
outfile = SETTINGS.XML_LOCATION + "/" + docid + ".xml"
try:
os.remove(outfile)
except OSError:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse(self, tokenizer):\n pass",
"def __init__(self):\n self.tokens = []",
"def tokenize(self):\n\n x = [] # input documents\n for file_path in glob.glob(self.train_dir + '*.txt'):\n file_as_string = open(file_path).read()\n x.append(file_as_string)\n\n self.tokenizer.fit_o... | [
"0.61516076",
"0.6044435",
"0.5898327",
"0.5834319",
"0.58167106",
"0.5813318",
"0.5673961",
"0.5612146",
"0.5571863",
"0.55666846",
"0.55541897",
"0.5546777",
"0.553209",
"0.5514731",
"0.5511445",
"0.5496212",
"0.5490531",
"0.54755586",
"0.54755586",
"0.54755586",
"0.5452871... | 0.5427992 | 23 |
A custom sort. Favors cases where there are already labels for the tokens from parserator. For big corpuses, parsing takes time so you don't want to parse the whole corpus just to see how it is doing | def sort_have_labels(doc_cloud_id):
filename = SETTINGS.LABELED_LOCATION + "/" + doc_cloud_id
if os.path.isfile(filename):
return 0
return 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sorting(tokens: list):\n tokens.sort(key=lambda x: (x[0], x[1]))",
"def sort_tokens(tokens: Iterable[Cwf]) -> List[Cwf]:\n return sorted(tokens, key=lambda t: (t.get_sent(), int(t.get_offset())))",
"def sort_by_tokens(self, token_order):\n\n remaining_tokens = list(set(self.dictionary.tok... | [
"0.6858186",
"0.6613914",
"0.657223",
"0.64046764",
"0.640126",
"0.63479173",
"0.62306327",
"0.6093973",
"0.6057724",
"0.59947205",
"0.59803766",
"0.5903831",
"0.5857513",
"0.5817867",
"0.5800997",
"0.57934964",
"0.5732152",
"0.57284874",
"0.57194114",
"0.5718229",
"0.5717523... | 0.0 | -1 |
Allows the user to change his/her password. If the existing password matches, and both new password fields match, then the password is changed. A ?next=/... query parameter can be added, so after the password is changed, the user is redirected back to the original referring page. | def password_req(request):
next = request.POST.get('next',
request.META.get('HTTP_REFERER',
DEFAULT_REDIRECT))
args = default_context(request, username=request.user.username, next=next)
try:
password = request.POST['password']
pw1 = request.POST['pw1']
pw2 = request.POST['pw2']
exc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def change_password(self, old_password, new_password):\n data = dict(password = new_password)\n data['old-password'] = old_password\n return self.app.post('/_changePassword', data = data, follow_redirects = True)",
"def change_password():\n form = PasswordResetForm()\n\n if form.valida... | [
"0.7684161",
"0.7678293",
"0.7636813",
"0.7593512",
"0.7537619",
"0.7510125",
"0.75019175",
"0.748036",
"0.7474108",
"0.7473725",
"0.74614745",
"0.7304231",
"0.7270338",
"0.72622114",
"0.72228485",
"0.7220767",
"0.72164667",
"0.71916544",
"0.7117814",
"0.71164465",
"0.7103846... | 0.7167825 | 18 |
Handles the 'forgotten password' form. The user can ask for a specific username to be reset. The user can also specify an email address instead of a username. An email containing encrypted and signed links is sent to the particular email address. There is no difference in the output if 0, 1, or many users are found mat... | def forgot_req(request):
server = request.META['SERVER_NAME']
recover_url = urljoin(full_url(request), 'recover')
if request.POST and not request.user.is_authenticated():
try:
username_or_email = request.POST['username']
except KeyError:
pass
else:
if '@' in username_or_email:
qs = User... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forgot_password():\n if request.method == 'POST':\n if 'username' in request.form:\n username = request.form['username']\n user = Users.query.get(username)\n if user:\n reset_slug = utils.encrypt(username)\n reset_url = request.host_url +... | [
"0.8209941",
"0.7987478",
"0.7894088",
"0.7582648",
"0.7481974",
"0.744047",
"0.7361025",
"0.73203427",
"0.7314185",
"0.7305841",
"0.73045814",
"0.72920185",
"0.72777385",
"0.71073365",
"0.7094137",
"0.703783",
"0.7018474",
"0.7012398",
"0.69860375",
"0.6957978",
"0.6949704",... | 0.7435538 | 6 |
Allows the user to change his/her password. | def recover_req(request):
query_string = request.META['QUERY_STRING']
query_args = parse_qs(get_encrypted_query_string(query_string,
settings.SECRET_KEY))
template_map = dict(META = request.META,
enc = request.GET['enc'],
hmac = request.GET['hmac'],
root = settings.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def change_password(self, new_pass):\n self.manager.change_user_password(self, new_pass)",
"def ChangePassword():\n if self.ChangePassword():\n # Update successful, return to main screen\n self.confirm_pass.set('')\n self.password.set('')\n ... | [
"0.8333886",
"0.8186766",
"0.8097396",
"0.7924953",
"0.79134744",
"0.79105085",
"0.7877887",
"0.78761387",
"0.7860327",
"0.784283",
"0.7838352",
"0.78312457",
"0.78055656",
"0.7788097",
"0.77424246",
"0.77323174",
"0.77305025",
"0.7709434",
"0.7682401",
"0.76711226",
"0.76426... | 0.0 | -1 |
Cancels a user session. Puts up the login form. | def logout_req(request):
if request.user.is_authenticated():
logout(request)
return render_to_response('registration/login.html',
dict(next = DEFAULT_REDIRECT,
META = request.META,
root = settings.ROOT_URL,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def signout(self):\n username = cherrypy.session.get('username')\n if username is None:\n pass\n else:\n cherrypy.lib.sessions.expire()\n raise cherrypy.HTTPRedirect('/')",
"def logout():\r\n form = LoginForm()\r\n user = current_user\r\n user.authentica... | [
"0.7182822",
"0.69931966",
"0.69211394",
"0.67985123",
"0.67923224",
"0.6713557",
"0.66810346",
"0.6674477",
"0.6670308",
"0.66364765",
"0.66233695",
"0.6603241",
"0.65926504",
"0.6584644",
"0.65809464",
"0.6569001",
"0.6568214",
"0.65630865",
"0.65387446",
"0.6528097",
"0.65... | 0.0 | -1 |
Create an object from its rdf type | def oid(identifier_or_rdf_type, rdf_type, context, base_type=None):
identifier = identifier_or_rdf_type
if rdf_type is None:
rdf_type = identifier_or_rdf_type
identifier = None
cls = None
if context is not None:
cls = context.resolve_class(rdf_type)
if cls is None and conte... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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... | [
"0.6613706",
"0.62533885",
"0.5993754",
"0.5973116",
"0.59641635",
"0.59002733",
"0.58277136",
"0.58260673",
"0.5804339",
"0.579951",
"0.57783437",
"0.5778184",
"0.5754997",
"0.56360924",
"0.56325865",
"0.56170595",
"0.5612792",
"0.55933315",
"0.55877227",
"0.5579284",
"0.557... | 0.5583555 | 19 |
Load dataset from csv file | def load_simulator_data(self, csvfname):
data = []
with open(csvfname, 'r') as csvfile:
data_tmp = list(csv.reader(csvfile, delimiter=','))
for row in data_tmp:
x7 = [float(x) for x in row[7].split(':')]
x8 = [float(x) for x in row[8].split(':')]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_dataset(path):\n training_data = []\n with open(path) as csv_file:\n reader = csv.reader(csv_file, delimiter=\",\")\n next(reader)\n for row in reader:\n training_data.append(row[1])\n return training_data",
"def loadCSV(input_file):",
"def load():\n filepat... | [
"0.7754483",
"0.77290475",
"0.7686873",
"0.76696587",
"0.75522053",
"0.74628526",
"0.7399509",
"0.7380369",
"0.7370351",
"0.7362085",
"0.72771174",
"0.7227899",
"0.72193736",
"0.7215024",
"0.72012967",
"0.7180689",
"0.71734875",
"0.7173242",
"0.7164557",
"0.7121014",
"0.71139... | 0.0 | -1 |
Gets info about all datasets. Returns str with MarkDown syntax | def get_info() -> str:
req = Request(URL + '/info')
context = ssl._create_unverified_context()
with urlopen(req, context=context) as response:
return response.read().decode('utf-8') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_datasets():\n return METADATA.keys()",
"def info(self, datasets=(), tasks=()):\n pp = pprint.PrettyPrinter(indent=4)\n print_text_box('Dataset')\n if any(datasets) or any(tasks):\n data = self._get_select_tasks_and_datasets_data(datasets, tasks)\n else:\n ... | [
"0.7014192",
"0.6812912",
"0.6607309",
"0.65944916",
"0.64315784",
"0.6382068",
"0.636666",
"0.63273066",
"0.63251984",
"0.6180837",
"0.6164181",
"0.61418563",
"0.61337954",
"0.61007583",
"0.6100278",
"0.6081731",
"0.60703063",
"0.60678405",
"0.60557",
"0.6037266",
"0.6016712... | 0.0 | -1 |
Load dataset by dataset_name. Run get_info() to get dataset information | def load_dataset(dataset_name: str, internals_folder_path: str = None) -> Dataset:
dataset_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), dataset_name)
if glob(dataset_path + '*'):
return Dataset(glob(dataset_path + '*')[0], internals_folder_path=internals_folder_path)
req = Reque... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load(name):\n if name in datasets:\n\n return pd.read_csv(os.path.join(datasets_path, \"%s.csv\" % name))\n else:\n raise ValueError(\"Dataset not found!\")",
"def load_dataset(dataset_name):\n url = METADATA[dataset_name][\"url\"]\n f = urlopen(url)\n data = _read_rows(f)\n f... | [
"0.77818465",
"0.7501332",
"0.7296937",
"0.7217461",
"0.71556944",
"0.70442104",
"0.7043356",
"0.7002447",
"0.69755036",
"0.69738203",
"0.6970711",
"0.6962691",
"0.6954843",
"0.69172084",
"0.69021535",
"0.68848944",
"0.6871628",
"0.6846385",
"0.68101037",
"0.6778666",
"0.6768... | 0.69610137 | 12 |
Creates a GSEA analysis This GSEA implementation is based on gseaPy. | def __init__(self, data_source, num_resamples=NUM_RESAMPLES, method=GSEA_RANKING_SNR, case=None, control=None,
preprocessors=None):
logger.debug('GSEA initialised with num_resamples=%d and ranking_method=%s' % (num_resamples, method))
super().__init__(data_source, preprocessors=preproce... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _run_gsea(self, gct_file, gmt_file, cls_file, gsea_dir):\n r = robjects.r\n r.source(self.gsea_r_location)\n r(\"\"\"GSEA( # Input/Output Files :-------------------------------------------\n input.ds = \"{}\", # Input gene expressi... | [
"0.6862905",
"0.59698844",
"0.5741826",
"0.5694374",
"0.5569399",
"0.55237055",
"0.5385206",
"0.53803694",
"0.5294734",
"0.5274186",
"0.5242113",
"0.51879853",
"0.5178812",
"0.5157552",
"0.51452965",
"0.51294",
"0.5125397",
"0.5094075",
"0.50884384",
"0.5040239",
"0.4964143",... | 0.49073586 | 23 |
Main method to perform GSEA/MSEA analysis | def get_results(self, preprocess=True):
logger.debug('Calculating GSEA')
measurement_df = self._get_measurement_df(preprocess)
annot_df = self.data_source.get_annotations()
joined = pd.merge(left=measurement_df, right=annot_df, left_index=True, right_index=True)
joined = joined.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\r\n graphPerformance = False # Built in graphing ability, currently not functional, but mechanism is in place.\r\n trainData = \"2_1000_0_1600_0_0_CV_0_Train.txt\"\r\n testData = \"2_1000_0_1600_0_0_CV_0_Test.txt\"\r\n outProg = \"GH_GALE_ProgressTrack\"\r\n outPop = \"GH_GALE_Population... | [
"0.71552646",
"0.67432594",
"0.6589852",
"0.65624803",
"0.6458963",
"0.6455297",
"0.64501965",
"0.63569146",
"0.6244363",
"0.62363696",
"0.6217135",
"0.6186109",
"0.6183862",
"0.6182799",
"0.6166517",
"0.61521643",
"0.61434954",
"0.6135868",
"0.6134632",
"0.6118668",
"0.61104... | 0.6480827 | 4 |
forward procedure. No need for inputs to be sorted | def forward(self, input_seqs, input_lens, hidden=None):
batch_size = input_seqs.size(1)
embedded = self.embedding(input_seqs)
embedded = embedded.transpose(0, 1) # [B,T,E]
sort_idx = np.argsort(-input_lens)
unsort_idx = cuda_(torch.LongTensor(np.argsort(sort_idx)))
input... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self, input):\n raise NotImplementedError",
"def forward(self, input):\n raise NotImplementedError",
"def forward(self, inputs):\n raise NotImplementedError",
"def forward(self, input):\n raise NotImplementedError()",
"def forward(self, *inputs):\n raise NotIm... | [
"0.7305762",
"0.7305762",
"0.72925854",
"0.71346843",
"0.70455575",
"0.69174004",
"0.6737259",
"0.6706367",
"0.665543",
"0.6645303",
"0.6645303",
"0.6637352",
"0.66037333",
"0.6563919",
"0.6515652",
"0.6515652",
"0.6511204",
"0.64887595",
"0.64721954",
"0.6462899",
"0.6424968... | 0.0 | -1 |
Used in ``mezzanine.pages.views.page`` to ensure ``PageMiddleware`` or a subclass has been installed. We cache the result on the ``PageMiddleware._installed`` to only run this once. | def installed(cls):
try:
return cls._installed
except AttributeError:
name = "mezzanine.pages.middleware.PageMiddleware"
installed = middlewares_or_subclasses_installed([name])
setattr(cls, "_installed", installed)
return installed | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Install (self):\n if self in sys.meta_path:\n return\n sys.meta_path.insert (0, self)",
"def is_installed(self):\n pass",
"def pre_installation(self):\n pass",
"def autodiscover():\n from django.utils.importlib import import_module\n global LOADED\n if LOAD... | [
"0.5708004",
"0.5457926",
"0.53875947",
"0.5337035",
"0.53081757",
"0.5224973",
"0.52124566",
"0.5208954",
"0.51006395",
"0.5072566",
"0.5057796",
"0.5034346",
"0.5021708",
"0.50119513",
"0.5004418",
"0.5003487",
"0.4994785",
"0.49845058",
"0.49206704",
"0.49062628",
"0.49048... | 0.8444131 | 0 |
Perrequest mechanics for the current page object. | def process_view(self, request, view_func, view_args, view_kwargs):
# Load the closest matching page by slug, and assign it to the
# request object. If none found, skip all further processing.
slug = path_to_slug(request.path_info)
pages = Page.objects.with_ascendants_for_slug(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self):\r\n self.init_data = td.import_data(self.__module__)\r\n self.page1() # GET navigation (requests 101-153)\r\n\r\n grinder.sleep(20)\r\n self.page2() # GET case (requests 201-252)\r\n\r\n grinder.sleep(20)\r\n self.page3() # GET view (requ... | [
"0.7065218",
"0.6655661",
"0.6454575",
"0.6180861",
"0.6127758",
"0.59273225",
"0.58338803",
"0.5830356",
"0.579896",
"0.57571733",
"0.5753007",
"0.56619835",
"0.5652793",
"0.557103",
"0.5565266",
"0.55646205",
"0.5558261",
"0.5553076",
"0.5551274",
"0.5549091",
"0.552509",
... | 0.0 | -1 |
Checks if an object is a number. That is, a ``float`` or an ``int``. Where this differs from simply checking if an object is an instance of ``numbers.Number`` is that boolean objects are also a number by that measure (which, technically, | def is_numeric(number):
if isinstance(number, bool):
return False
elif isinstance(number, int) or isinstance(number, float):
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isNumeric(obj):\n # type: (Any) -> bool\n return isinstance(obj, numbers.Number)",
"def isNumeric(obj):\n return isinstance(obj, (int, float, bool))",
"def is_numeric(obj):\n return isinstance(obj, (int, float, complex))",
"def is_number(x):\n if isinstance(x, (int, float)):\n r... | [
"0.84229404",
"0.8354426",
"0.80287915",
"0.8011571",
"0.79731923",
"0.7880432",
"0.78278196",
"0.78255373",
"0.7822248",
"0.7775982",
"0.7771816",
"0.76862437",
"0.7623797",
"0.76032704",
"0.7492383",
"0.74228925",
"0.7375729",
"0.7342082",
"0.73297185",
"0.7325915",
"0.7303... | 0.75077426 | 14 |
Checks if all the arguments it receives are numeric (according to | def are_numeric(*values):
for value in values:
if not is_numeric(value):
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_arguments(arguments):\n quit = False\n for argument, value in vars(arguments).items():\n try:\n float(value)\n except:\n print(\"{} must be numeric\".format(argument))\n quit = True\n if quit:\n exit(1)",
"def check_for_float_and_int(check)... | [
"0.79766375",
"0.72621953",
"0.7188788",
"0.7124984",
"0.7036451",
"0.7026137",
"0.6995436",
"0.69920516",
"0.6922569",
"0.6913737",
"0.68856776",
"0.68640095",
"0.68215996",
"0.67944366",
"0.6732328",
"0.6717718",
"0.6717057",
"0.6711378",
"0.664611",
"0.6630572",
"0.6597417... | 0.7544063 | 1 |
Drop the unit definition silently | def _drop_units(q):
try:
return q.magnitude
except:
return q | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def removeUnitDefinition(self, *args):\n return _libsbml.Model_removeUnitDefinition(self, *args)",
"def unsetName(self):\n return _libsbml.UnitDefinition_unsetName(self)",
"def unsetKind(self):\n return _libsbml.Unit_unsetKind(self)",
"def removeUnit(self, *args):\n return _libsbm... | [
"0.7016923",
"0.671953",
"0.65005463",
"0.6406769",
"0.6294587",
"0.6132818",
"0.61080724",
"0.61080724",
"0.6019801",
"0.6007988",
"0.5972027",
"0.58067775",
"0.5797811",
"0.5779521",
"0.5779516",
"0.5762775",
"0.574033",
"0.57371294",
"0.57115144",
"0.5674466",
"0.5610218",... | 0.61350024 | 5 |
Adapt the resolution of the spectra to match the lick definitions Lick definitions have different resolution elements as function of wavelength. These definition are hardcoded in this function | def reduce_resolution(wi, fi, fwhm0=0.55, sigma_floor=0.2):
# all in AA
w_lick_res = (4000., 4400., 4900., 5400., 6000.)
lick_res = (11.5, 9.2, 8.4, 8.4, 9.8) # FWHM in AA
w = np.asarray(wi)
flux = np.atleast_2d(fi)
# Linear interpolation of lick_res over w
# numpy interp does constant ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_resolution( self ):\r\n offset = 0\r\n # if current and skinned resolutions differ and skinned resolution is not\r\n # 1080i or 720p (they have no 4:3), calculate widescreen offset\r\n if ( ( not ( self.currentResolution == self.resolution ) ) and self.resolution > 1 ):\r\n ... | [
"0.6454344",
"0.62690383",
"0.58017045",
"0.57871443",
"0.5685021",
"0.56665695",
"0.5640041",
"0.5633661",
"0.56125605",
"0.5611095",
"0.55840474",
"0.55816716",
"0.5537546",
"0.55354196",
"0.54867184",
"0.54815644",
"0.5469447",
"0.54505324",
"0.5441042",
"0.5431353",
"0.54... | 0.0 | -1 |
return a dictionary of the current index | def to_dict(self):
d = {}
d.update(**self._lick)
return d | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index(self):\n return dict(data='index')",
"def _get_index(self):\n\n return self.index\n\n # to avoid having differences bigger than 2pi",
"def index(self):\n return self._index",
"def index(self):\n path = self.path.format('index')\n \n with open(path, 'r', ... | [
"0.7655854",
"0.71581787",
"0.7109777",
"0.7092145",
"0.6977287",
"0.6977287",
"0.6973881",
"0.69227993",
"0.6913379",
"0.6897256",
"0.68841493",
"0.6860583",
"0.68244886",
"0.68158996",
"0.6750094",
"0.67243034",
"0.67243034",
"0.67243034",
"0.67243034",
"0.67243034",
"0.672... | 0.0 | -1 |
return the unitwise definition corresponding to attrname | def _get_wavelength_attrs_with_units(self, attrname, units='AA'):
attr = self._lick[attrname]
if self.wavelength_unit is not None:
if units is None:
return attr * unit[self.wavelength_unit]
else:
return (attr * unit[self.wavelength_unit]).to(units)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_wavelength_attrs_with_units(self, attrname, units='AA'):\n attr = self._lick[attrname]\n if self.wavelength_unit is not None:\n if units is None:\n return attr * Unit(self.wavelength_unit)\n else:\n return (attr * Unit(self.wavelength_unit)... | [
"0.63725454",
"0.60422206",
"0.5772077",
"0.57339555",
"0.5650211",
"0.5626752",
"0.5624979",
"0.55762106",
"0.55762106",
"0.5543511",
"0.55427015",
"0.55405295",
"0.5533721",
"0.5516388",
"0.54795426",
"0.5476638",
"0.5459001",
"0.5459001",
"0.5439841",
"0.54318297",
"0.5421... | 0.6441973 | 0 |
display information about the current Index | def info(self):
txt = """Lick Index {s.name}
wavelength units: {s.wavelength_unit}
Index Band: {s.band}
Blue continuum band: {s.blue}
Red continuum band: {s.red}
Measurement unit: {s.index_unit}""".format(s=self)
print(txt) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index(self):\r\n return None",
"def get_info_format(self):\n return self.session.api.get_index(self)",
"def show_elasticsearch_index_info(cluster: str, index: str):\n\n elastic = sreElastic(host=cluster)\n pp = pprint.PrettyPrinter(indent=2, width=120)\n\n print(\"\\nLocation:\")\n ... | [
"0.7144294",
"0.6980231",
"0.6847654",
"0.68377274",
"0.67996037",
"0.67142814",
"0.6706408",
"0.6706408",
"0.66565186",
"0.66213363",
"0.6611364",
"0.65879714",
"0.65692246",
"0.65692246",
"0.65692246",
"0.65692246",
"0.65692246",
"0.65692246",
"0.65692246",
"0.65692246",
"0... | 0.6661338 | 9 |
compute spectral index after continuum subtraction | def __call__(self, *args, **kwargs):
return self.get(*args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_spectral_index(self):\n try:\n return self.alpha\n except AttributeError:\n return None",
"def refractive_index_fused_silica(wavelength):\n wavelength_um = wavelength / 1000\n\n A0 = 2.104025406E+00\n A1 = -1.456000330E-04\n A2 = -9.049135390E-03\n A3 = ... | [
"0.6287062",
"0.6141436",
"0.59078664",
"0.58944124",
"0.58218056",
"0.5802506",
"0.5760204",
"0.5752179",
"0.5743206",
"0.57092756",
"0.5689199",
"0.5686934",
"0.56437397",
"0.5623954",
"0.5587823",
"0.5585669",
"0.5536266",
"0.5534484",
"0.5534108",
"0.5532117",
"0.55112505... | 0.0 | -1 |
compute spectral index after continuum subtraction | def get(self, wave, flux, **kwargs):
if hasUnit(wave):
_w = wave.to('AA').magnitude
else:
print("Warning: assuming units are in Angstroms")
_w = _drop_units(wave)
_f = _drop_units(flux)
blue = self._get_wavelength_attrs_with_units('blue').magnitude
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_spectral_index(self):\n try:\n return self.alpha\n except AttributeError:\n return None",
"def refractive_index_fused_silica(wavelength):\n wavelength_um = wavelength / 1000\n\n A0 = 2.104025406E+00\n A1 = -1.456000330E-04\n A2 = -9.049135390E-03\n A3 = ... | [
"0.6287113",
"0.6141516",
"0.59084785",
"0.5892982",
"0.58204657",
"0.58018076",
"0.5760177",
"0.5751786",
"0.5741839",
"0.57074076",
"0.5688546",
"0.5685407",
"0.5644722",
"0.5622003",
"0.55865675",
"0.5584795",
"0.55340075",
"0.55338055",
"0.55332595",
"0.5530644",
"0.55118... | 0.0 | -1 |
compute spectral index after continuum subtraction | def _get_indice(cls, w, flux, blue, red, band=None, unit='ew', degree=1,
**kwargs):
wi, fi = cls.continuum_normalized_region_around_line(w, flux, blue,
red, band=band,
de... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_spectral_index(self):\n try:\n return self.alpha\n except AttributeError:\n return None",
"def refractive_index_fused_silica(wavelength):\n wavelength_um = wavelength / 1000\n\n A0 = 2.104025406E+00\n A1 = -1.456000330E-04\n A2 = -9.049135390E-03\n A3 = ... | [
"0.6286422",
"0.61412746",
"0.59083164",
"0.58922887",
"0.58213574",
"0.580119",
"0.57615376",
"0.5752075",
"0.5741933",
"0.5708254",
"0.56879544",
"0.56858265",
"0.56429803",
"0.56224555",
"0.55869263",
"0.558585",
"0.55347013",
"0.5534027",
"0.5532789",
"0.553044",
"0.55096... | 0.0 | -1 |
cut out and normalize flux around a line | def continuum_normalized_region_around_line(cls, wi, fi, blue, red, band=None,
degree=1):
w = np.asarray(wi)
flux = np.atleast_2d(fi)
# index is true in the region where we fit the polynomial
indcont = (((w >= blue[0]) & (w <= blue[1])) |
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def line_lum(line_flux, dist): \n line_lum = 4 * pi * (dist*u.pc)**2 * line_flux * u.erg / (u.s * (u.cm)**2)\n line_lum = line_lum.decompose().to(u.W)\n return line_lum/u.W",
"def normalize_vector(line):\n if isinstance(line, pd.DataFrame):\n line = line.values\n try:\n n = np.sqr... | [
"0.6464081",
"0.59551424",
"0.58137214",
"0.5795742",
"0.5787084",
"0.57819617",
"0.57134414",
"0.5706386",
"0.56656975",
"0.5642102",
"0.56365347",
"0.55645335",
"0.5524223",
"0.5506707",
"0.54946476",
"0.5492588",
"0.54654",
"0.5452259",
"0.5443912",
"0.54263026",
"0.541494... | 0.51007783 | 57 |
any comment in the input file | def description(self):
return self._hdr | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_comments(self):\n fp = FilePath(self.mktemp())\n fp.setContent('something\\n#commented\\ncool')\n self.assertEqual(list(inventoryReader(fp.path)), ['something', 'cool'])",
"def skip_comments(filepointer):\n\tcomments = []\n\tdata = '#'\n\ttry:\n\t\tpos = filepointer.tell()\n\texcept... | [
"0.7160076",
"0.6916625",
"0.6867486",
"0.6765558",
"0.6749642",
"0.6743258",
"0.6716404",
"0.670146",
"0.6650719",
"0.65236187",
"0.64683205",
"0.64683205",
"0.64408094",
"0.6426981",
"0.6329149",
"0.63261276",
"0.6201037",
"0.6192405",
"0.61553055",
"0.6140866",
"0.613756",... | 0.0 | -1 |
read the list of lick indices | def _read_lick_list(cls, fname=__default__, comment='#'):
with open(fname, 'r') as f:
data = {}
hdr = []
for line in f:
if line[0] != comment:
l = line.split()
attr = dict(
band=(float(l[1]), floa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _read_indices(path):\n paths = sorted(tf.io.gfile.glob('%s-*-of-*_index.json' % path))\n all_indices = []\n for path in paths:\n json_str = epath.Path(path).read_text()\n # parse it back into a proto.\n shard_index = json.loads(json_str)\n all_indices.append(list(shard_index['index']))\n return... | [
"0.64467746",
"0.6441595",
"0.6411123",
"0.63643146",
"0.6275804",
"0.6236173",
"0.6204214",
"0.6117496",
"0.6063966",
"0.6062045",
"0.60506487",
"0.59956235",
"0.59590757",
"0.59548295",
"0.5933144",
"0.59210235",
"0.59165895",
"0.5916158",
"0.59155154",
"0.588967",
"0.58896... | 0.0 | -1 |
Size of the library | def __len__(self):
return len(self.content) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __get_size(self):\n\t\treturn 4*self.version + 17",
"def get_size(self):",
"def getSize(self) -> long:\n ...",
"def get_size(self):\n ...",
"def getSize(self) -> int:\n ...",
"def getSize(self) -> int:\n ...",
"def calc_size(self):\r\n pass",
"def size(self):\n ... | [
"0.80670005",
"0.7656748",
"0.76485074",
"0.74939597",
"0.7419034",
"0.7419034",
"0.74108195",
"0.7401268",
"0.73442686",
"0.7325931",
"0.7315922",
"0.72330016",
"0.72330016",
"0.72330016",
"0.72193474",
"0.7187202",
"0.71814",
"0.7137367",
"0.7112294",
"0.70785505",
"0.70591... | 0.0 | -1 |
Make this object like a dictionary and load one or multiple filters | def __getitem__(self, name):
with self as s:
try:
f = s._load_filter(name)
except TypeError:
f = [s._load_filter(k) for k in name]
return f | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filters(self):\n filters = IterDict()\n for key in self.FILTERS:\n filter = IterDict()\n filter_param = ((self.prefix or '') + '-' + key).strip('-')\n\n for value, display in self.fields[key].choices:\n choice = {}\n choice['value'] =... | [
"0.69429255",
"0.68280834",
"0.678945",
"0.67390245",
"0.6707644",
"0.6680645",
"0.66653675",
"0.664991",
"0.66167235",
"0.6582854",
"0.6568152",
"0.6519853",
"0.6499183",
"0.64964235",
"0.64200693",
"0.6409539",
"0.6404884",
"0.63648516",
"0.6337536",
"0.62964696",
"0.627265... | 0.6210194 | 24 |
Load a given filter from the library | def _load_filter(self, fname, **kwargs):
with self as s:
return LickIndex(fname, s._content[fname]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loadFilterFromString(spec):\n return _loadPluginFromString(spec, \"ufo2ft.filters\", isValidFilter)",
"def _load_filter(self, *args, **kwargs):\n raise NotImplementedError",
"def _load_filter(self, fname, interp=True, lamb=None):\n ftab = self.hdf\n if hasattr(fname, 'decode'):\n ... | [
"0.7596461",
"0.73965544",
"0.70921934",
"0.6901158",
"0.6694745",
"0.6442038",
"0.6273887",
"0.6259627",
"0.62564397",
"0.6248318",
"0.623958",
"0.62291145",
"0.6115416",
"0.6082468",
"0.6026562",
"0.59056175",
"0.5899553",
"0.5848221",
"0.58212197",
"0.5782896",
"0.57552046... | 0.6228943 | 12 |
Scan for independent loops and set up dictionaries. | def main(self, verbose=0):
indepdict=self.scan_for_loop(self.indeploop)
pegdict1 = self.scan_for_loop(self.pegloop1)
pegdict2 = self.scan_for_loop(self.pegloop2)
if len(indepdict.keys()) == 0 and len(pegdict1.keys()) == 0 and len(pegdict2.keys()) == 0:
return dict()
a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prepare_looped_datasets(self, alldict, allcombs):\n datasets_dict=dict()\n numcombs = len(allcombs)\n combct = 0\n while combct < numcombs:\n newdata = list(self.baseinput.data)\n loopedlines = dict()\n loopedlines = self.prepare_looped_lines(alldict... | [
"0.60553885",
"0.5839073",
"0.5820277",
"0.5816718",
"0.5751431",
"0.5579861",
"0.5559903",
"0.55534524",
"0.5551435",
"0.55467737",
"0.5465791",
"0.5446664",
"0.54339755",
"0.54255664",
"0.53983235",
"0.5374087",
"0.53734773",
"0.53571624",
"0.53484",
"0.53369623",
"0.533300... | 0.59351087 | 1 |
Prepare a combination list of looping indices. | def get_combo_list(self, loopdict, pegged=0):
combolist=list()
flatlists=list()
loopkeys = list(loopdict.keys())
loopkeys.sort()
if pegged == 0:
for loopkey in loopkeys:
numloop = len(loopdict[loopkey]['looplist'])
loopct=0
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_index_iterator(indexes, length):\n return combinations(indexes, length)",
"def construct_indices(after_pooling):\n our_indices = np.zeros_like(after_pooling, dtype=np.int64)\n batch_num, channel_num, row_num, col_num = after_pooling.shape\n for batch_id in range(batch_num):\n for ... | [
"0.6275713",
"0.6154315",
"0.6077849",
"0.6049278",
"0.5934963",
"0.5888981",
"0.5846226",
"0.5782302",
"0.57822573",
"0.5774816",
"0.5757438",
"0.57275736",
"0.56466776",
"0.56323755",
"0.56219804",
"0.55682474",
"0.5567099",
"0.5565119",
"0.55425763",
"0.54685265",
"0.54512... | 0.51132363 | 60 |
Combine two pegged lists and one independent list. | def combine_three_combo_lists(self, indeplist, peglist1, peglist2):
templist=list()
threelist=list()
templist = self.combine_combo_lists(indeplist, peglist1)
threelist = self.combine_combo_lists(templist, peglist2)
return threelist | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge_lists(l1, l2):\n return [ *l1, *l2 ]",
"def _merge_lists(cls, li1, li2):\n if not li1:\n return li2[:]\n elif not li2:\n return li1[:]\n else:\n li = li1[:]\n for el in li2:\n if el not in li:\n li.app... | [
"0.7555634",
"0.7349701",
"0.7179665",
"0.70421684",
"0.6992282",
"0.6892206",
"0.6813232",
"0.68128705",
"0.6796102",
"0.67734545",
"0.6721897",
"0.6630253",
"0.6618824",
"0.65558565",
"0.6551609",
"0.6527701",
"0.64997417",
"0.64883775",
"0.64660096",
"0.6453299",
"0.642906... | 0.6404212 | 23 |
Prepare looped lines from looping dictionary. | def prepare_looped_lines(self, alldict, comblist):
loopline_dict=dict()
for stridx in comblist:
lidx = int(stridx.split('-')[0])
loopidx = int(stridx.split('-')[1])
loopline_dict[lidx] = alldict[lidx]['prepend'] + alldict[lidx]['looplist'][loopidx].strip() + alldict[... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prepare_looped_datasets(self, alldict, allcombs):\n datasets_dict=dict()\n numcombs = len(allcombs)\n combct = 0\n while combct < numcombs:\n newdata = list(self.baseinput.data)\n loopedlines = dict()\n loopedlines = self.prepare_looped_lines(alldict... | [
"0.62352186",
"0.5535244",
"0.540953",
"0.538531",
"0.53788745",
"0.5370846",
"0.53634304",
"0.5115916",
"0.510933",
"0.50691956",
"0.5020476",
"0.5014774",
"0.50135577",
"0.50128126",
"0.5011278",
"0.5003016",
"0.49997228",
"0.49952468",
"0.49902463",
"0.49880245",
"0.498213... | 0.7311217 | 0 |
Prepare looped datasets from looping lines. | def prepare_looped_datasets(self, alldict, allcombs):
datasets_dict=dict()
numcombs = len(allcombs)
combct = 0
while combct < numcombs:
newdata = list(self.baseinput.data)
loopedlines = dict()
loopedlines = self.prepare_looped_lines(alldict, allcombs[c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data_preprocessing():\n lineid_content = get_lineid_content()\n print('Read movie_lines.txt file complete...')\n convos = get_convos()\n print('Read movie_conversations.txt file complete...')\n print('Building dataset')\n get_data(lineid_content, convos)",
"def _prepare_sets(self):\n\n ... | [
"0.6232418",
"0.6178191",
"0.61240345",
"0.6034664",
"0.5999491",
"0.59856147",
"0.5969796",
"0.5958377",
"0.5950267",
"0.5871935",
"0.58671767",
"0.5818414",
"0.5809877",
"0.5804624",
"0.5801337",
"0.5794393",
"0.5745656",
"0.5720152",
"0.5712723",
"0.5677284",
"0.56412107",... | 0.6497661 | 0 |
Create independently looped input files. | def create_input_files(self, datasets_dict):
ifname = self.keywords['inputfile']
dirstem = os.path.dirname(ifname)
basename = os.path.basename(ifname).split('.')[0]
createdfiles=list()
if dirstem == "":
dirstem = os.getcwd()
dkeys = datasets_dict.keys()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _make_files(self, dir, num_files=10):\n for i in range(num_files):\n self._make_random_file(dir)",
"def create_input_files(in_dir, R, I):\n def get_filepath(in_volume, infiles_partition):\n _3d_pos = numeric_to_3d_pos(in_volume.index, infiles_partition, order='F')\n i, j, k... | [
"0.6580419",
"0.6510424",
"0.6231249",
"0.6147335",
"0.61276037",
"0.60895264",
"0.60482085",
"0.6024064",
"0.59860575",
"0.5985176",
"0.59534013",
"0.58648974",
"0.58312774",
"0.582473",
"0.5797607",
"0.57878214",
"0.5783304",
"0.5764239",
"0.5764155",
"0.57330567",
"0.57255... | 0.6638289 | 0 |
Extract constant names from sybdb.h to use as python constants | def extract_constants(freetds_include="sybdb.h", constants_file="bcp_constants.py"):
fileno, source_file = mkstemp(suffix=".c", text=True)
write(fileno, "#include <{}>".format(freetds_include).encode())
close(fileno)
fileno, include_directives = mkstemp(suffix=".txt")
close(fileno)
if ON_WINDO... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_declarations(self):\n return \"extern const unsigned int %s;\\n\" % self.name",
"def get_calculable_constant_names_latex():\n return r\"t_0\", r\"S_{rr}\", r\"S_{r\\theta}\", r\"S_{rz}\", r\"S_{zz}\" \\\n r\"\\alpha\", r\"\\beta\", r\"\\gamma\", r\"C_{13}\", r\"C_{33}\", \... | [
"0.63279045",
"0.6142163",
"0.594471",
"0.5942139",
"0.59368765",
"0.59215355",
"0.590987",
"0.58534914",
"0.57482266",
"0.57082814",
"0.5656697",
"0.56237125",
"0.55894226",
"0.55852455",
"0.5570691",
"0.5560409",
"0.5546228",
"0.5487835",
"0.5454318",
"0.5445472",
"0.543823... | 0.6312631 | 1 |
Return holdout indices respecting hte temporal ordering of the data | def time_series_hold_out_validation(random_state: np.random.RandomState,
val_share: float, indices: np.ndarray, **kwargs: Any) \
-> Tuple[np.ndarray, np.ndarray]:
n_prediction_steps = kwargs['n_prediction_steps']
n_repeats = kwargs['n_repeats']
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_pulling_indices(self, weight):\n pass",
"def getBreakIndices(self):\n for i in self.raw.index[:-1]:\n if self.raw['stress'][i+1] > self.raw['stress'][i] and \\\n self.raw['stress'][i+2] < self.raw['stress'][i+1]:\n brkIdx1 = i+1 # brkIdx1: start of ... | [
"0.6033882",
"0.5888383",
"0.5833695",
"0.576953",
"0.5758707",
"0.56996095",
"0.5611121",
"0.5609971",
"0.5606583",
"0.5600059",
"0.5593295",
"0.5524574",
"0.54750305",
"0.54693586",
"0.5458139",
"0.54525465",
"0.54286104",
"0.54272556",
"0.5421725",
"0.5421557",
"0.5390778"... | 0.0 | -1 |
Standard k fold cross validation. | def k_fold_cross_validation(random_state: np.random.RandomState,
num_splits: int,
indices: np.ndarray,
**kwargs: Any
) -> List[Tuple[np.ndarray, np.ndarray]]:
shuffle = kwargs.get('shu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def k_folds_cross_validate(self, k):\n start_time = time.time()\n partition_size = int(self.num_samples / k)\n partitions = [\n (i * partition_size, (i + 1) * partition_size) for i in range(k)\n ]\n average_accuracy = 0.0\n for start, end in partitions:\n ... | [
"0.77007174",
"0.7679591",
"0.76575476",
"0.76463956",
"0.7470647",
"0.7434266",
"0.7416312",
"0.73822284",
"0.7370632",
"0.73616713",
"0.73327446",
"0.73284346",
"0.722847",
"0.7186071",
"0.71467024",
"0.7122442",
"0.70457053",
"0.6964643",
"0.6961495",
"0.6944377",
"0.69214... | 0.63284665 | 56 |
Returns train and validation indices respecting the temporal ordering of the data. | def time_series_cross_validation(random_state: np.random.RandomState,
num_splits: int,
indices: np.ndarray,
**kwargs: Any
) -> List[Tuple[np.ndarray, np.ndarray]]:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_train_index():\n data_size = (NUM_CLASS - 1) * NUM_DATA_PER_CLASS\n return np.array([i for i in range(0, data_size)])",
"def get_training_index():\n return list(range(0, 305))",
"def split_data(train, parameters):\n labels = train.labels\n train_indices, val_indices = train_test_split(ra... | [
"0.6553474",
"0.6376504",
"0.6233736",
"0.5944764",
"0.59190506",
"0.5901625",
"0.58788",
"0.58554393",
"0.58391976",
"0.5713936",
"0.56517017",
"0.563909",
"0.56207126",
"0.56050724",
"0.5597223",
"0.5592754",
"0.55752015",
"0.5573872",
"0.5544355",
"0.5543345",
"0.55142456"... | 0.0 | -1 |
Returns the indices without performing any operation on them. To be used for fitting on the whole dataset. This strategy is not compatible with HPO search. | def no_resampling(random_state: np.random.RandomState,
indices: np.ndarray) -> np.ndarray:
return indices | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def indices(self) -> np.ndarray:\n return self.impl.indices",
"def get_indices(self):\r\n return self._indices",
"def vir_indices(self):\n indices = []\n for index,item in enumerate(self):\n if item==0:\n indices.append(index)\n return indices",
"d... | [
"0.7181901",
"0.69676125",
"0.69128466",
"0.6892532",
"0.68412507",
"0.67869836",
"0.6754658",
"0.67145926",
"0.6703281",
"0.66633874",
"0.65803033",
"0.6534292",
"0.6509533",
"0.64898914",
"0.6441676",
"0.6402624",
"0.63538474",
"0.6317454",
"0.6311111",
"0.6274377",
"0.6259... | 0.65598696 | 11 |
Get open accounts Returns array with active account numbers | async def get_open_accounts(self):
result = []
URL = API_HOST + "/api/resources/header"
async with async_timeout.timeout(TIMEOUT):
response = await self.session.get(URL)
json_data = await response.json()
accounts = json_data["data"]["accounts"]["data"]["data"]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_accounts(self):\n\n data = {\n 'customerId': self.personal_identity_number,\n 'responseControl': {\n 'filter': {\n 'includes': ['ALL']\n }\n }\n }\n\n headers = {'Content-type': 'application/json',\n ... | [
"0.63580984",
"0.6303217",
"0.62876016",
"0.6213196",
"0.61325455",
"0.61324793",
"0.6089535",
"0.6086548",
"0.6079627",
"0.6079134",
"0.6050323",
"0.6013716",
"0.59957004",
"0.59836334",
"0.59793425",
"0.5972705",
"0.5965284",
"0.59572",
"0.5945932",
"0.59283507",
"0.5911551... | 0.8321022 | 0 |
Logging out from fpl | async def logout(self):
_LOGGER.info("Logging out")
URL_LOGOUT = API_HOST + "/api/resources/logout"
try:
async with async_timeout.timeout(TIMEOUT):
await self.session.get(URL_LOGOUT)
except Exception as e:
_LOGGER.error(e) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logout():",
"def logout():\n login()",
"def logout(self):",
"def logout(self):\n pass",
"def do_logout():\n\n session['authenticated'] = False\n session['username'] = None\n session['name'] = None\n session['cpi'] = None\n session['grp_size'] = None... | [
"0.7692397",
"0.73293793",
"0.7156266",
"0.70811003",
"0.7076655",
"0.70410043",
"0.70080215",
"0.6955402",
"0.6835801",
"0.6776245",
"0.67325246",
"0.6707584",
"0.67055",
"0.6672805",
"0.66292965",
"0.661934",
"0.6611719",
"0.6587299",
"0.6579601",
"0.6559363",
"0.6532657",
... | 0.0 | -1 |
Get data from resources endpoint | async def update(self, account) -> dict:
data = {}
URL_RESOURCES_ACCOUNT = API_HOST + "/api/resources/account/{account}"
async with async_timeout.timeout(TIMEOUT):
response = await self.session.get(
URL_RESOURCES_ACCOUNT.format(account=account)
)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_resources():\n return Response(f\"{Resource.get_all_resources()}\", 200, mimetype='text/plain')",
"def list(self, **kwargs):\n data, self.endpoint = self.data_endpoint(kwargs)\n r = super(Resource, self).list(**data)\n\n # Change display settings and data format for human consumpt... | [
"0.7040653",
"0.7014533",
"0.6972194",
"0.6868909",
"0.6711269",
"0.67088366",
"0.6694223",
"0.6652421",
"0.65987545",
"0.6597155",
"0.6576477",
"0.6572885",
"0.65307814",
"0.6527663",
"0.6498717",
"0.6484466",
"0.64421904",
"0.64192057",
"0.63806015",
"0.63806015",
"0.638060... | 0.0 | -1 |
get data from projected bill endpoint | async def __getFromProjectedBill(self, account, premise, currentBillDate) -> dict:
data = {}
try:
async with async_timeout.timeout(TIMEOUT):
response = await self.session.get(
URL_RESOURCES_PROJECTED_BILL.format(
account=account,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def __getBBL_async(self, account, projectedBillData) -> dict:\n _LOGGER.info(\"Getting budget billing data\")\n data = {}\n\n try:\n async with async_timeout.timeout(TIMEOUT):\n response = await self.session.get(\n URL_BUDGET_BILLING_PREMISE_D... | [
"0.6360357",
"0.6014319",
"0.59525716",
"0.5819394",
"0.5776328",
"0.57017654",
"0.5693053",
"0.56899124",
"0.5679887",
"0.5679887",
"0.5679887",
"0.56725025",
"0.56725025",
"0.5663544",
"0.5658554",
"0.5646016",
"0.56169564",
"0.5605687",
"0.5596649",
"0.5570589",
"0.5530671... | 0.59895027 | 2 |
Get budget billing data | async def __getBBL_async(self, account, projectedBillData) -> dict:
_LOGGER.info("Getting budget billing data")
data = {}
try:
async with async_timeout.timeout(TIMEOUT):
response = await self.session.get(
URL_BUDGET_BILLING_PREMISE_DETAILS.format(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetCampaignBudget(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')",
"def budget(self):\n return self._budget",
"def billing_info(self):\r\n r... | [
"0.66888595",
"0.6544355",
"0.64032984",
"0.6293646",
"0.62567914",
"0.625594",
"0.62317514",
"0.6158417",
"0.6107173",
"0.60221004",
"0.59583",
"0.586195",
"0.58142555",
"0.57493407",
"0.56994355",
"0.5688151",
"0.5630534",
"0.5616468",
"0.56075585",
"0.5590992",
"0.5573143"... | 0.7448803 | 0 |
get data from appliance usage | async def __getDataFromApplianceUsage(self, account, lastBilledDate) -> dict:
_LOGGER.info("Getting appliance usage data")
JSON = {"startDate": str(lastBilledDate.strftime("%m%d%Y"))}
data = {}
try:
async with async_timeout.timeout(TIMEOUT):
response = await... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getUsageInfo(self):\n return self.jsonRequest(\"/api/v1/usage\", { \"apiKey\": self._apiKey })",
"def get_application_api_usage_get(self, applicationId, end, start):\n # TODO: Assuming first server is good - need to make fallback logic\n return self.session.get_any(\"{base}{request_url}\... | [
"0.6542614",
"0.6461803",
"0.6203412",
"0.6135864",
"0.5930974",
"0.5910394",
"0.5888209",
"0.5844207",
"0.58017164",
"0.5787487",
"0.57435703",
"0.5714978",
"0.5709852",
"0.564539",
"0.5628239",
"0.5616134",
"0.5614402",
"0.56101",
"0.5602017",
"0.55986047",
"0.5594599",
"... | 0.6843256 | 0 |
get data from appliance usage | async def __getDataFromBalance(self, account) -> dict:
_LOGGER.info("Getting appliance usage data")
data = {}
URL_BALANCE = API_HOST + "/api/resources/account/{account}/balance?count=-1"
try:
async with async_timeout.timeout(TIMEOUT):
response = await self.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def __getDataFromApplianceUsage(self, account, lastBilledDate) -> dict:\n _LOGGER.info(\"Getting appliance usage data\")\n\n JSON = {\"startDate\": str(lastBilledDate.strftime(\"%m%d%Y\"))}\n data = {}\n\n try:\n async with async_timeout.timeout(TIMEOUT):\n ... | [
"0.68421215",
"0.6543652",
"0.64636284",
"0.6203195",
"0.61375993",
"0.5911429",
"0.58880204",
"0.5845489",
"0.5802097",
"0.57885844",
"0.57432395",
"0.57148707",
"0.5710095",
"0.5646816",
"0.56286925",
"0.5616645",
"0.5614922",
"0.56103456",
"0.56019914",
"0.55968064",
"0.55... | 0.5929427 | 5 |
Return the default form class used for user registration. | def get_form_class(self, request):
return RegistrationForm | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_form_class(self, request):\n\t\treturn RegistrationForm",
"def get_form_class(self):\n return self.form_class",
"def get_form_class(self):\n if self.form_class:\n return self.form_class\n else:\n raise ImproperlyConfigured(\n \"在定义类视图%s的时候,你必须明确... | [
"0.8111784",
"0.770102",
"0.74282926",
"0.72233987",
"0.71631217",
"0.7097246",
"0.7082445",
"0.696311",
"0.692484",
"0.6767896",
"0.67418265",
"0.66456175",
"0.66020036",
"0.64767134",
"0.64665145",
"0.64210325",
"0.63494134",
"0.6314577",
"0.62687373",
"0.6240669",
"0.62336... | 0.7956627 | 1 |
Creates the sum tree data structure for the given replay capacity. | def __init__(self, capacity):
assert isinstance(capacity, int)
if capacity <= 0:
raise ValueError(
'Sum tree capacity should be positive. Got: {}'.format(capacity))
self.nodes = []
self.depth = int(np.ceil(np.log2(capacity)))
self.low_idx = (2**self.depth) - 1 # pri_idx + low_idx -... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, capacity, tuple, alpha=0.6, beta=0.4):\n self.tree = SumTree(capacity)\n self.capacity = capacity\n self.alpha = alpha\n self.beta = beta\n self.tuple = tuple",
"def __init__(self, memory_size, batch_size, alpha):\n self.tree = sum_tree.SumTree(memory_... | [
"0.6020408",
"0.5820842",
"0.5724238",
"0.55728537",
"0.55458015",
"0.5542693",
"0.5513752",
"0.5476557",
"0.53817534",
"0.53465384",
"0.53336674",
"0.53084284",
"0.5296613",
"0.5293262",
"0.5262831",
"0.5256954",
"0.5208593",
"0.519735",
"0.5179887",
"0.51658785",
"0.5162465... | 0.70326006 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.