query
stringlengths 9
9.05k
| document
stringlengths 10
222k
| metadata
dict | negatives
listlengths 30
30
| negative_scores
listlengths 30
30
| document_score
stringlengths 4
10
| document_rank
stringclasses 2
values |
|---|---|---|---|---|---|---|
The main function of the ``electrons_normalize`` module. The image given by outputfinal is converted from units of ``DN`` to ``e/s``. This is done by multiplying the image by the gain and dividing the image by the exposure time. The gain and exposure time are grabbed from the header. | def electrons_normalize(superdark):
logging.info('\tConverting {} to electrons.'.format(superdark))
# Open the image and get the data
hdulist = fits.open(superdark, 'update')
sci1 = hdulist[1].data
err2 = hdulist[2].data
sci4 = hdulist[4].data
err5 = hdulist[5].data
# Find gains and exposure time
gain = {}
gain['A'] = hdulist[0].header['ATODGNA']
gain['B'] = hdulist[0].header['ATODGNB']
gain['C'] = hdulist[0].header['ATODGNC']
gain['D'] = hdulist[0].header['ATODGND']
exptime = hdulist[0].header['EXPTIME']
# Multiply each "half" of the extensions by the appropriate gain.
logging.info('\tMultiplying each quadrant by its gain.')
apply_norm(sci1, '*', gain['C'], 'regionAorC')
apply_norm(err2, '*', gain['C'], 'regionAorC')
apply_norm(sci1, '*', gain['D'], 'regionBorD')
apply_norm(err2, '*', gain['D'], 'regionBorD')
apply_norm(sci4, '*', gain['A'], 'regionAorC')
apply_norm(err5, '*', gain['A'], 'regionAorC')
apply_norm(sci4, '*', gain['B'], 'regionBorD')
apply_norm(err5, '*', gain['B'], 'regionBorD')
# Normalizing the gain to 1 is not necessary since calwf3
# doesn't look at this keyword. It already assumes the units
# of the darks are e-/sec and will use the gains in CCDTAB to
# reconvert the darks to DNs. But we do it for consistency.
logging.info('\tNormalizing the SCI and ERR extensions (1, 2, 4, 5) ' + \
'by the integration time.')
apply_norm(sci1, '/', exptime, 'None')
apply_norm(err2, '/', exptime, 'None')
apply_norm(sci4, '/', exptime, 'None')
apply_norm(err5, '/', exptime, 'None')
# Update necessary keywords
for ext in range(7):
hdulist[ext].header['CCDGAIN'] = 1.0
hdulist[0].header['EXPTIME'] = 1.0
hdulist[0].header['TEXPTIME'] = 1.0
hdulist.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def photometry(userinputs, image, catalog, outputname, apertures, annulus='', dannulus='', recenter=False):\n logging.info('Running photometry function on {}'.format(image))\n logging.info('Using {}px apertures'.format(apertures))\n\n #set directory\n target_dir = userinputs['OUTDIR']\n\n #Update passed names to be full paths if they are not\n\n if len(image.split('/'))==1:\n logging.info('Looking for {} in {}.'.format(image,userinputs['DATA']))\n image = glob.glob(userinputs['DATA'] + '/' + image)\n if len(image)==0:\n logging.critical('No {} image found'.format(image))\n filemanagement.shutdown('Selected image does not exist',userinputs)\n else:\n image = image[0]\n logging.debug('Using image: {}'.format(image))\n\n if len(catalog.split('/'))==1:\n catalog = target_dir + '/init/' + catalog\n logging.debug('Input catalog: {}'.format(catalog))\n\n if len(outputname.split('/'))==1:\n output = target_dir + '/photometry/' + outputname\n logging.debug('Output name: {}'.format(output))\n else:\n output = outputname\n outputname = outputname.split('/')[-1]\n logging.debug('Output name: {}'.format(output))\n\n\n #Load zeropoints\n inst_zp, filter_zp, zp_zp = np.loadtxt(target_dir + '/init/Hi-PEEC_zeropoints.tab', unpack=True, dtype='str')\n # print inst_zp, filter_zp, zp_zp\n # Get filter from header\n filter = get_filter(image)\n\n\n # Set the necessary variables for photometry on the reference image\n exptime = fits.getheader(image)['EXPTIME']\n logging.debug('Exposure time from header: {}'.format(exptime))\n inst = fits.getheader(image)['INSTRUME']\n logging.debug('Intrument from header: {}'.format(inst))\n inst = inst.lower()\n\n\n match = (inst_zp == inst) & (filter_zp == filter.lower())\n zp = zp_zp[match]\n\n # zp is a string within an array, so need to turn into a float\n try:\n zp = float(zp[0])\n #If that cannot be done there was no match.\n except IndexError:\n if inst == 'acs':\n logging.debug('Zeropoint not found in file, passing to ACS calculation')\n zp = ACS_zeropoint(image)\n elif inst == 'wfc3':\n logging.debug('Zeropoint not found in file, passing to WFC3 calculation')\n zp = WFC3_zeropoint(image)\n else:\n logging.critical('No matching zeropoint found. Quitting.')\n logging.debug('No zeropoint match found for filter {} with instrument {}'\\\n .format(filter,inst))\n logging.debug('Available filters in zeropoint file : {} for instrument {}'\\\n .format(filter_zp, inst_zp))\n filemanagement.shutdown('No zeropoint was found for filter: {}'.format(filter),userinputs)\n\n logging.debug('Zeropoint from file: {}'.format(zp))\n # Remove output file if it already exists\n filemanagement.remove_if_exists(output)\n\n\n # Run photometry\n #--------------------------------------------------------------------------\n # Set up IRAF params:\n iraf.datapars.epadu = exptime\n\n # !!!!!!!!!!!!!!!!!\n # Only center on reference frame\n if recenter:\n iraf.centerpars.calgorithm = 'centroid'\n else:\n iraf.centerpars.calgorithm = 'none'\n # !!!!!!!!!!!!!!!\n # CHANGE BACKGROUND ESTIMATE IN ANNULUS TO MODE\n\n # Select the annulus depending on whether it is overwritten in the function call or not\n if annulus == '':\n iraf.fitskypars.annulus = userinputs['ANNULUS']\n logging.debug('Using annulus from inputfile ({}px)'.format(userinputs['ANNULUS']))\n else:\n iraf.fitskypars.annulus = annulus\n logging.debug('Using user specified annulus ({}px)'.format(annulus))\n if dannulus == '':\n iraf.fitskypars.dannulus = userinputs['D_ANNULUS']\n logging.debug('Using annulus width from inputfile ({}px)'.format(userinputs['D_ANNULUS']))\n else:\n iraf.fitskypars.dannulus = dannulus\n logging.debug('Using user specified annulus width ({}px)'.format(dannulus))\n\n iraf.photpars.apertures = apertures\n logging.debug('Using aperture(s) of {}px'.format(apertures))\n iraf.photpars.zmag = zp\n logging.debug('Setting zeropoint to {}'.format(zp))\n\n # Do phot\n iraf.phot(image+'[SCI]', catalog, output)\n #--------------------------------------------------------------------------\n\n\n #Depending on the number of apertures used, different methods of saving the\n # results are required\n #--------------------------------------------------------------------------\n\n naper = len(apertures.split(','))\n logging.debug('Number of apertures used {}'.format(naper))\n\n #final output filename\n fullcat_mag_short = target_dir + '/photometry/short_' + outputname\n\n if naper > 1:\n # Removes all outputlines that do not contain the character '*'\n # ensures only phot results are kept\n cmd = 'grep \"*\" ' + output + ' > ' + fullcat_mag_short\n os.system(cmd)\n\n # Replace INDEFS:\n cmd = 'sed -i.bak \"s/INDEF/99.999/g\" ' + fullcat_mag_short\n os.system(cmd)\n\n # Remove .bak files to prevent confusion\n bak_fullcat = fullcat_mag_short + '.bak'\n os.remove(bak_fullcat)\n\n\n else:\n #Dump results into a temp file\n temp = target_dir + '/photometry/phot_dump.mag'\n filemanagement.remove_if_exists(temp)\n iraf.txdump(output, 'XCENTER,YCENTER,FLUX,MAG,MERR,MSKY,ID', 'yes', Stdout = temp)\n\n # Set placeholders for sources outside of FOV and undetected sources\n # For outside of FOV, use 66.666 instead of INDEF\n # For undetected sources, use 99.999 instead of INDEF\n\n # Sources outside of FOV have exactly zero flux\n x, y, flux, mag, merr, msky, id = np.loadtxt(temp, unpack = True,\n dtype = str)\n\n flux = flux.astype(float)\n\n out_fov = (flux == 0.)\n logging.debug('Number of sources outside FOV: {}'.format(len(out_fov)))\n\n mag[out_fov] = 66.666\n merr[out_fov] = 66.666\n msky[out_fov] = 66.666\n\n # Undetected sources, those with negative flux or fluxes so small that mag err\n # is INDEF\n neg_flux = (flux < 0.)\n tiny_flux = (flux > 0.) & (merr == 'INDEF')\n\n mag[neg_flux] = 99.999\n merr[neg_flux] = 99.999\n msky[neg_flux] = 99.999\n\n merr[tiny_flux] = 99.999\n msky[tiny_flux] = 99.999\n\n logging.debug('Nr of undetected sources: {}'.format(len(tiny_flux)+len(neg_flux)))\n # Save results to new file\n x = x.astype(float)\n y = y.astype(float)\n mag = mag.astype(float)\n merr = merr.astype(float)\n msky = msky.astype(float)\n id = id.astype(int)\n\n zip_phot = zip(x, y, mag, merr, msky, id)\n\n np.savetxt(fullcat_mag_short, zip_phot,\n fmt = '%.3f %.3f %.3f %.3f %.9f %i')\n\n #--------------------------------------------------------------------------\n\n return fullcat_mag_short",
"def calibrate_output(self, img, spectral=False, units=\"contrast\"):\n if units == \"contrast\":\n if spectral:\n # spectral cube, each slice needs it's own calibration\n numwvs = img.shape[0]\n img /= self.dn_per_contrast[:numwvs, None, None]\n else:\n # broadband image\n img /= np.nanmean(self.dn_per_contrast)\n self.flux_units = \"contrast\"\n\n return img",
"def normalize_emission(self):\n self._e /= self._e.sum(0)",
"def _normalize(self):\r\n self.dataframe['norm_intensity'] = self.dataframe['intensity']\r\n self.dataframe['norm_intensity'] -= self.dataframe['norm_intensity'].min()\r\n self.dataframe['norm_intensity'] /= self.dataframe['norm_intensity'].max() * 0.01",
"def main(start_dt, end_dt, img_ws, ancillary_ws, output_ws,\n etr_flag=False, eto_flag=False, extent_path=None, output_extent=None,\n stats_flag=True, overwrite_flag=False, use_cimis_eto_flag=False):\n logging.info('\\nComputing CIMIS ETo/ETr')\n logging.debug(' Start date: {}'.format(start_dt))\n logging.debug(' End date: {}'.format(end_dt))\n\n np.seterr(invalid='ignore')\n\n # Compute ETr and/or ETo\n if not etr_flag and not eto_flag:\n logging.info(' ETo/ETr flag(s) not set, defaulting to ETr')\n etr_flag = True\n\n etr_folder = 'etr'\n eto_folder = 'eto'\n etr_fmt = 'etr_{}_daily_cimis.img'\n eto_fmt = 'eto_{}_daily_cimis.img'\n\n # DEM for air pressure calculation\n mask_raster = os.path.join(ancillary_ws, 'cimis_mask.img')\n dem_raster = os.path.join(ancillary_ws, 'cimis_elev.img')\n lat_raster = os.path.join(ancillary_ws, 'cimis_lat.img')\n # lon_raster = os.path.join(ancillary_ws, 'cimis_lon.img')\n\n # Interpolate zero windspeed pixels\n # interpolate_zero_u2_flag = False\n\n # Interpolate edge and coastal cells\n # interpolate_edge_flag = False\n\n # Resample type\n # 0 = GRA_NearestNeighbour, Nearest neighbour (select on one input pixel)\n # 1 = GRA_Bilinear,Bilinear (2x2 kernel)\n # 2 = GRA_Cubic, Cubic Convolution Approximation (4x4 kernel)\n # 3 = GRA_CubicSpline, Cubic B-Spline Approximation (4x4 kernel)\n # 4 = GRA_Lanczos, Lanczos windowed sinc interpolation (6x6 kernel)\n # 5 = GRA_Average, Average (computes the average of all non-NODATA contributing pixels)\n # 6 = GRA_Mode, Mode (selects the value which appears most often of all the sampled points)\n resample_type = gdal.GRA_CubicSpline\n\n # Wind speed is measured at 2m\n zw = 2\n\n # Output workspaces\n etr_ws = os.path.join(output_ws, etr_folder)\n eto_ws = os.path.join(output_ws, eto_folder)\n if etr_flag and not os.path.isdir(etr_ws):\n os.makedirs(etr_ws)\n if eto_flag and not os.path.isdir(eto_ws):\n os.makedirs(eto_ws)\n\n # Get CIMIS grid properties from mask\n cimis_mask_ds = gdal.Open(mask_raster)\n cimis_osr = drigo.raster_ds_osr(cimis_mask_ds)\n cimis_proj = drigo.osr_proj(cimis_osr)\n cimis_cs = drigo.raster_ds_cellsize(cimis_mask_ds, x_only=True)\n cimis_extent = drigo.raster_ds_extent(cimis_mask_ds)\n cimis_full_geo = cimis_extent.geo(cimis_cs)\n cimis_x, cimis_y = cimis_extent.origin()\n cimis_mask_ds = None\n logging.debug(' Projection: {}'.format(cimis_proj))\n logging.debug(' Cellsize: {}'.format(cimis_cs))\n logging.debug(' Geo: {}'.format(cimis_full_geo))\n logging.debug(' Extent: {}'.format(cimis_extent))\n\n # Manually set CIMIS grid properties\n # cimis_extent = drigo.Extent((-400000, -650000, 600000, 454000))\n # cimis_cs = 2000\n # cimis_geo = drigo.extent_geo(cimis_extent, cellsize)\n # cimis_epsg = 3310 # NAD_1983_California_Teale_Albers\n # cimis_x, cimis_y = (0,0)\n\n # Subset data to a smaller extent\n if output_extent is not None:\n logging.info('\\nComputing subset extent & geo')\n logging.debug(' Extent: {}'.format(output_extent))\n cimis_extent = drigo.Extent(output_extent)\n cimis_extent.adjust_to_snap('EXPAND', cimis_x, cimis_y, cimis_cs)\n cimis_geo = cimis_extent.geo(cimis_cs)\n logging.debug(' Geo: {}'.format(cimis_geo))\n logging.debug(' Extent: {}'.format(output_extent))\n elif extent_path is not None:\n logging.info('\\nComputing subset extent & geo')\n if not os.path.isfile(extent_path):\n logging.error(\n '\\nThe extent object does not exist, exiting\\n'\n ' {}'.format(extent_path))\n return False\n elif extent_path.lower().endswith('.shp'):\n cimis_extent = drigo.feature_path_extent(extent_path)\n extent_osr = drigo.feature_path_osr(extent_path)\n extent_cs = None\n else:\n cimis_extent = drigo.raster_path_extent(extent_path)\n extent_osr = drigo.raster_path_osr(extent_path)\n extent_cs = drigo.raster_path_cellsize(extent_path, x_only=True)\n cimis_extent = drigo.project_extent(\n cimis_extent, extent_osr, cimis_osr, extent_cs)\n cimis_extent.adjust_to_snap('EXPAND', cimis_x, cimis_y, cimis_cs)\n cimis_geo = cimis_extent.geo(cimis_cs)\n logging.debug(' Geo: {}'.format(cimis_geo))\n logging.debug(' Extent: {}'.format(cimis_extent))\n else:\n cimis_geo = cimis_full_geo\n\n # Latitude\n lat_array = drigo.raster_to_array(\n lat_raster, mask_extent=cimis_extent, return_nodata=False)\n lat_array = lat_array.astype(np.float32)\n lat_array *= math.pi / 180\n\n # Elevation data\n elev_array = drigo.raster_to_array(\n dem_raster, mask_extent=cimis_extent, return_nodata=False)\n elev_array = elev_array.astype(np.float32)\n\n # Process each year in the input workspace\n logging.info(\"\")\n for year_str in sorted(os.listdir(img_ws)):\n logging.debug('{}'.format(year_str))\n if not re.match('^\\d{4}$', year_str):\n logging.debug(' Not a 4 digit year folder, skipping')\n continue\n year_ws = os.path.join(img_ws, year_str)\n year_int = int(year_str)\n # year_days = int(dt.datetime(year_int, 12, 31).strftime('%j'))\n if start_dt is not None and year_int < start_dt.year:\n logging.debug(' Before start date, skipping')\n continue\n elif end_dt is not None and year_int > end_dt.year:\n logging.debug(' After end date, skipping')\n continue\n logging.info('{}'.format(year_str))\n\n # Output paths\n etr_raster = os.path.join(etr_ws, etr_fmt.format(year_str))\n eto_raster = os.path.join(eto_ws, eto_fmt.format(year_str))\n if etr_flag and (overwrite_flag or not os.path.isfile(etr_raster)):\n logging.debug(' {}'.format(etr_raster))\n drigo.build_empty_raster(\n etr_raster, band_cnt=366, output_dtype=np.float32,\n output_proj=cimis_proj, output_cs=cimis_cs,\n output_extent=cimis_extent, output_fill_flag=True)\n if eto_flag and (overwrite_flag or not os.path.isfile(eto_raster)):\n logging.debug(' {}'.format(eto_raster))\n drigo.build_empty_raster(\n eto_raster, band_cnt=366, output_dtype=np.float32,\n output_proj=cimis_proj, output_cs=cimis_cs,\n output_extent=cimis_extent, output_fill_flag=True)\n\n # Process each date in the year\n for date_str in sorted(os.listdir(year_ws)):\n logging.debug('{}'.format(date_str))\n try:\n date_dt = dt.datetime.strptime(date_str, '%Y_%m_%d')\n except ValueError:\n logging.debug(\n ' Invalid folder date format (YYYY_MM_DD), skipping')\n continue\n if start_dt is not None and date_dt < start_dt:\n logging.debug(' Before start date, skipping')\n continue\n elif end_dt is not None and date_dt > end_dt:\n logging.debug(' After end date, skipping')\n continue\n logging.info(date_str)\n date_ws = os.path.join(year_ws, date_str)\n doy = int(date_dt.strftime('%j'))\n\n # Set file paths\n tmax_path = os.path.join(date_ws, 'Tx.img')\n tmin_path = os.path.join(date_ws, 'Tn.img')\n tdew_path = os.path.join(date_ws, 'Tdew.img')\n rso_path = os.path.join(date_ws, 'Rso.img')\n rs_path = os.path.join(date_ws, 'Rs.img')\n u2_path = os.path.join(date_ws, 'U2.img')\n eto_path = os.path.join(date_ws, 'ETo.img')\n # k_path = os.path.join(date_ws, 'K.img')\n # rnl_path = os.path.join(date_ws, 'Rnl.img')\n input_list = [\n tmin_path, tmax_path, tdew_path, u2_path, rs_path, rso_path]\n\n # If any input raster is missing, skip the day\n # Unless ETo is present (and use_cimis_eto_flag is True)\n day_skip_flag = False\n for t_path in input_list:\n if not os.path.isfile(t_path):\n logging.info(' {} is missing'.format(t_path))\n day_skip_flag = True\n\n if (day_skip_flag and\n use_cimis_eto_flag and\n os.path.isfile(eto_path)):\n logging.info(' Using CIMIS ETo directly')\n eto_array = drigo.raster_to_array(\n eto_path, 1, cimis_extent, return_nodata=False)\n eto_array = eto_array.astype(np.float32)\n if not np.any(eto_array):\n logging.info(' {} is empty or missing'.format(eto_path))\n logging.info(' Skipping date')\n continue\n # ETr\n if etr_flag:\n drigo.array_to_comp_raster(\n 1.2 * eto_array, etr_raster, band=doy,\n stats_flag=False)\n # drigo.array_to_raster(\n # 1.2 * eto_array, etr_raster,\n # output_geo=cimis_geo, output_proj=cimis_proj,\n # stats_flag=stats_flag)\n # ETo\n if eto_flag:\n drigo.array_to_comp_raster(\n eto_array, eto_raster, band=doy, stats_flag=False)\n # drigo.array_to_raster(\n # eto_array, eto_raster,\n # output_geo=cimis_geo, output_proj=cimis_proj,\n # stats_flag=stats_flag)\n del eto_array\n continue\n elif not day_skip_flag:\n # Read in rasters\n tmin_array = drigo.raster_to_array(\n tmin_path, 1, cimis_extent, return_nodata=False)\n tmax_array = drigo.raster_to_array(\n tmax_path, 1, cimis_extent, return_nodata=False)\n tdew_array = drigo.raster_to_array(\n tdew_path, 1, cimis_extent, return_nodata=False)\n # rso_array = drigo.raster_to_array(\n # rso_path, 1, cimis_extent, return_nodata=False)\n rs_array = drigo.raster_to_array(\n rs_path, 1, cimis_extent, return_nodata=False)\n u2_array = drigo.raster_to_array(\n u2_path, 1, cimis_extent, return_nodata=False)\n # k_array = drigo.raster_to_array(\n # k_path, 1, cimis_extent, return_nodata=False)\n # rnl_array = drigo.raster_to_array(\n # rnl_path, 1, cimis_extent, return_nodata=False)\n\n # Check that all input arrays have data\n for t_name, t_array in [\n [tmin_path, tmin_array], [tmax_path, tmax_array],\n [tdew_path, tdew_array], [u2_path, u2_array],\n [rs_path, rs_array]]:\n if not np.any(t_array):\n logging.warning(\n ' {} is empty or missing'.format(t_name))\n day_skip_flag = True\n if day_skip_flag:\n logging.warning(' Skipping date')\n continue\n\n # # DEADBEEF - Some arrays have a 500m cellsize\n # # i.e. 2011-07-25, 2010-01-01 -> 2010-07-27\n # tmin_array = rescale_array_func(tmin_array, elev_array, 'tmin')\n # tmax_array = rescale_array_func(tmax_array, elev_array, 'tmax')\n # tdew_array = rescale_array_func(tdew_array, elev_array, 'tdew')\n # rso_array = rescale_array_func(rso_array, elev_array, 'rso')\n # rs_array = rescale_array_func(rs_array, elev_array, 'rs')\n # u2_array = rescale_array_func(u2_array, elev_array, 'u2')\n # # k_array = rescale_array_func(k_array, elev_array, 'k')\n # # rnl_array = rescale_array_func(rnl_array, elev_array, 'rnl')\n\n\n # Compute Ea from Tdew\n ea_array = refet.calcs._sat_vapor_pressure(tdew_array)\n\n # # Calculate q from tdew by first calculating ea from tdew\n # ea_array = refet.calcs._sat_vapor_pressure(tdew_array)\n # pair_array = refet.calcs.air_pressure_func(elev_array)\n # q_array = 0.622 * ea_array / (pair_array - (0.378 * ea_array))\n # del es_array, pair_array, tdew_array\n\n # # Calculate rhmin/rhmax from tdew\n # ea_tmax = refet._calcs._sat_vapor_pressure(tmax_array)\n # ea_tmin = refet._calcs._sat_vapor_pressure(tmin_array)\n # rhmin = ea_tdew * 2 / (ea_tmax + ea_tmin);\n # rhmax = ea_tdew * 2 / (ea_tmax + ea_tmin);\n # del ea_tmax, ea_tmin\n\n refet_obj = refet.Daily(\n tmin=tmin_array, tmax=tmax_array, ea=ea_array,\n rs=rs_array, uz=u2_array, zw=zw, elev=elev_array,\n lat=lat_array, doy=doy, method='asce')\n # rso_type='ARRAY', rso=rso_array\n\n # ETr\n if etr_flag:\n drigo.array_to_comp_raster(\n refet_obj.etr().astype(np.float32), etr_raster,\n band=doy, stats_flag=False)\n # drigo.array_to_raster(\n # refet_obj.etr().astype(np.float32), etr_raster,\n # output_geo=cimis_geo, output_proj=cimis_proj,\n # stats_flag=stats_flag)\n # ETo\n if eto_flag:\n drigo.array_to_comp_raster(\n refet_obj.eto().astype(np.float32), eto_raster,\n band=doy, stats_flag=False)\n # drigo.array_to_raster(\n # refet_obj.eto().astype(np.float32), eto_raster,\n # output_geo=cimis_geo, output_proj=cimis_proj,\n # stats_flag=stats_flag)\n\n # Cleanup\n del tmin_array, tmax_array, u2_array, rs_array, ea_array\n # del rnl, rs, rso\n else:\n logging.info(' Skipping date')\n continue\n\n if stats_flag and etr_flag:\n drigo.raster_statistics(etr_raster)\n if stats_flag and eto_flag:\n drigo.raster_statistics(eto_raster)\n\n logging.debug('\\nScript Complete')",
"def run_phot_normalization(setup, **params):\n\n log = logs.start_stage_log( setup.red_dir, 'postproc_phot_norm', version=VERSION )\n\n xmatch = crossmatch.CrossMatchTable()\n xmatch.load(params['crossmatch_file'],log=log)\n\n # Identify the datasets to be used as the primary reference in each\n # filter:\n xmatch.id_primary_datasets_per_filter()\n log.info('Identified datasets to be used as the primary references in each filter: '\\\n +repr(xmatch.reference_datasets))\n\n # Add columns to the dataset Table to hold the photometric calibration\n # parameters\n ndset = len(xmatch.datasets)\n ncol = len(xmatch.datasets.colnames)\n if 'norm_a0' not in xmatch.datasets.colnames:\n xmatch.datasets.add_column(np.zeros(ndset), name='norm_a0', index=ncol+1)\n xmatch.datasets.add_column(np.zeros(ndset), name='norm_a1', index=ncol+2)\n xmatch.datasets.add_column(np.zeros(ndset), name='norm_covar_0', index=ncol+3)\n xmatch.datasets.add_column(np.zeros(ndset), name='norm_covar_1', index=ncol+4)\n xmatch.datasets.add_column(np.zeros(ndset), name='norm_covar_2', index=ncol+5)\n xmatch.datasets.add_column(np.zeros(ndset), name='norm_covar_3', index=ncol+6)\n log.info('Expanded xmatch.datasets table for normalization parameters')\n\n # Extract list of filters from xmatch.images['filter'] column\n filter_list = np.unique(xmatch.images['filter'].data)\n log.info('Identified list of filters to process: '+repr(filter_list))\n\n # Read data from quadrant 1\n # Reading in the timeseries data for all four quadrants is at the very\n # edge of the memory limits on the machines available, so it is preferable\n # to calibrate the quadrant's data separately. However, there are sufficient\n # stars in each quantant to be able to determine the photometric calibration\n # from a single quadrant, and apply it to the rest of the image.\n log.info('Loading the timeseries photometry from quadrant 1')\n file_path = path.join(setup.red_dir, params['field_name']+'_quad1_photometry.hdf5')\n phot_data = hd5_utils.read_phot_from_hd5_file(file_path, return_type='array')\n log.info('-> Completed photometry load')\n\n # Identify constant stars in the dataset\n constant_stars = find_constant_stars(xmatch, phot_data, log)\n star = 1\n\n # Normalize the photometry of each dataset to that of the reference\n # image in the primary reference dataset in that filter\n #for filter in filter_list:\n for filter in filter_list:\n\n # Plot an RMS diagram of the lightcurves for all stars in this filter,\n # prior to normalization, for comparison\n image_index = np.where(xmatch.images['filter'] == filter)[0]\n phot_data_filter = phot_data[:,image_index,:]\n (mag_col, mag_err_col) = field_photometry.get_field_photometry_columns('corrected')\n qc_col = 16\n\n plot_multisite_rms(params, phot_data_filter, mag_col, mag_err_col, qc_col,\n 'rms_prenorm_'+str(filter)+'.png', log)\n\n # Extract the reference image photometry for the primary-ref dataset\n # for this filter\n ref_datacode = xmatch.reference_datasets[filter]\n sitecode = get_site_code(ref_datacode)\n log.info('Reference dataset in '+filter+' is '+ref_datacode+', sitecode='+sitecode)\n\n ref_phot = np.zeros((len(xmatch.stars),2))\n ref_phot[:,0] = xmatch.stars['cal_'+filter.replace('p','')+'_mag_'+sitecode]\n ref_phot[:,1] = xmatch.stars['cal_'+filter.replace('p','')+'_magerr_'+sitecode]\n\n # Extract the lightcurves for all other datasets in this filter in turn\n dataset_index = np.where(xmatch.datasets['dataset_filter'] == filter)[0]\n\n for idset in dataset_index:\n dset_datacode = xmatch.datasets['dataset_code'][idset]\n dset_sitecode = get_site_code(dset_datacode)\n\n # If the dataset is the reference dataset, replicate the photometric\n # measurements from the corrected columns to the normalized columns,\n # since no normalization is required - this ensures the full\n # lightcurve can be accessed from the normalization columns.\n if dset_datacode == ref_datacode:\n log.info('Replicating primary reference photometry from dataset '\\\n +dset_datacode+' to the normalized photometry columns')\n image_index = np.where(xmatch.images['dataset_code'] == dset_datacode)[0]\n (mag_col, mag_err_col) = field_photometry.get_field_photometry_columns('corrected')\n (norm_mag_col, norm_mag_err_col) = field_photometry.get_field_photometry_columns('normalized')\n for i in image_index:\n phot_data[:,i,norm_mag_col] = phot_data[:,i,mag_col]\n phot_data[:,i,norm_mag_err_col] = phot_data[:,i,mag_err_col]\n\n # Normalize any dataset that isn't the same as the reference dataset\n else:\n log.info('Normalizing dataset '+dset_datacode+', sitecode='+dset_sitecode)\n image_index = np.where(xmatch.images['dataset_code'] == dset_datacode)[0]\n\n ## Dset created to hold all stars in field, not quadrant - \n # normalization is calculated from whole field.\n dset_phot = np.zeros((len(xmatch.stars),2))\n dset_phot[:,0] = xmatch.stars['cal_'+filter.replace('p','')+'_mag_'+dset_sitecode]\n dset_phot[:,1] = xmatch.stars['cal_'+filter.replace('p','')+'_magerr_'+dset_sitecode]\n\n # Calculate their weighted offset relative to the primary-ref\n # dataset for the filter\n (fit, covar_fit) = calc_phot_normalization(ref_phot, dset_phot,\n constant_stars, log,\n diagnostics=True, ref=sitecode,\n dset=dset_sitecode, f=filter)\n\n # Store the fit results for this dataset\n xmatch = store_dataset_phot_normalization(idset, xmatch, fit, covar_fit, log)\n\n # Apply the normalization calibration to the dataset's reference\n # image photometry, and store the results in the xmatch.stars table\n log.info('Applying normalization to the datasets reference image photometry')\n cal_phot = apply_phot_normalization_single_frame(fit, covar_fit, dset_phot,\n 0, 1, log,\n diagnostics=True, ref=sitecode,\n dset=dset_sitecode, f=filter)\n xmatch.stars['norm_'+filter.replace('p','')+'_mag_'+dset_sitecode] = cal_phot[:,0]\n xmatch.stars['norm_'+filter.replace('p','')+'_magerr_'+dset_sitecode] = cal_phot[:,1]\n\n # Apply the photometry calibration to the timeseries data\n # for this dataset\n (mag_col, mag_err_col) = field_photometry.get_field_photometry_columns('corrected')\n (norm_mag_col, norm_mag_err_col) = field_photometry.get_field_photometry_columns('normalized')\n phot_data = normalize_timeseries_photometry(phot_data, image_index,\n fit, covar_fit,\n mag_col, mag_err_col,\n norm_mag_col, norm_mag_err_col,\n log)\n\n # Plot a second RMS diagram of the lightcurves for all stars in this\n # filter, post normalization, for comparison\n image_index = np.where(xmatch.images['filter'] == filter)[0]\n phot_data_filter = phot_data[:,image_index,:]\n (mag_col, mag_err_col) = field_photometry.get_field_photometry_columns('normalized')\n plot_multisite_rms(params, phot_data_filter, mag_col, mag_err_col, qc_col,\n 'rms_postnorm_'+str(filter)+'.png', log)\n\n\n fig = plt.figure(3,(10,10))\n (norm_mag_col, norm_mag_err_col) = field_photometry.get_field_photometry_columns('normalized')\n idx = np.where(phot_data[star,:,norm_mag_col] > 0.0)[0]\n plt.errorbar(phot_data[star,idx,0], phot_data[star,idx,norm_mag_col],\n yerr=phot_data[star,idx,norm_mag_err_col], fmt='none', color='k')\n (xmin,xmax,ymin,ymax) = plt.axis()\n ymin = max(ymin,14.0)\n ymax = min(ymax,22.0)\n plt.axis([xmin,xmax,ymax,ymin])\n plt.xlabel('HJD')\n plt.ylabel('Mag')\n plt.savefig('Star_'+str(star)+'_lc_norm.png')\n plt.close(3)\n\n # Output updated crossmatch table\n xmatch.save(params['crossmatch_file'])\n\n # Output the photometry for quadrant 1:\n output_quadrant_photometry(params, setup, 1, phot_data, log)\n\n logs.close_log(log)\n\n status = 'OK'\n report = 'Completed successfully'\n return status, report",
"def normalise(image):",
"def normalize(image):\r\n return image / 127.5 - 1.",
"def normalize(self):\n self.image = rescale_intensity(self.image, out_range=(0, 255))",
"def _normalize(images):\n images -= images.mean(axis=0, keepdims=True)\n images /= np.maximum(images.std(axis=0, keepdims=True), 3e-1)",
"def _normalize(images):\n images -= images.mean(axis=0, keepdims=True)\n images /= np.maximum(images.std(axis=0, keepdims=True), 3e-1)",
"def normalize(image):\n return image / 127.5 - 1.",
"def convert_energy_2_internal_u(self,val):\n units = self.current_units[\"energy\"]\n cfact = conversion_facs_energy[self.current_units[\"energy\"]]\n \n # special handling for nano meters\n if units == \"nm\":\n # zero is interpretted as zero energy\n try:\n ret = numpy.zeros(val.shape, dtype=val.dtype)\n ret[val!=0.0] = 1.0/val[val!=0]\n return ret/cfact\n except: \n return (1.0/val)/cfact\n #if val == 0.0:\n # return 0.0\n #return (1.0/val)/cfact\n else:\n return val*cfact",
"def turn_intensity_normalization_on(self):\n self.intensity_normalize_image = True",
"def _normalize(self):\n\n n = len(self.e2[0])\n E = []\n\n for e2 in self.e2:\n if len(e2) != n:\n print 'WARNING: non consistent length in error statistics!!!'\n E.append(np.nansum(np.sqrt(e2))) # temporal aggregation\n\n E = np.asarray(E)\n EM = E.mean() # take square root, as e2 is still the squared error!\n self.e_norm = (E - EM) / EM # see Glecker et al, eq.2",
"def monitor_normalize(sansdata,mon0=1e8):\n monitor=sansdata.metadata['run.moncnt']\n result=sansdata.data*mon0/monitor\n res=SansData()\n res.data=result\n res.metadata=deepcopy(sansdata.metadata)\n res.qx=copy(sansdata.qx)\n res.qy=copy(sansdata.qy)\n res.theta=copy(sansdata.theta)\n return res",
"def run(self):\n #calculate platescale of first input image\n try:\n det = np.linalg.det(wcs.WCS(self.datain[0].header).wcs.cd)\n pscale = np.sqrt(np.abs(det))*3600.\n except:\n try:\n det = np.linalg.det(wcs.WCS(self.datain[0].header).wcs.pc)\n pscale = np.sqrt(np.abs(det))*3600.\n except:\n pscale = self.datain[0].header['PIXSCAL']\n #filtering out images which are too far away from the others\n #passing images added to a list of (image, WCS) tuples\n '''\n image_centers = []\n for f in self.datain:\n image_centers.append((f.header['CRVAL1'], f.header['CRVAL2']))\n filtered_datain = []\n dist_list = [[[0]*(len(image_centers)-1)]*len(image_centers)]\n for i in range(len(image_centers)):\n for j in range(len(image_centers)-1):\n dist_list[i][j+1] = np.sqrt((image_)**2+()**2)\n '''\n #calculations necessary for updating wcs information\n px = []\n py = []\n \n #in order to avoid NaN interactions, creating weight map\n weights=[]\n for f in self.datain:\n weights.append((np.where(np.isnan(f.image) == True, 0, 1)))\n \n for f in self.datain:\n px.extend(wcs.WCS(f.header).calc_footprint()[:,0])\n py.extend(wcs.WCS(f.header).calc_footprint()[:,1])\n x0 = (max(px)+min(px))/2.\n y0 = (max(py)+min(py))/2.\n sx = (max(px)-min(px))*np.cos(y0/180*np.pi) # arcsec\n sy = (max(py)-min(py)) # arcsec\n size = (sx*3600+self.getarg('pad')*2, sy*3600+self.getarg('pad')*2)\n xpix = size[0]//pscale\n ypix = size[1]//pscale\n cdelt = [pscale/3600.]*2\n \n #create self.dataout and give it a copy of an input's header\n self.dataout = DataFits(config = self.config)\n self.dataout.header = self.datain[0].header.copy()\n \n #update header wcs information\n self.log.info('Creating new WCS header')\n \n self.dataout.header['CRPIX1'] = xpix/2\n self.dataout.header['CRPIX2'] = ypix/2\n self.dataout.header['CRVAL1'] = x0\n self.dataout.header['CRVAL2'] = y0\n self.dataout.header['CD1_1'] = -cdelt[0]\n self.dataout.header['CD1_2'] = self.dataout.header['CD2_1'] = 0.\n self.dataout.header['CD2_2'] = cdelt[1]\n self.dataout.header['NAXIS1'] = int(xpix)\n self.dataout.header['NAXIS2'] = int(ypix)\n self.dataout.header['CTYPE1'] = 'RA---TAN-SIP'\n self.dataout.header['CTYPE2'] = 'DEC--TAN-SIP'\n self.dataout.header['RADESYS'] = 'ICRS'\n self.dataout.header['EQUINOX'] = 2000\n self.dataout.header['LATPOLE'] = self.datain[0].header['CRVAL2']\n self.dataout.header['LONPOLE'] = 180\n self.dataout.header['PIXASEC'] = pscale\n \n theta_rad = np.deg2rad(self.getarg('outangle'))\n rot_matrix = np.array([[np.cos(theta_rad), -np.sin(theta_rad)], \n [np.sin(theta_rad), np.cos(theta_rad)]])\n rot_cd = np.dot(rot_matrix, np.array([[self.dataout.header['CD1_1'], 0.],[0., self.dataout.header['CD2_2']]]))\n for i in [0,1]:\n for j in [0,1]:\n self.dataout.header['CD{0:d}_{1:d}'.format(i+1, j+1)] = rot_cd[i,j]\n \n #check drizzle arguments\n if self.getarg('kernel') == 'smoothing':\n kernel = 'lanczos3'\n elif self.getarg('kernel') in ['square', 'point', 'gaussian', 'tophat']:\n kernel = self.getarg('kernel')\n else:\n self.log.error('Kernel name not recognized, using default')\n kernel = 'square'\n if self.getarg('drizzleweights') == 'uniform':\n driz_wt = ''\n elif self.getarg('drizzleweights') in ['exptime', 'expsq']:\n driz_wt = self.getarg('drizzleweights')\n else:\n self.log.error('Drizzle weighting not recognized, using default')\n driz_wt = ''\n \n #create drizzle object and add input images\n fullwcs = wcs.WCS(self.dataout.header)\n self.log.info('Starting drizzle')\n driz = drz.Drizzle(outwcs = fullwcs, pixfrac=self.getarg('pixfrac'), \\\n kernel=kernel, fillval='10000', wt_scl=driz_wt)\n for i,f in enumerate(self.datain):\n self.log.info('Adding %s to drizzle stack' % f.filename)\n driz.add_image(f.imgdata[0], wcs.WCS(f.header), inwht=weights[i])\n \n try:\n fillval=float(self.getarg('fillval'))\n except:\n fillval=np.nan\n self.log.error('Fillvalue not recognized or missing, using default')\n \n #creates output fits file from drizzle output\n self.dataout.imageset(np.where(driz.outsci == 10000, fillval, driz.outsci))\n self.dataout.imageset(driz.outwht,'OutWeight', self.dataout.header)\n self.dataout.filename = self.datain[0].filename\n\n #add history\n self.dataout.setheadval('HISTORY','Coadd: %d files combined with %s kernel, pixfrac %f at %f times resolution' \\\n % (len(self.datain), kernel, self.getarg('pixfrac'), self.getarg('resolution')))",
"def normalize(image):\n image = image.astype(np.float32)\n mean = np.mean(image)\n std = np.std(image)\n if std > 0:\n ret = (image - mean) / std\n else:\n ret = image * 0.\n return ret",
"def make_flux_stdev_function():\n\n def uncertainty_function(prediction_dict):\n \"\"\"Computes stdev uncertainty of fluxes for each example.\n\n E = number of examples\n\n :param prediction_dict: Dictionary in format returned by\n `prediction_io.read_file`.\n :return: uncertainty_values: length-E numpy array of uncertainty values.\n \"\"\"\n\n num_ensemble_members = (\n prediction_dict[prediction_io.VECTOR_PREDICTIONS_KEY].shape[-1]\n )\n assert num_ensemble_members > 1\n\n model_file_name = prediction_dict[prediction_io.MODEL_FILE_KEY]\n model_metafile_name = neural_net.find_metafile(\n model_dir_name=os.path.split(model_file_name)[0],\n raise_error_if_missing=True\n )\n\n model_metadata_dict = neural_net.read_metafile(model_metafile_name)\n generator_option_dict = (\n model_metadata_dict[neural_net.TRAINING_OPTIONS_KEY]\n )\n scalar_target_names = (\n generator_option_dict[neural_net.SCALAR_TARGET_NAMES_KEY]\n )\n\n num_examples = (\n prediction_dict[prediction_io.VECTOR_PREDICTIONS_KEY].shape[0]\n )\n predicted_flux_matrix_w_m02 = numpy.full(\n (num_examples, 0, num_ensemble_members), numpy.nan\n )\n\n for this_name in SHORTWAVE_RAW_FLUX_NAMES + LONGWAVE_RAW_FLUX_NAMES:\n if this_name not in scalar_target_names:\n continue\n\n j = scalar_target_names.index(this_name)\n\n predicted_flux_matrix_w_m02 = numpy.concatenate((\n predicted_flux_matrix_w_m02,\n prediction_dict[prediction_io.SCALAR_PREDICTIONS_KEY][:, [j], :]\n ), axis=1)\n\n if all([n in scalar_target_names for n in SHORTWAVE_RAW_FLUX_NAMES]):\n down_index = scalar_target_names.index(\n example_utils.SHORTWAVE_SURFACE_DOWN_FLUX_NAME\n )\n up_index = scalar_target_names.index(\n example_utils.SHORTWAVE_TOA_UP_FLUX_NAME\n )\n this_matrix = prediction_dict[prediction_io.SCALAR_PREDICTIONS_KEY]\n\n predicted_flux_matrix_w_m02 = numpy.concatenate((\n predicted_flux_matrix_w_m02,\n this_matrix[:, [down_index], :] - this_matrix[:, [up_index], :]\n ), axis=1)\n\n elementwise_stdev_matrix_k_day01 = numpy.std(\n predicted_flux_matrix_w_m02, ddof=1, axis=-1\n )\n return numpy.sqrt(\n numpy.mean(elementwise_stdev_matrix_k_day01 ** 2, axis=-1)\n )\n\n return uncertainty_function",
"def normalize_image(self):\n # The image normalization is identical to Cloud TPU ResNet.\n self._image = tf.image.convert_image_dtype(self._image, dtype=tf.float32)\n offset = tf.constant(DATASET_MEAN)\n offset = tf.expand_dims(offset, axis=0)\n offset = tf.expand_dims(offset, axis=0)\n self._image -= offset\n\n scale = tf.constant(DATASET_VAR)\n scale = tf.expand_dims(scale, axis=0)\n scale = tf.expand_dims(scale, axis=0)\n self._image /= scale",
"def normalization(image):\n return (image - np.min(image)) / (np.max(image) - np.min(image))",
"def main():\n test_image = load_image()\n\n pixelate_image(\n normalize_image(test_image)\n )\n pass",
"def main():\n amplitute_variation = [0.98, 1.02]\n frequency_variation = [0, 0.06]\n transition_band = [(0.1*math.pi), (0.4*math.pi)]\n (passband, stopband, transition_band_diff) = set_diffs(\n amplitute_variation, frequency_variation, transition_band)\n omega_c = np.mean(transition_band)\n dB = to_dB(stopband)\n windowing_type = choose_window_type(dB)\n M = get_magnetude(transition_band_diff, windowing_type)\n result_filter = create_filter(M, omega_c, windowing_type)\n print('Filter: {0}\\nNormalized_filter: {1}'.format(\n result_filter, normalize(result_filter)))",
"def _normalize_images(self, images: th.Tensor) -> th.Tensor:\n output = ((images+2)/4 - self._norm_mean)/self._norm_std\n return output",
"def analyze(self, event):\n electrons = self.inputCollection(event)\n muons = Collection(event, \"Muon\")\n triggerObjects = self.triggerObjectCollection(event)\n\n selectedElectrons = []\n unselectedElectrons = []\n \n weight_reco_nominal = 1.\n weight_reco_up = 1.\n weight_reco_down = 1.\n\n weight_id_nominal = 1.\n weight_id_up = 1.\n weight_id_down = 1.\n\n for electron in electrons:\n # https://twiki.cern.ch/twiki/bin/view/CMS/CutBasedElectronIdentificationRun2\n if electron.pt>self.electronMinPt \\\n and math.fabs(electron.eta)<self.electronMaxEta \\\n and self.electronID(electron)\\\n and self.triggerMatched(electron, triggerObjects):\n\n dxy = math.fabs(electron.dxy)\n dz = math.fabs(electron.dz)\n \n if math.fabs(electron.eta) < 1.479 and (dxy>0.05 or dz>0.10):\n unselectedElectrons.append(electron)\n continue\n elif dxy>0.10 or dz>0.20:\n unselectedElectrons.append(electron)\n continue\n\n #reject electron if close-by muon\n if len(muons)>0:\n mindr = min(map(lambda muon: deltaR(muon, electron), muons))\n if mindr < 0.05:\n unselectedElectrons.append(electron)\n continue\n\n selectedElectrons.append(electron)\n \n #TODO: electron reco/ID SFs\n \n \n else:\n unselectedElectrons.append(electron)\n\n \n if not Module.globalOptions[\"isData\"] and self.storeWeights:\n \n self.out.fillBranch(self.outputName+\"_weight_reco_nominal\", weight_reco_nominal)\n self.out.fillBranch(self.outputName+\"_weight_reco_up\", weight_reco_up)\n self.out.fillBranch(self.outputName+\"_weight_reco_down\", weight_reco_down)\n\n self.out.fillBranch(self.outputName+\"_weight_id_nominal\",weight_id_nominal)\n self.out.fillBranch(self.outputName+\"_weight_id_up\",weight_id_up)\n self.out.fillBranch(self.outputName+\"_weight_id_down\",weight_id_down)\n\n self.out.fillBranch(\"n\"+self.outputName,len(selectedElectrons))\n\n for variable in self.storeKinematics:\n self.out.fillBranch(self.outputName+\"_\"+variable,map(lambda electron: getattr(electron,variable), selectedElectrons))\n\n setattr(event,self.outputName,selectedElectrons)\n setattr(event,self.outputName+\"_unselected\",unselectedElectrons)\n\n return True",
"def transformMeasurementError(self):\n var = self.model.observationError**2\n self.errShD = self.model.observationError\n self.errSinvD = 1.0/var\n self.errSinvhD = np.sqrt(self.errSinvD)",
"def norm_experiment():\n print(\"NORM_EXPERIMENT\")\n\n # set the name of the experiment\n now = datetime.datetime.now()\n experiment_id = str(now.day) + \"_\" + str(now.month) + \"_\" + str(now.hour) + \".\" + str(now.minute)\n experiment_name = 'normalization_' + str(experiment_id)\n\n # define if you want to use preprocessed data from file\n use_prep_data = False\n if use_prep_data:\n set_params(preproc_data_id='16_5_10.16.47')\n else:\n set_params(use_preproc_data=False)\n\n # define the changing parameter and its value\n changing_param_name = 'NORMALIZE'\n changing_param_value = [1, 0]\n # , {0:4, 1:100}, {0:3, 1:100}, {0:2, 1:100}, {0:1, 1:100}] #[{0:1, 1:1}, {0:15, 1:85}]#\n\n # set constant parameters\n set_params(epochs=20)\n set_params(dropout=0.3)\n set_params(use_word_emb=1)\n\n # save constant parameters to a new \"experiment_..\" file\n save_constant_parameters(experiment_name, changing_param_name)\n\n # run experiment for every parameter value\n for value in changing_param_value:\n\n # update the parameter value\n set_params(normalize = value)\n\n # update the model_id for this new model\n now = datetime.datetime.now()\n new_model_id = str(now.day) + \"_\" + str(now.month) + \"_\" + str(now.hour) + \".\" + str(now.minute) + \".\" + str(now.second)\n set_params(model_id = new_model_id)\n\n # evaluate the new model and save the results in the experiment file\n oneExperiment = Process(target=run_experiment, args=(experiment_name, new_model_id, changing_param_name, value,))\n oneExperiment.start()\n oneExperiment.join()",
"def __call__(self, results):\n for key in results.get('img_fields', ['img']):\n results[key] = general_ocr.imnormalize(results[key], self.mean, self.std,\n self.to_rgb)\n results['img_norm_cfg'] = dict(\n mean=self.mean, std=self.std, to_rgb=self.to_rgb)\n return results",
"def normalize(image):\n mean = image.mean()\n stddev = image.std()\n adjusted_stddev = max(stddev, 1.0/math.sqrt(image.size))\n standardized_image = (image - mean) / adjusted_stddev\n \n return standardized_image",
"def normalize(image):\n mean = image.mean()\n stddev = image.std()\n adjusted_stddev = max(stddev, 1.0/math.sqrt(image.size))\n standardized_image = (image - mean) / adjusted_stddev\n \n return standardized_image"
] | [
"0.55928487",
"0.54889816",
"0.5454765",
"0.54423666",
"0.5435256",
"0.5370167",
"0.5334091",
"0.53084034",
"0.5299961",
"0.527705",
"0.527705",
"0.52367365",
"0.5215581",
"0.5211756",
"0.52079666",
"0.5163994",
"0.5149342",
"0.51089543",
"0.51064676",
"0.5093443",
"0.5086404",
"0.5078151",
"0.5071362",
"0.50599927",
"0.50595546",
"0.5042426",
"0.504094",
"0.5039783",
"0.5027069",
"0.5027069"
] | 0.70171016 | 0 |
Generate generic betweenagent measurement message from local measurement message. | def gen_measurement_msg(agent_id,msg):
if type(msg) is list:
meas_msg = []
for m in msg:
new_msg = AgentMeasurement()
# new_msg.type = msg._type.split('/')[1]
new_msg.header.stamp = rospy.Time.now()
new_msg.src = agent_id
if m._type == 'offset_etddf/linrelMeasurement':
new_msg.type = 'rel'
new_msg.data = [m.x, m.y]
new_msg.target = int(m.robot_measured.split("_")[1])
elif m._type == 'offset_etddf/gpsMeasurement':
new_msg.type = 'abs'
new_msg.data = [m.x, m.y]
new_msg.status = [1 for x in new_msg.data]
meas_msg.append(new_msg)
return meas_msg
else:
meas_msg = AgentMeasurement()
# meas_msg.type = msg._type.split('/')[1]
meas_msg.header.stamp = rospy.Time.now()
meas_msg.src = agent_id
if msg._type == 'offset_etddf/linrelMeasurement':
meas_msg.type = 'rel'
meas_msg.data = [msg.x, msg.y]
new_msg.target = int(m.robot_measured.split("_")[1])
elif msg._type == 'offset_etddf/gpsMeasurement':
meas_msg.type = 'abs'
meas_msg.data = [msg.x, msg.y]
meas_msg.status = [1 for x in meas_msg.data]
return meas_msg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_message(self):\n meter = Meter.objects.get_or_create(name=\"4530303237303030303130313334353136\")[0]\n\n measurement = Measurement()\n measurement.meter = meter\n measurement.power_usage_current = random.randint(300,400) / 1000\n measurement.power_usage_total_low = 0\n measurement.power_usage_total_normal = 0\n measurement.power_supply_current = random.randint(300,400) / 1000\n measurement.power_supply_total_low = 0\n measurement.power_supply_total_normal = 0\n measurement.timestamp = datetime.now(pytz.utc)\n\n if(measurement.power_usage_current < measurement.power_supply_current):\n measurement.power_usage_current = 0\n else :\n measurement.power_supply_current = 0\n\n return measurement",
"def ros2python_measurement(msg_ros):\n \n if type(msg_ros) is list:\n\n msg_python = []\n\n for msg in msg_ros:\n\n new_msg = MeasurementMsg(msg.src,\n msg.dest,\n msg.target,\n msg.status,\n msg.type,\n msg.data,\n msg.header.stamp.to_sec())\n\n msg_python.append(new_msg)\n\n return msg_python\n\n else:\n\n msg_python = MeasurementMsg(msg.src,\n msg.dest,\n msg.target,\n msg.status,\n msg.type,\n msg.data,\n msg.header.stamp.to_sec())\n\n return msg_python",
"def create_message_updates(self, simulation_id, message):\n try:\n message_str = 'received message ' + str(message)\n\n builder = asiodnp3.UpdateBuilder()\n json_msg = yaml.safe_load(str(message))\n\n if type(json_msg) != dict:\n raise ValueError(\n ' is not a json formatted string.'\n + '\\njson_msg = {0}'.format(json_msg))\n\n # fncs_input_message = {\"{}\".format(simulation_id): {}}\n measurement_values = json_msg[\"message\"][\"measurements\"]\n\n # Calculate each net-phase measurement\n if(measurement_values):\n\n myPoints = self.outstation.get_agent().point_definitions.all_points()\n netPoints = list(filter(lambda x: \"net-\" in x.description, myPoints))\n \n for point in netPoints:\n ptMeasurements = list(filter(lambda m: m.get(\"measurement_mrid\") in point.measurement_id, measurement_values.values()))\n netValue = 0.0\n \n for m in ptMeasurements:\n if \"VAR\" in point.name:\n angle = math.radians(m.get(\"angle\"))\n netValue = netValue + math.sin(angle) * float(m.get(\"magnitude\"))\n\n elif \"Watts\" in point.name:\n angle = math.radians(m.get(\"angle\"))\n netValue += math.cos(angle) * float(m.get(\"magnitude\"))\n\n else:\n netValue += float(m.get(\"magnitude\"))\n\n point.magnitude = netValue\n builder.Update(opendnp3.Analog(point.magnitude), point.index)\n\n # Calculate each measurement\n for y in measurement_values:\n # print(self.processor_point_def.points_by_mrid())\n m = measurement_values[y]\n\n if \"magnitude\" in m.keys():\n for point in self.outstation.get_agent().point_definitions.all_points():\n #print(\"point\",point.name)\n #print(\"y\",y)\n if m.get(\"measurement_mrid\") == point.measurement_id:\n if point.magnitude != float(m.get(\"magnitude\")):\n point.magnitude = float(m.get(\"magnitude\"))\n builder.Update(opendnp3.Analog(point.magnitude), point.index)\n\n if point.measurement_type == \"VA\":\n if \"VAR\" in point.name:\n angle = math.radians(m.get(\"angle\"))\n point.magnitude = math.sin(angle) * float(m.get(\"magnitude\"))\n builder.Update(opendnp3.Analog(point.magnitude), point.index)\n\n if \"Watts\" in point.name:\n angle1 = math.radians(m.get(\"angle\"))\n point.magnitude = math.cos(angle1) * float(m.get(\"magnitude\"))\n builder.Update(opendnp3.Analog(point.magnitude), point.index)\n\n if \"angle\" in point.name:\n angle2 = math.radians(m.get(\"angle\"))\n builder.Update(opendnp3.Analog(angle2), point.index)\n\n elif \"value\" in m.keys():\n for point in self.outstation.get_agent().point_definitions.all_points():\n if m.get(\"measurement_mrid\") == point.measurement_id and point.value != m.get(\"value\"):\n point.value = m.get(\"value\")\n builder.Update(opendnp3.Binary(point.value), point.index)\n\n # Return the atomic \"updates\" object\n print(\"Updates Created\")\n return builder.Build()\n except Exception as e:\n message_str = \"An error occurred while trying to translate the message received\" + str(e)",
"def generate_message(self, mtu):\r\n return self.state.generate_message(mtu)",
"def makeAMQPmsg(self):\n msg = {'msgType' : 'AgentUpdate',\n 'AgentType': 'Bus',\n 'Extnum':self.Extnum,\n 'Vm': self.cv['Vm'],\n 'Va': self.cv['Va'],\n }\n return msg",
"def parse_msg(msg, stationary_R=False):\n x_hat, y_hat, zone_num, zone_letter = utm.from_latlon(msg['lat'], msg['lon'])\n\n heading = msg['heading']\n\n # convert from degrees from true north to\n # degrees from x axis (UTM easting)\n heading = (-heading + 90.) % 360.\n\n measurement = np.array([x_hat, y_hat, msg['speed'], heading])\n\n x_rms = msg['rms_lat']\n y_rms = msg['rms_lon']\n\n if not stationary_R:\n return measurement, x_rms, y_rms\n else:\n return measurement",
"def measure():\n print(\"alias, timestamp, current, total, power, voltage, err_code\")\n message_str = MeasurementRequest(None).to_json()\n socket_object = UdpSocket()\n s = UDPSendThread(message_str, socket_object)\n r = UDPRecvThread(socket_object, measurement_output_parser)\n s.start()\n r.start()\n\n wait((s, r))",
"def outgoing_message(self,msg):\n if msg._type == 'offset_etddf/AgentMeasurement':\n self.comms_meas_pub.publish(msg)\n elif msg._type == 'offset_etddf/AgentState':\n self.comms_state_pub.publish(msg)",
"def python2ros_measurement(msg_python):\n\n if type(msg_python) is list:\n\n msg_ros = []\n\n for msg in msg_python:\n\n new_msg = AgentMeasurement()\n \n new_msg.src = msg.src\n new_msg.dest = msg.dest\n new_msg.target = msg.target\n new_msg.status = msg.status\n new_msg.type = msg.type_\n new_msg.data = msg.data\n new_msg.header.stamp = rospy.Time.now()\n\n msg_ros.append(new_msg)\n\n return msg_ros\n\n else:\n\n new_msg = AgentMeasurement()\n \n new_msg.src = msg.src\n new_msg.dest = msg.dest\n new_msg.target = msg.target\n new_msg.status = msg.status\n new_msg.type = msg.type_\n new_msg.data = msg.data\n new_msg.header.stamp = rospy.Time.now()\n\n return msg_ros",
"def makeMessage( name, *structure ):\n return X12Message( name, *structure )",
"def _generate_omf_measurement(asset_code):\n\n asset_id = asset_code.replace(\" \", \"\")\n return _OMF_PREFIX_MEASUREMENT + asset_id",
"def _get_meas_identifier(self, msg, undo=False):\n if not undo:\n meas_type = msg.meas_type\n if \"implicit\" in meas_type:\n meas_type = meas_type.split(\"_implicit\")[0]\n elif \"burst\" in meas_type:\n meas_type = meas_type.split(\"_burst\")[0]\n identifier = \"{}-{}-{}\".format(meas_type, msg.src_asset, msg.measured_asset)\n return identifier\n else: # Go from msg (msg_id) ==> ros msg\n meas_type, src_asset, measured_asset = msg.split(\"-\")\n m = Measurement()\n m.meas_type = meas_type\n m.src_asset = src_asset\n m.measured_asset = measured_asset\n return m",
"def test_serialize_through_message(self):\n s1 = StatsEntry(self.stats, \"test\", \"GET\")\n s1.log(10, 0)\n s1.log(20, 0)\n s1.log(40, 0)\n u1 = StatsEntry.unserialize(s1.serialize())\n\n data = Message.unserialize(\n Message(\"dummy\", s1.serialize(), \"none\").serialize()\n ).data\n u1 = StatsEntry.unserialize(data)\n\n self.assertEqual(20, u1.median_response_time)",
"def on_message(self, simulation_id,message):\n\n try:\n message_str = 'received message ' + str(message)\n\n json_msg = yaml.safe_load(str(message))\n\n if type(json_msg) != dict:\n raise ValueError(\n ' is not a json formatted string.'\n + '\\njson_msg = {0}'.format(json_msg))\n\n # fncs_input_message = {\"{}\".format(simulation_id): {}}\n measurement_values = json_msg[\"message\"][\"measurements\"]\n\n # storing the magnitude and measurement_mRID values to publish in the dnp3 points for measurement key values\n for y in measurement_values:\n # print(self.processor_point_def.points_by_mrid())\n m = measurement_values[y]\n if \"magnitude\" in m.keys():\n for point in self.outstation.get_agent().point_definitions.all_points():\n #print(\"point\",point)\n #print(\"y\",y)\n if m.get(\"measurement_mrid\") == point.measurement_id and point.magnitude != m.get(\"magnitude\"):\n point.magnitude = m.get(\"magnitude\")\n self.outstation.apply_update(opendnp3.Analog(point.magnitude), point.index)\n\n elif point.measurement_type == \"VA\" and \"VAR\" in point.name:\n angle = math.radians(m.get(\"angle\"))\n point.magnitude = math.sin(angle) * m.get(\"magnitude\")\n self.outstation.apply_update(opendnp3.Analog(point.magnitude), point.index)\n \n elif point.measurement_type == \"VA\" and \"Watts\" in point.name:\n angle1 = math.radians(m.get(\"angle\"))\n point.magnitude = math.cos(angle1) * m.get(\"magnitude\")\n self.outstation.apply_update(opendnp3.Analog(point.magnitude), point.index)\n \n elif point.measurement_type == \"VA\" and \"angle\" in point.name:\n angle2 = math.radians(m.get(\"angle\"))\n #point.magnitude = math.cos(angle1) * m.get(\"magnitude\")\n self.outstation.apply_update(opendnp3.Analog(angle2), point.index)\n \n \n elif \"value\" in m.keys():\n for point in self.outstation.get_agent().point_definitions.all_points():\n if m.get(\"measurement_mrid\") == point.measurement_id and point.value != m.get(\"value\"):\n point.value = m.get(\"value\")\n self.outstation.apply_update(opendnp3.Binary(point.value), point.index)\n except Exception as e:\n message_str = \"An error occurred while trying to translate the message received\" + str(e)",
"def makemsg2write(innermsg, inputtext=''):\n nowtuple = time.time()\n nowdatetime = datetime.datetime.fromtimestamp(nowtuple)\n finnalmsg = {'fmId': math.floor(nowtuple),\n 'fmTime': nowdatetime.strftime(\"%Y-%m-%d %H:%M:%S\"),\n 'fmSend': True, 'fmSender': innermsg['fmSender'],\n 'fmType': 'Text',\n 'fmText': f\"{inputtext}\"\n }\n writefmmsg2txtandmaybeevernotetoo(finnalmsg)",
"def get_measurements(self):\r\n self.msg_send_upr.data[0] = b\"\\xff\"[0]\r\n self.send_and_flush(self.msg_send_upr)",
"def __init__(self, *args, **kwds):\n if args or kwds:\n super(mav_monitor, self).__init__(*args, **kwds)\n #message fields cannot be None, assign default values for those that are\n if self.header is None:\n self.header = std_msgs.msg.Header()\n if self.battery_voltage is None:\n self.battery_voltage = 0.\n if self.flight_mode_ll is None:\n self.flight_mode_ll = ''\n if self.state_estimation is None:\n self.state_estimation = ''\n if self.position_control is None:\n self.position_control = ''\n if self.serial_interface_enabled is None:\n self.serial_interface_enabled = False\n if self.serial_interface_active is None:\n self.serial_interface_active = False\n if self.flight_time is None:\n self.flight_time = 0.\n if self.cpu_load is None:\n self.cpu_load = 0.\n if self.motor_status is None:\n self.motor_status = ''\n if self.gps_status is None:\n self.gps_status = ''\n if self.gps_num_satellites is None:\n self.gps_num_satellites = 0\n if self.have_SSDK_parameters is None:\n self.have_SSDK_parameters = False\n if self.timesync_offset is None:\n self.timesync_offset = 0.\n if self.rc_channel is None:\n self.rc_channel = [0,0,0,0,0,0,0,0]\n if self.control_axes is None:\n self.control_axes = [0,0,0,0,0,0]\n if self.control_buttons is None:\n self.control_buttons = []\n if self.latitude is None:\n self.latitude = 0.\n if self.longitude is None:\n self.longitude = 0.\n if self.altitude is None:\n self.altitude = 0.\n if self.pressure_height is None:\n self.pressure_height = 0.\n if self.velocity_x is None:\n self.velocity_x = 0.\n if self.velocity_y is None:\n self.velocity_y = 0.\n else:\n self.header = std_msgs.msg.Header()\n self.battery_voltage = 0.\n self.flight_mode_ll = ''\n self.state_estimation = ''\n self.position_control = ''\n self.serial_interface_enabled = False\n self.serial_interface_active = False\n self.flight_time = 0.\n self.cpu_load = 0.\n self.motor_status = ''\n self.gps_status = ''\n self.gps_num_satellites = 0\n self.have_SSDK_parameters = False\n self.timesync_offset = 0.\n self.rc_channel = [0,0,0,0,0,0,0,0]\n self.control_axes = [0,0,0,0,0,0]\n self.control_buttons = []\n self.latitude = 0.\n self.longitude = 0.\n self.altitude = 0.\n self.pressure_height = 0.\n self.velocity_x = 0.\n self.velocity_y = 0.",
"def pack(self):\n if self.originalOriginate is None:\n os, on = divmod(self.originateNanos,1000000000)\n else:\n os, on = self.originalOriginate\n rs, rn = divmod(self.receiveNanos, 1000000000)\n ts, tn = divmod(self.transmitNanos, 1000000000)\n msg = struct.pack(WCMessage.STRUCT_FMT, 0, self.msgtype, self.precision, 0, self.maxFreqError, os, on, rs, rn, ts, tn) \n return msg",
"def import_measurements():\n\n print('Receive a transfer...')",
"def _create_message(self, msg):\n head = msg[\"head\"]\n body = msg[\"body\"]\n body = body.format(**self.data)\n length = len(body)\n head = head.format(length=length, **self.data)\n return head + body",
"def make_message(parsed):\n frame = {\n 'technology': 'LoRa',\n 'freq': parsed[3],\n 'bw': parsed[4],\n 'sf': parsed[5],\n 'snr': parsed[9] / 100.0,\n 'length': parsed[11],\n 'payload': str(parsed[14]).decode('latin-1').encode(\"utf-8\")\n }\n print frame\n return frame",
"def deserialize(self, str):\n try:\n if self.model_aligned is None:\n self.model_aligned = articulation_msgs.msg.ModelMsg()\n if self.data_aligned is None:\n self.data_aligned = articulation_msgs.msg.ModelMsg()\n end = 0\n _x = self\n start = end\n end += 12\n (_x.model_aligned.header.seq, _x.model_aligned.header.stamp.secs, _x.model_aligned.header.stamp.nsecs,) = _struct_3I.unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.model_aligned.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.model_aligned.header.frame_id = str[start:end]\n start = end\n end += 4\n (self.model_aligned.id,) = _struct_i.unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.model_aligned.name = str[start:end].decode('utf-8')\n else:\n self.model_aligned.name = str[start:end]\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.model_aligned.params = []\n for i in range(0, length):\n val1 = articulation_msgs.msg.ParamMsg()\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n val1.name = str[start:end].decode('utf-8')\n else:\n val1.name = str[start:end]\n _x = val1\n start = end\n end += 9\n (_x.value, _x.type,) = _struct_dB.unpack(str[start:end])\n self.model_aligned.params.append(val1)\n _x = self\n start = end\n end += 12\n (_x.model_aligned.track.header.seq, _x.model_aligned.track.header.stamp.secs, _x.model_aligned.track.header.stamp.nsecs,) = _struct_3I.unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.model_aligned.track.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.model_aligned.track.header.frame_id = str[start:end]\n start = end\n end += 4\n (self.model_aligned.track.id,) = _struct_i.unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.model_aligned.track.pose = []\n for i in range(0, length):\n val1 = geometry_msgs.msg.Pose()\n _v71 = val1.position\n _x = _v71\n start = end\n end += 24\n (_x.x, _x.y, _x.z,) = _struct_3d.unpack(str[start:end])\n _v72 = val1.orientation\n _x = _v72\n start = end\n end += 32\n (_x.x, _x.y, _x.z, _x.w,) = _struct_4d.unpack(str[start:end])\n self.model_aligned.track.pose.append(val1)\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.model_aligned.track.pose_headers = []\n for i in range(0, length):\n val1 = std_msgs.msg.Header()\n start = end\n end += 4\n (val1.seq,) = _struct_I.unpack(str[start:end])\n _v73 = val1.stamp\n _x = _v73\n start = end\n end += 8\n (_x.secs, _x.nsecs,) = _struct_2I.unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n val1.frame_id = str[start:end].decode('utf-8')\n else:\n val1.frame_id = str[start:end]\n self.model_aligned.track.pose_headers.append(val1)\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.model_aligned.track.pose_projected = []\n for i in range(0, length):\n val1 = geometry_msgs.msg.Pose()\n _v74 = val1.position\n _x = _v74\n start = end\n end += 24\n (_x.x, _x.y, _x.z,) = _struct_3d.unpack(str[start:end])\n _v75 = val1.orientation\n _x = _v75\n start = end\n end += 32\n (_x.x, _x.y, _x.z, _x.w,) = _struct_4d.unpack(str[start:end])\n self.model_aligned.track.pose_projected.append(val1)\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.model_aligned.track.pose_resampled = []\n for i in range(0, length):\n val1 = geometry_msgs.msg.Pose()\n _v76 = val1.position\n _x = _v76\n start = end\n end += 24\n (_x.x, _x.y, _x.z,) = _struct_3d.unpack(str[start:end])\n _v77 = val1.orientation\n _x = _v77\n start = end\n end += 32\n (_x.x, _x.y, _x.z, _x.w,) = _struct_4d.unpack(str[start:end])\n self.model_aligned.track.pose_resampled.append(val1)\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sI'%length\n start = end\n end += struct.calcsize(pattern)\n self.model_aligned.track.pose_flags = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.model_aligned.track.channels = []\n for i in range(0, length):\n val1 = sensor_msgs.msg.ChannelFloat32()\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n val1.name = str[start:end].decode('utf-8')\n else:\n val1.name = str[start:end]\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sf'%length\n start = end\n end += struct.calcsize(pattern)\n val1.values = struct.unpack(pattern, str[start:end])\n self.model_aligned.track.channels.append(val1)\n _x = self\n start = end\n end += 12\n (_x.data_aligned.header.seq, _x.data_aligned.header.stamp.secs, _x.data_aligned.header.stamp.nsecs,) = _struct_3I.unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.data_aligned.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.data_aligned.header.frame_id = str[start:end]\n start = end\n end += 4\n (self.data_aligned.id,) = _struct_i.unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.data_aligned.name = str[start:end].decode('utf-8')\n else:\n self.data_aligned.name = str[start:end]\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.data_aligned.params = []\n for i in range(0, length):\n val1 = articulation_msgs.msg.ParamMsg()\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n val1.name = str[start:end].decode('utf-8')\n else:\n val1.name = str[start:end]\n _x = val1\n start = end\n end += 9\n (_x.value, _x.type,) = _struct_dB.unpack(str[start:end])\n self.data_aligned.params.append(val1)\n _x = self\n start = end\n end += 12\n (_x.data_aligned.track.header.seq, _x.data_aligned.track.header.stamp.secs, _x.data_aligned.track.header.stamp.nsecs,) = _struct_3I.unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.data_aligned.track.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.data_aligned.track.header.frame_id = str[start:end]\n start = end\n end += 4\n (self.data_aligned.track.id,) = _struct_i.unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.data_aligned.track.pose = []\n for i in range(0, length):\n val1 = geometry_msgs.msg.Pose()\n _v78 = val1.position\n _x = _v78\n start = end\n end += 24\n (_x.x, _x.y, _x.z,) = _struct_3d.unpack(str[start:end])\n _v79 = val1.orientation\n _x = _v79\n start = end\n end += 32\n (_x.x, _x.y, _x.z, _x.w,) = _struct_4d.unpack(str[start:end])\n self.data_aligned.track.pose.append(val1)\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.data_aligned.track.pose_headers = []\n for i in range(0, length):\n val1 = std_msgs.msg.Header()\n start = end\n end += 4\n (val1.seq,) = _struct_I.unpack(str[start:end])\n _v80 = val1.stamp\n _x = _v80\n start = end\n end += 8\n (_x.secs, _x.nsecs,) = _struct_2I.unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n val1.frame_id = str[start:end].decode('utf-8')\n else:\n val1.frame_id = str[start:end]\n self.data_aligned.track.pose_headers.append(val1)\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.data_aligned.track.pose_projected = []\n for i in range(0, length):\n val1 = geometry_msgs.msg.Pose()\n _v81 = val1.position\n _x = _v81\n start = end\n end += 24\n (_x.x, _x.y, _x.z,) = _struct_3d.unpack(str[start:end])\n _v82 = val1.orientation\n _x = _v82\n start = end\n end += 32\n (_x.x, _x.y, _x.z, _x.w,) = _struct_4d.unpack(str[start:end])\n self.data_aligned.track.pose_projected.append(val1)\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.data_aligned.track.pose_resampled = []\n for i in range(0, length):\n val1 = geometry_msgs.msg.Pose()\n _v83 = val1.position\n _x = _v83\n start = end\n end += 24\n (_x.x, _x.y, _x.z,) = _struct_3d.unpack(str[start:end])\n _v84 = val1.orientation\n _x = _v84\n start = end\n end += 32\n (_x.x, _x.y, _x.z, _x.w,) = _struct_4d.unpack(str[start:end])\n self.data_aligned.track.pose_resampled.append(val1)\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sI'%length\n start = end\n end += struct.calcsize(pattern)\n self.data_aligned.track.pose_flags = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.data_aligned.track.channels = []\n for i in range(0, length):\n val1 = sensor_msgs.msg.ChannelFloat32()\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n val1.name = str[start:end].decode('utf-8')\n else:\n val1.name = str[start:end]\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sf'%length\n start = end\n end += struct.calcsize(pattern)\n val1.values = struct.unpack(pattern, str[start:end])\n self.data_aligned.track.channels.append(val1)\n start = end\n end += 72\n self.R = _struct_9d.unpack(str[start:end])\n start = end\n end += 24\n self.T = _struct_3d.unpack(str[start:end])\n _x = self\n start = end\n end += 12\n (_x.dist_rot, _x.dist_trans,) = _struct_df.unpack(str[start:end])\n return self\n except struct.error as e:\n raise genpy.DeserializationError(e) #most likely buffer underfill",
"def _create_msg(self, tr_id, i_triples, i_type, r_triples, r_type, confirm):\n params = SSAP_UPDATE_PARAM_TEMPLATE % (str(i_type).upper(),\n str(i_triples),\n str(r_type).upper(),\n str(r_triples),\n str(confirm).upper())\n tmp = SSAP_MESSAGE_TEMPLATE % (str(self.node_id), str(self.targetSS),\n self.tr_type, str(tr_id), params)\n return tmp",
"def _build_get_device_status_user_data_message(self) -> LocalServerInfo_pb2.LocalServerMessage:\n magic_number = self._get_magic_number()\n message = LocalServerInfo_pb2.LocalServerMessage()\n message.localcode = self.local_code\n message.magic_num = magic_number\n message.c.type = 1\n\n return message",
"def wrap_information_object_m_me_nc_1(self, message):\n if not type(message) is tuple:\n return \"ERROR: M_ME_NC_1 expects a float value and a tuple containing some bits of the IEC 104 quality descriptor in a tuple.\"\n if not type(message[0]) is float:\n return \"ERROR: M_ME_NC_1 expects a float value.\"\n io = self.wrap_quality_descriptor(0, message[1][0], message[1][1], message[1][2], message[1][3])\n if type(io) is str:\n return io\n return struct.pack('<f', message[0]) + io",
"def multidim_measurement_to_attachment(name, measurement):\n\n dimensions = list(measurement.dimensions)\n if measurement.units:\n dimensions.append(\n measurements.Dimension.from_unit_descriptor(measurement.units))\n\n dims = []\n for d in dimensions:\n if d.suffix is None:\n suffix = u''\n else:\n suffix = d.suffix\n dims.append({\n 'uom_suffix': suffix,\n 'uom_code': d.code,\n 'name': d.name,\n })\n # Refer to the module docstring for the expected schema.\n dimensioned_measured_value = measurement.measured_value\n value = (\n sorted(dimensioned_measured_value.value, key=lambda x: x[0])\n if dimensioned_measured_value.is_value_set else None)\n outcome_str = _measurement_outcome_to_test_run_status_name(\n measurement.outcome, measurement.marginal)\n data = _convert_object_to_json({\n 'outcome': outcome_str,\n 'name': name,\n 'dimensions': dims,\n 'value': value,\n })\n attachment = htf_test_record.Attachment(data, test_runs_pb2.MULTIDIM_JSON) # pytype: disable=wrong-arg-types # gen-stub-imports\n\n return attachment",
"def deserialize(self, str):\n try:\n if self.header is None:\n self.header = std_msgs.msg.Header()\n if self.localStamp is None:\n self.localStamp = vehicle_msgs.msg.FrameStamp()\n if self.globalStamp is None:\n self.globalStamp = vehicle_msgs.msg.FrameStamp()\n if self.camera is None:\n self.camera = vehicle_msgs.msg.Camera()\n if self.camera_obj is None:\n self.camera_obj = None\n if self.camera_lane is None:\n self.camera_lane = vehicle_msgs.msg.Camera_Lane()\n end = 0\n _x = self\n start = end\n end += 12\n (_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.header.frame_id = str[start:end]\n _x = self\n start = end\n end += 16\n (_x.messageID, _x.localStamp.header.seq, _x.localStamp.header.stamp.secs, _x.localStamp.header.stamp.nsecs,) = _get_struct_i3I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.localStamp.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.localStamp.header.frame_id = str[start:end]\n _x = self\n start = end\n end += 32\n (_x.localStamp.time, _x.localStamp.lat, _x.localStamp.lng, _x.localStamp.height,) = _get_struct_4d().unpack(str[start:end])\n start = end\n end += 24\n self.localStamp.position = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n self.localStamp.orientation = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n self.localStamp.linearSpeed = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n self.localStamp.angularSpeed = _get_struct_3d().unpack(str[start:end])\n _x = self\n start = end\n end += 12\n (_x.globalStamp.header.seq, _x.globalStamp.header.stamp.secs, _x.globalStamp.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.globalStamp.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.globalStamp.header.frame_id = str[start:end]\n _x = self\n start = end\n end += 32\n (_x.globalStamp.time, _x.globalStamp.lat, _x.globalStamp.lng, _x.globalStamp.height,) = _get_struct_4d().unpack(str[start:end])\n start = end\n end += 24\n self.globalStamp.position = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n self.globalStamp.orientation = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n self.globalStamp.linearSpeed = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n self.globalStamp.angularSpeed = _get_struct_3d().unpack(str[start:end])\n _x = self\n start = end\n end += 12\n (_x.camera.header.seq, _x.camera.header.stamp.secs, _x.camera.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.camera.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.camera.header.frame_id = str[start:end]\n _x = self\n start = end\n end += 16\n (_x.camera.messageID, _x.camera.localStamp.header.seq, _x.camera.localStamp.header.stamp.secs, _x.camera.localStamp.header.stamp.nsecs,) = _get_struct_i3I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.camera.localStamp.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.camera.localStamp.header.frame_id = str[start:end]\n _x = self\n start = end\n end += 32\n (_x.camera.localStamp.time, _x.camera.localStamp.lat, _x.camera.localStamp.lng, _x.camera.localStamp.height,) = _get_struct_4d().unpack(str[start:end])\n start = end\n end += 24\n self.camera.localStamp.position = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n self.camera.localStamp.orientation = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n self.camera.localStamp.linearSpeed = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n self.camera.localStamp.angularSpeed = _get_struct_3d().unpack(str[start:end])\n _x = self\n start = end\n end += 12\n (_x.camera.globalStamp.header.seq, _x.camera.globalStamp.header.stamp.secs, _x.camera.globalStamp.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.camera.globalStamp.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.camera.globalStamp.header.frame_id = str[start:end]\n _x = self\n start = end\n end += 32\n (_x.camera.globalStamp.time, _x.camera.globalStamp.lat, _x.camera.globalStamp.lng, _x.camera.globalStamp.height,) = _get_struct_4d().unpack(str[start:end])\n start = end\n end += 24\n self.camera.globalStamp.position = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n self.camera.globalStamp.orientation = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n self.camera.globalStamp.linearSpeed = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n self.camera.globalStamp.angularSpeed = _get_struct_3d().unpack(str[start:end])\n _x = self\n start = end\n end += 12\n (_x.camera.camera_numobstacles, _x.camera.VehSpeed,) = _get_struct_id().unpack(str[start:end])\n self.camera_obj = []\n for i in range(0, 10):\n val1 = vehicle_msgs.msg.Camera_Obj()\n _v9 = val1.header\n start = end\n end += 4\n (_v9.seq,) = _get_struct_I().unpack(str[start:end])\n _v10 = _v9.stamp\n _x = _v10\n start = end\n end += 8\n (_x.secs, _x.nsecs,) = _get_struct_2I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n _v9.frame_id = str[start:end].decode('utf-8')\n else:\n _v9.frame_id = str[start:end]\n start = end\n end += 4\n (val1.messageID,) = _get_struct_i().unpack(str[start:end])\n _v11 = val1.localStamp\n _v12 = _v11.header\n start = end\n end += 4\n (_v12.seq,) = _get_struct_I().unpack(str[start:end])\n _v13 = _v12.stamp\n _x = _v13\n start = end\n end += 8\n (_x.secs, _x.nsecs,) = _get_struct_2I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n _v12.frame_id = str[start:end].decode('utf-8')\n else:\n _v12.frame_id = str[start:end]\n _x = _v11\n start = end\n end += 32\n (_x.time, _x.lat, _x.lng, _x.height,) = _get_struct_4d().unpack(str[start:end])\n start = end\n end += 24\n _v11.position = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n _v11.orientation = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n _v11.linearSpeed = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n _v11.angularSpeed = _get_struct_3d().unpack(str[start:end])\n _v14 = val1.globalStamp\n _v15 = _v14.header\n start = end\n end += 4\n (_v15.seq,) = _get_struct_I().unpack(str[start:end])\n _v16 = _v15.stamp\n _x = _v16\n start = end\n end += 8\n (_x.secs, _x.nsecs,) = _get_struct_2I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n _v15.frame_id = str[start:end].decode('utf-8')\n else:\n _v15.frame_id = str[start:end]\n _x = _v14\n start = end\n end += 32\n (_x.time, _x.lat, _x.lng, _x.height,) = _get_struct_4d().unpack(str[start:end])\n start = end\n end += 24\n _v14.position = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n _v14.orientation = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n _v14.linearSpeed = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n _v14.angularSpeed = _get_struct_3d().unpack(str[start:end])\n _x = val1\n start = end\n end += 136\n (_x.camera_obstacle_id, _x.camera_obstacleposx, _x.camera_obstacleposy, _x.blinkerInfo, _x.cut_in_and_out, _x.obstacle_type, _x.obstacle_status, _x.obstacle_valid, _x.obstacles_brake_lights, _x.obstacle_length, _x.obstacle_width, _x.obstacles_velx, _x.obstacleAge, _x.obstacleLane, _x.CIPVFlag, _x.RadarPosX, _x.RadarVelX, _x.RadarMatchConfidence, _x.MatcheRadarID, _x.obstacleAngleRate, _x.obstacles_velY, _x.object_Accel_X, _x.obstacleReplaced, _x.obstacleAngle,) = _get_struct_i2d6i3d3i2d2ididid().unpack(str[start:end])\n self.camera_obj.append(val1)\n _x = self\n start = end\n end += 12\n (_x.camera_lane.header.seq, _x.camera_lane.header.stamp.secs, _x.camera_lane.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.camera_lane.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.camera_lane.header.frame_id = str[start:end]\n _x = self\n start = end\n end += 16\n (_x.camera_lane.messageID, _x.camera_lane.localStamp.header.seq, _x.camera_lane.localStamp.header.stamp.secs, _x.camera_lane.localStamp.header.stamp.nsecs,) = _get_struct_i3I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.camera_lane.localStamp.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.camera_lane.localStamp.header.frame_id = str[start:end]\n _x = self\n start = end\n end += 32\n (_x.camera_lane.localStamp.time, _x.camera_lane.localStamp.lat, _x.camera_lane.localStamp.lng, _x.camera_lane.localStamp.height,) = _get_struct_4d().unpack(str[start:end])\n start = end\n end += 24\n self.camera_lane.localStamp.position = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n self.camera_lane.localStamp.orientation = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n self.camera_lane.localStamp.linearSpeed = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n self.camera_lane.localStamp.angularSpeed = _get_struct_3d().unpack(str[start:end])\n _x = self\n start = end\n end += 12\n (_x.camera_lane.globalStamp.header.seq, _x.camera_lane.globalStamp.header.stamp.secs, _x.camera_lane.globalStamp.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.camera_lane.globalStamp.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.camera_lane.globalStamp.header.frame_id = str[start:end]\n _x = self\n start = end\n end += 32\n (_x.camera_lane.globalStamp.time, _x.camera_lane.globalStamp.lat, _x.camera_lane.globalStamp.lng, _x.camera_lane.globalStamp.height,) = _get_struct_4d().unpack(str[start:end])\n start = end\n end += 24\n self.camera_lane.globalStamp.position = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n self.camera_lane.globalStamp.orientation = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n self.camera_lane.globalStamp.linearSpeed = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 24\n self.camera_lane.globalStamp.angularSpeed = _get_struct_3d().unpack(str[start:end])\n _x = self\n start = end\n end += 404\n (_x.camera_lane.l_numoflaneline, _x.camera_lane.l_lanelineid, _x.camera_lane.l_lanepositon, _x.camera_lane.l_lanecurvature, _x.camera_lane.l_lanecurvaturederivative, _x.camera_lane.l_lane_type, _x.camera_lane.l_heading_angle, _x.camera_lane.l_lane_mark_color, _x.camera_lane.l_laneQuality, _x.camera_lane.l_laneWidthMarking, _x.camera_lane.l_laneViewRangStart, _x.camera_lane.l_laneViewRangEnd, _x.camera_lane.l_laneCrossing, _x.camera_lane.l_lanePRED_DIST_BASED_EXTRAPOLATION, _x.camera_lane.l_lanePRED_OTHER_SIDE, _x.camera_lane.l_lanePRED_OVERRIDE, _x.camera_lane.l_lanePRED_OCCLUDED_LM_EXTRAPOLATION, _x.camera_lane.l_lanePRED_HEADWAY_ORIENTED, _x.camera_lane.l_lanePRED_SOURCE_DIVERGING_LANES, _x.camera_lane.l_lanePRED_SOURCE_GUARDRAIL_SHADOW, _x.camera_lane.l_lanePRED_SOURCE_HWE_SPAIN, _x.camera_lane.l_lanePRED_SOURCE_STD, _x.camera_lane.l_lanePRED_SOURCE_VRTL_MERGE, _x.camera_lane.l_laneTCL, _x.camera_lane.r_numoflaneline, _x.camera_lane.r_lanelineid, _x.camera_lane.r_lanepositon, _x.camera_lane.r_lanecurvature, _x.camera_lane.r_lanecurvaturederivative, _x.camera_lane.r_lane_type, _x.camera_lane.r_heading_angle, _x.camera_lane.r_lane_mark_color, _x.camera_lane.r_laneQuality, _x.camera_lane.r_laneWidthMarking, _x.camera_lane.r_laneViewRangStart, _x.camera_lane.r_laneViewRangEnd, _x.camera_lane.r_laneCrossing, _x.camera_lane.r_lanePRED_DIST_BASED_EXTRAPOLATION, _x.camera_lane.r_lanePRED_OTHER_SIDE, _x.camera_lane.r_lanePRED_OVERRIDE, _x.camera_lane.r_lanePRED_OCCLUDED_LM_EXTRAPOLATION, _x.camera_lane.r_lanePRED_HEADWAY_ORIENTED, _x.camera_lane.r_lanePRED_SOURCE_DIVERGING_LANES, _x.camera_lane.r_lanePRED_SOURCE_GUARDRAIL_SHADOW, _x.camera_lane.r_lanePRED_SOURCE_HWE_SPAIN, _x.camera_lane.r_lanePRED_SOURCE_STD, _x.camera_lane.r_lanePRED_SOURCE_VRTL_MERGE, _x.camera_lane.r_laneTCL, _x.camera_lane.next_l_laneViewRangStart, _x.camera_lane.next_l_laneViewRangEnd, _x.camera_lane.next_l_numoflaneline, _x.camera_lane.next_l_lanelineid, _x.camera_lane.next_l_lanepositon, _x.camera_lane.next_l_lanecurvature, _x.camera_lane.next_l_lanecurvaturederivative, _x.camera_lane.next_l_lane_type, _x.camera_lane.next_l_heading_angle, _x.camera_lane.next_l_lane_mark_color, _x.camera_lane.next_l_laneQuality, _x.camera_lane.next_l_laneWidthMarking, _x.camera_lane.next_r_laneViewRangStart, _x.camera_lane.next_r_laneViewRangEnd, _x.camera_lane.next_r_numoflaneline, _x.camera_lane.next_r_lanelineid, _x.camera_lane.next_r_lanepositon, _x.camera_lane.next_r_lanecurvature, _x.camera_lane.next_r_lanecurvaturederivative, _x.camera_lane.next_r_lane_type, _x.camera_lane.next_r_heading_angle, _x.camera_lane.next_r_lane_mark_color, _x.camera_lane.next_r_laneQuality, _x.camera_lane.next_r_laneWidthMarking, _x.camera_lane.highwayConstructionArea, _x.camera_lane.highwayRoadType, _x.camera_lane.highwayHighwayExitRight, _x.camera_lane.highwayHighwayExitLeft, _x.camera_lane.highwayProbabilityLeftLane, _x.camera_lane.highwayProbabilityRightLane, _x.camera_lane.highwayDriving_peed_left_lane, _x.camera_lane.highwayDriving_peed_right_lane, _x.camera_lane.highwayprotocol_version,) = _get_struct_2i3did19i3did21i3did7i3did7i4di().unpack(str[start:end])\n return self\n except struct.error as e:\n raise genpy.DeserializationError(e) #most likely buffer underfill",
"def sendMeasurement(self, metric, value, source, timestamp=None):\n sys.stdout.write('{0} {1} {2} {3}\\n'.format(metric, value, source, timestamp).decode('utf-8'))\n sys.stdout.flush()",
"def process_meter_message(self, d):\n dpid = int(d.get(\"dpid\", 0))\n dp = self.dpset.get(dpid)\n if not dp:\n return \"Datapath does not exist!\"\n\n ofproto = dp.ofproto\n parser = dp.ofproto_parser\n\n command = {\n 'add': ofproto.OFPMC_ADD,\n 'mod': ofproto.OFPMC_MODIFY,\n 'del': ofproto.OFPMC_DELETE,\n }\n cmd = command.get(d[\"operation\"], ofproto.OFPMC_ADD)\n\n meter_id = d[\"meter_id\"]\n\n flags = 0\n bands = []\n if \"flags\" in d: # Ryu's format\n print(d['flags'])\n for f in d['flags']:\n flags += 0x01 if f == 'KBPS' else 0\n flags += 0x02 if f == 'PKTPS' else 0\n flags += 0x04 if f == 'BURST' else 0\n flags += 0x08 if f == 'STATS' else 0\n\n for band in d[\"bands\"]:\n if band['type'] == 'DROP':\n bands += [parser.OFPMeterBandDrop(rate=band['rate'],\n burst_size=band['burst_size'])]\n elif band['type'] == 'DSCP_REMARK':\n bands += [parser.OFPMeterBandDscpRemark(rate=band['rate'],\n burst_size=band['burst_size'], prec_level=band['prec_level'])]\n\n else: # FlowManager's format\n flags += 0x01 if d['OFPMF_KBPS'] else 0\n flags += 0x02 if d['OFPMF_PKTPS'] else 0\n flags += 0x04 if d['OFPMF_BURST'] else 0\n flags += 0x08 if d['OFPMF_STATS'] else 0\n\n # Flags must have KBPS or PKTPS\n flags = flags if (flags & 0x03) else (flags | 0x01)\n\n for band in d[\"bands\"]:\n #mtype = type_convert.get(band[0])\n if band[0] == 'DROP':\n bands += [parser.OFPMeterBandDrop(rate=band[1],\n burst_size=band[2])]\n elif band[0] == 'DSCP_REMARK':\n bands += [parser.OFPMeterBandDscpRemark(rate=band[1],\n burst_size=band[2], prec_level=band[3])]\n\n # TODO: catch some errors\n meter_mod = parser.OFPMeterMod(dp, cmd, flags, meter_id, bands)\n try:\n dp.send_msg(meter_mod)\n except KeyError as e:\n return e.__repr__()\n except Exception as e:\n return e.__repr__()\n\n return \"Message sent successfully.\"",
"def deserialize(self, str):\n try:\n if self.header is None:\n self.header = std_msgs.msg._Header.Header()\n end = 0\n _x = self\n start = end\n end += 12\n (_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _struct_3I.unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n self.header.frame_id = str[start:end]\n _x = self\n start = end\n end += 51\n (_x.temp_1_curr, _x.temp_1_min, _x.temp_1_max, _x.temp_2_curr, _x.temp_2_min, _x.temp_2_max, _x.temp_3_curr, _x.temp_3_min, _x.temp_3_max, _x.temp_4_curr, _x.temp_4_min, _x.temp_4_max, _x.temp_5_curr, _x.temp_5_min, _x.temp_5_max, _x.temp_6_curr, _x.temp_6_min, _x.temp_6_max, _x.akku_voltage_curr, _x.akku_voltage_min, _x.akku_voltage_max, _x.hals_motor_voltage_curr, _x.hals_motor_voltage_min, _x.hals_motor_voltage_max, _x.hals_logik_voltage_curr, _x.hals_logik_voltage_min, _x.hals_logik_voltage_max, _x.tablett_logik_voltage_curr, _x.tablett_logik_voltage_min, _x.tablett_logik_voltage_max, _x.arm_logik_voltage_curr, _x.arm_logik_voltage_min, _x.arm_logik_voltage_max, _x.tablett_motor_voltage_curr, _x.tablett_motor_voltage_min, _x.tablett_motor_voltage_max, _x.hals_motor_current_curr, _x.hals_motor_current_min, _x.hals_motor_current_max, _x.hals_logik_current_curr, _x.hals_logik_current_min, _x.hals_logik_current_max, _x.tablett_logik_current_curr, _x.tablett_logik_current_min, _x.tablett_logik_current_max, _x.arm_logik_current_curr, _x.arm_logik_current_min, _x.arm_logik_current_max, _x.tablett_motor_current_curr, _x.tablett_motor_current_min, _x.tablett_motor_current_max,) = _struct_51B.unpack(str[start:end])\n return self\n except struct.error, e:\n raise roslib.message.DeserializationError(e) #most likely buffer underfill"
] | [
"0.65161324",
"0.56551564",
"0.5491576",
"0.5452257",
"0.53777915",
"0.5376039",
"0.52958506",
"0.5245437",
"0.5220593",
"0.52068007",
"0.519156",
"0.5148551",
"0.5132906",
"0.5083219",
"0.50504714",
"0.50471866",
"0.50409704",
"0.50309426",
"0.5000225",
"0.49718854",
"0.49680185",
"0.49450237",
"0.4937931",
"0.49343672",
"0.49291366",
"0.49290803",
"0.4927736",
"0.49251917",
"0.49168372",
"0.49113774"
] | 0.6765715 | 0 |
Construct full NxN covariance matrix from flattened upper triangular elements. Useful for reconstructing covariance data from over the wire, esp. from a ROS msg. | def inflate_covariance(covariance_flat):
# compute size of matrix using quadratic formula
cov_size = int(-1 + np.sqrt(1 + 8*len(covariance_flat))) // 2
# get indicies for upper triangular of correct size
upper_idx = np.triu_indices(cov_size)
# create empty matrix for storing values
inflated_covariance = np.empty((cov_size, cov_size))
# fill value in upper triangular, then transpose and fill again
inflated_covariance[upper_idx] = covariance_flat
inflated_covariance.T[upper_idx] = covariance_flat
return inflated_covariance | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def covariance_matrix(self):\n\n self._order_observations()\n self.cov_matrix = self._compute_covariance_matrix(\n self.list_observations, self.list_observations)\n\n self.cov_matrix += np.diag(np.array([self.noise] * self.n_observation))\n\n return self.cov_matrix",
"def covariance_matrix(self):\n\n cov_filename = self.covariance_filename\n cov_press, cov_data = self._co_star_read(cov_filename)\n\n # \"Fix\" covariances that are not positive definite\n if not np.all(np.linalg.eigvals(cov_data) > 0):\n warnings.warn(\"Covariance matrix for species {} is not positive definite, modifying eigenvals\".format(self.species))\n\n # Get eigen values and vector from matrix\n eigval, eigvec = np.linalg.eig(cov_data)\n\n # Find negative eigen values and set to the media\n eigval[np.where(eigval < 0)] = np.median(eigval)\n\n # Reconstruct matrix with modified eigen values\n cov_data = eigvec @ np.diag(eigval) @ np.linalg.inv(eigvec)\n\n return cov_data",
"def _mn_cov_ ( self , size = -1 , root = False ) :\n #\n if size <= 0 : size = len ( self )\n size = min ( size , len ( self ) ) \n #\n from array import array\n matrix = array ( 'd' , [ 0 for i in range(0, size * size) ] )\n self.mnemat ( matrix , size )\n #\n import ostap.math.linalg\n from ostap.core.core import Ostap \n mtrx = Ostap.Math.SymMatrix ( size )() \n for i in range ( 0 , size ) :\n for j in range ( i , size ) : \n mtrx [ i , j ] = matrix [ i * size + j ]\n \n return mtrx",
"def correlation_matrix(self):\n correlation_matrix = self.model.covariance.copy()\n sigmaD = np.sqrt(np.diag(correlation_matrix))\n for ii in range(correlation_matrix.shape[0]):\n for jj in range(correlation_matrix.shape[1]):\n correlation_matrix[ii, jj] /= sigmaD[ii] * sigmaD[jj]\n return correlation_matrix",
"def getCovarianceNoiseMatrix(self):\n return np.dot ( self.getB().T, self.getB() )",
"def mkCoalMatrix(C, npop):\n C = np.array(C).flatten()\n M = np.zeros((npop, npop))\n cnt = 0\n for i in range(npop):\n for j in range(i, npop):\n M[i, j] = C[cnt]\n if i != j:\n M[j, i] = M[i, j]\n cnt += 1\n\n return M",
"def covariance(data_matrix):\n return np.asmatrix(np.cov(data_matrix, rowvar=0))",
"def create_covariance_matrix(cls, coordinates):\n number_of_conformations = coordinates.shape[0]\n number_of_atoms = coordinates.shape[1]\n coordinates_per_conformation = number_of_atoms * 3\n covariance_matrix = numpy.zeros((coordinates_per_conformation, coordinates_per_conformation))\n coordinates = coordinates.reshape((number_of_conformations, coordinates_per_conformation))\n # Mean structure\n mean = coordinates.mean(0)\n # Changed for efficiency\n for coords in coordinates:\n deviations = coords - mean\n covariance_matrix += numpy.outer(deviations, deviations)\n return covariance_matrix / number_of_conformations",
"def get_cov_matrix_states(self):\n cov = numpy.diag(numpy.zeros(self.get_num_variables()))\n i = 0\n for v in self.variables:\n cov[i,i] = v.get_covariance()\n i += 1\n return cov",
"def build_cov_dataset(self):\n return self.ini_eeg_f[:, :, self.mask_tri].copy()",
"def calcCovarianceMatrix(data):\n # Create covariance matrix and array to store the mean values for x_mean, y_mean, z_mean\n C = np.zeros((data.shape[1], data.shape[1]))\n mean_xyz = []\n # Calculate all mean values\n for i in range(0, data.shape[1]):\n mean_xyz.append(data[:,i].mean())\n mean_xyz = np.array(mean_xyz)\n # Check whether dimensions agree \n if data[:,0].size != data[:,1].size or data[:,0].size != data[:,2].size:\n print \"X, Y and Z must be of same dimensions.\"\n else:\n # For each row in covariance matrix C\n for i in range(0, C.shape[0]):\n # For each column in covariance matrix C\n for j in range(0, C.shape[1]):\n C[i,j] = 0\n # For each point in the dataset, access x, y, z-values\n for point in data:\n # For each point, access x,y and z in all combinations (xx, xy, xz, yx, yy, yz etc)\n C[i][j] = C[i][j] + (point[i]-mean_xyz[i])*(point[j]-mean_xyz[j])\n # Divide by the total number of points \n C = (1.0/data.shape[0]) * C\n return C",
"def compute_covariance_matrix1d(Xs):\n m, d = Xs.shape\n t1 = np.reshape(np.tile(Xs, m), (m, m, d))\n t2 = np.reshape(np.tile(Xs, (m, 1)), (m, m, d))\n K1 = np.abs(t1 - t2)\n K1 = np.reshape(K1, (m, m))\n coeff = 1.0\n Sigma = np.ones((m, m)) - coeff*K1\n return Sigma",
"def FormCovarianceMatrix(mat):\n nPts = mat.shape[0]\n sumVect = sum(mat)\n sumVect /= float(nPts)\n for row in mat:\n row -= sumVect\n return numpy.dot(numpy.transpose(mat), mat) / (nPts - 1)",
"def compute_covariance_matrix(Xs, sigma_2):\n m, d = Xs.shape\n t1 = np.reshape(np.tile(Xs, m), (m, m, d))\n t2 = np.reshape(np.tile(Xs, (m, 1)), (m, m, d))\n K1 = np.linalg.norm(t1 - t2, axis=2)\n coeff = 0.1\n Sigma = np.ones((m, m)) - coeff*K1\n return Sigma",
"def make_covariance_matrix(points, kernel):\n\n dim = len(points)\n p1 = np.reshape(points, (dim, 1, -1))\n p2 = np.reshape(points, (dim, -1, 1))\n\n return kernel(p1, p2)",
"def FormCovarianceMatrix(mat):\n nPts = mat.shape[0]\n sumVect = sum(mat)\n sumVect /= float(nPts)\n for row in mat:\n row -= sumVect\n return numpy.dot(numpy.transpose(mat),mat)/(nPts-1)",
"def to_coo_matrix(self):\n if self.E > 0:\n i, j = self.edges.T\n sm = coo_matrix((self.weights, (i, j)), shape=(self.V, self.V))\n else:\n sm = coo_matrix((self.V, self.V))\n return sm",
"def cov_matrix(X, mu):\n m, n = X.shape\n X_minus_mu = X - mu\n sigma = (1 / m) * (X_minus_mu.T).dot(X_minus_mu)\n\n return sigma",
"def to_coo_matrix(self):\n if self.E > 0:\n i, j = self.edges.T\n sm = coo_matrix((np.ones(self.E), (i, j)),\n shape=(self.V, self.V))\n else:\n sm = coo_matrix((self.V, self.V))\n return sm",
"def _gp_cov_matrix(Nt, snr2, clen2):\n f = lambda x: np.exp(-(x**2)/clen2)\n C = snr2 * f(np.arange(Nt))\n C[0] += 1 # noise\n return scipy.linalg.toeplitz(C)",
"def getCovMatrix(self, caliStep, weights):\n\n Sigma = np.zeros([self.numObs, self.numObs])\n # scale observation data with normalized variance parameter to get covariance matrix\n for i in range(self.numObs):\n # use smaller weights for higher precision\n if self.scaleCovWithMax:\n Sigma[i, i] = self.sigma * weights[i] * max(self.obsData[:, i]) ** 2\n else:\n Sigma[i, i] = self.sigma * weights[i] * self.obsData[caliStep, i] ** 2\n return Sigma",
"def reduce_size(data):\r\n data_ = pd.DataFrame(data)\r\n nonzero_idxs = np.flatnonzero(np.diag(data_))\r\n cov_reduced = data_.iloc[nonzero_idxs, nonzero_idxs]\r\n return nonzero_idxs, cov_reduced",
"def get_covariance(data_array):\n number_of_data = len(data_array)\n number_of_features = len(data_array[0]) if number_of_data != 0 else 0\n covariance_matrix = numpy.zeros([number_of_features, number_of_features])\n mean = numpy.zeros(number_of_features)\n for data in data_array:\n numpy.add(mean, data, mean)\n numpy.divide(mean, number_of_data, mean)\n for i in xrange(number_of_features):\n temp = numpy.zeros(number_of_data)\n for j in xrange(number_of_data):\n temp[j] = data_array[j][i] - mean[i]\n covariance_matrix[i][i] = max(numpy.dot(temp, temp.transpose()), 0.00001) / number_of_data\n return covariance_matrix, mean",
"def get_cov_matrix_state_pars(self):\n cov = numpy.diag(numpy.zeros(self.get_num_variables() + self.get_num_parameters()))\n i = 0\n for v in self.variables:\n cov[i,i] = v.get_covariance()\n i += 1\n for p in self.parameters:\n cov[i,i] = p.get_covariance()\n i += 1\n return cov",
"def build_inverse_covariance(self):\n return np.linalg.inv(self.cov)",
"def _dgp_cov_matrix(Nt, snr2=100, clen2=1):\n f = lambda x: np.exp(-(x**2)/clen2)\n C = snr2 * (2*f(np.arange(Nt)) - f(1+np.arange(Nt))- f(-1+np.arange(Nt)))\n C[0] += 2 + 0.01 # noise, add a small number to regularize\n C[1] += -1\n return scipy.linalg.toeplitz(C)",
"def get_cov_matrix_parameters(self):\n cov = numpy.diag(numpy.zeros(self.get_num_parameters()))\n i = 0\n for p in self.parameters:\n cov[i,i] = p.get_covariance()\n i += 1\n return cov",
"def cov(self, decomposed=False):\n if decomposed:\n return self._R, self._S\n else:\n return np.copy(self._C)",
"def mpi_cov(data):\n m = mpi_mean(data)\n data_centered = data - m\n cov_local = dot(data_centered.T, data_centered)\n covmat = np.empty_like(cov_local)\n mpi.COMM.Allreduce(cov_local, covmat)\n num_data = mpi.COMM.allreduce(data.shape[0])\n covmat /= float(num_data)\n return covmat",
"def build_covariance(self):\n raise RuntimeError(\"Your Gaussian covariance code needs to \"\n \"over-ride the build_covariance method so it knows how to \"\n \"load the data covariance (or set constant_covariance=False and \"\n \"over-ride the extract_covariance method)\")\n\n #using info in self.options,\n #like filenames etc,\n #build covariance"
] | [
"0.6434829",
"0.6285288",
"0.6159606",
"0.5981059",
"0.5952412",
"0.59400165",
"0.59368193",
"0.58926064",
"0.58616",
"0.58181053",
"0.5727994",
"0.5682243",
"0.56566226",
"0.56417537",
"0.5630792",
"0.5630418",
"0.55739963",
"0.5561916",
"0.55400753",
"0.5511477",
"0.5502872",
"0.5491273",
"0.548631",
"0.5477977",
"0.544267",
"0.5430653",
"0.53448784",
"0.53360385",
"0.5330529",
"0.5324333"
] | 0.66463983 | 0 |
Create flattened upper triangular representation of covariance. Useful for sending covariance data over the wire, esp. in a ROS msg. | def deflate_covariance(covariance):
# create list of indices to grad upper triangular
upper_tri_idx = np.triu_indices(covariance.shape[0])
# grab upper triangular elements from covariance using indices
upper_tri_cov = covariance[upper_tri_idx]
# convert array to list
deflated_covariance = upper_tri_cov.tolist()
return deflated_covariance | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inflate_covariance(covariance_flat):\n # compute size of matrix using quadratic formula\n cov_size = int(-1 + np.sqrt(1 + 8*len(covariance_flat))) // 2\n \n # get indicies for upper triangular of correct size\n upper_idx = np.triu_indices(cov_size)\n \n # create empty matrix for storing values\n inflated_covariance = np.empty((cov_size, cov_size))\n \n # fill value in upper triangular, then transpose and fill again\n inflated_covariance[upper_idx] = covariance_flat\n inflated_covariance.T[upper_idx] = covariance_flat\n \n return inflated_covariance",
"def build_inverse_covariance(self):\n return np.linalg.inv(self.cov)",
"def _project_to_correlation(self, covariance):\n D = np.diagonal(covariance)\n D_neg_half = 1.0/np.sqrt(D)\n covariance *= D_neg_half\n return covariance.T * D_neg_half",
"def getCovarianceNoiseMatrix(self):\n return np.dot ( self.getB().T, self.getB() )",
"def covariance(self):\n return self._covariance",
"def build_covariance(self):\n raise RuntimeError(\"Your Gaussian covariance code needs to \"\n \"over-ride the build_covariance method so it knows how to \"\n \"load the data covariance (or set constant_covariance=False and \"\n \"over-ride the extract_covariance method)\")\n\n #using info in self.options,\n #like filenames etc,\n #build covariance",
"def get_covariance(self):\n ...",
"def cov(self, decomposed=False):\n if decomposed:\n return self._R, self._S\n else:\n return np.copy(self._C)",
"def build_covariance(self):\n raise RuntimeError(\"Internal cosmosis error in SingleValueGaussianLikelihood\")",
"def diagflat(v, k=0):\n if isinstance(v, cupy.ndarray):\n return cupy.diag(v.ravel(), k)\n else:\n return cupy.diag(numpy.ndarray(v).ravel(), k)",
"def build_cov_dataset(self):\n return self.ini_eeg_f[:, :, self.mask_tri].copy()",
"def covariance(data_matrix):\n return np.asmatrix(np.cov(data_matrix, rowvar=0))",
"def covariance_matrix(self):\n\n self._order_observations()\n self.cov_matrix = self._compute_covariance_matrix(\n self.list_observations, self.list_observations)\n\n self.cov_matrix += np.diag(np.array([self.noise] * self.n_observation))\n\n return self.cov_matrix",
"def FormCovarianceMatrix(mat):\n nPts = mat.shape[0]\n sumVect = sum(mat)\n sumVect /= float(nPts)\n for row in mat:\n row -= sumVect\n return numpy.dot(numpy.transpose(mat), mat) / (nPts - 1)",
"def FormCovarianceMatrix(mat):\n nPts = mat.shape[0]\n sumVect = sum(mat)\n sumVect /= float(nPts)\n for row in mat:\n row -= sumVect\n return numpy.dot(numpy.transpose(mat),mat)/(nPts-1)",
"def triu_matrix(matrix, kind='upper'):\r\n matrix_ = pd.DataFrame(matrix)\r\n index = matrix_.index\r\n columns = matrix_.columns\r\n values = matrix_.values\r\n if kind == 'upper': \r\n index_lower = np.tril_indices(matrix_.shape[0], -1)\r\n values[index_lower] = values.T[index_lower]\r\n elif kind == 'lower':\r\n index_upper = np.triu_indices(matrix_.shape[0], 1)\r\n values[index_upper] = values.T[index_upper]\r\n return CategoryCov(pd.DataFrame(values, index=index, columns=columns))",
"def corr2cov(corr, s):\r\n s_ = np.diag(s)\r\n return s_.dot(corr.dot(s_))",
"def get_cov_matrix_states(self):\n cov = numpy.diag(numpy.zeros(self.get_num_variables()))\n i = 0\n for v in self.variables:\n cov[i,i] = v.get_covariance()\n i += 1\n return cov",
"def correlation_matrix(self):\n correlation_matrix = self.model.covariance.copy()\n sigmaD = np.sqrt(np.diag(correlation_matrix))\n for ii in range(correlation_matrix.shape[0]):\n for jj in range(correlation_matrix.shape[1]):\n correlation_matrix[ii, jj] /= sigmaD[ii] * sigmaD[jj]\n return correlation_matrix",
"def covariance(G, variables = [], conditionants = []):\n return parameters(G, variables = variables, \n conditionants = conditionants )[\"cov\"]",
"def get_thermal_covariance(self):\n cov = []\n for var in self.noise_power_variance:\n cov.append(np.diag(var * np.ones(len(self.eta))))\n\n return cov",
"def print_covariance(P):\n def b(string):\n \"\"\"\n Turns a given string blue.\n\n \"\"\"\n return \"\\033[94m{0}\\033[0m\".format(string)\n\n out = \" \"\n # Print out header with state variables\n for var in STATE_VARS:\n out += \"{0:9s} \".format(var)\n\n # Print out correlation / covariance matrix \n for row in range(18):\n out += \"\\n{0:3s} \".format(STATE_VARS[row])\n for col in range(18):\n # Print correlations on lower diagnal\n if col < row:\n out += \"{0: 2.2f}, \".format(float(P[row,col]/(sqrt(P[row,row]) * sqrt(P[col,col]) )))\n # Highlight variances in blue\n elif row == col:\n out += \"{0: 2.2e}, \".format(float(P[row,col]))\n else:\n out += \"{0: 2.2e}, \".format(float(P[row,col]))\n \n out += \"\\n\"\n\n print out",
"def covariance_type(self):\n return self._covariance_type",
"def diagflat(v, k=0):\n\n if not use_origin_backend(v):\n if not isinstance(v, dparray):\n pass\n else:\n return dpnp_diag(v.ravel(), k)\n\n return call_origin(numpy.diagflat, v, k)",
"def cov(self):\n cov_ = np.dot(self.weights * self.demeaned.T, self.demeaned)\n cov_ /= self.sum_weights - self.ddof\n return cov_",
"def getCovarianceMatrix(self):\n #ypost = np.dot ( self.getA().T, self.priorX )\n\n theta = np.mat ( self.getA() )\n Xm = np.mat ( self.priorX )\n\n ypost = Xm * theta\n yprior = self.priorY\n error = ypost - yprior\n #error = error - np.mean ( error, axis = 0 )\n return np.dot ( error.T, error )",
"def covariance_matrix(self):\n\n cov_filename = self.covariance_filename\n cov_press, cov_data = self._co_star_read(cov_filename)\n\n # \"Fix\" covariances that are not positive definite\n if not np.all(np.linalg.eigvals(cov_data) > 0):\n warnings.warn(\"Covariance matrix for species {} is not positive definite, modifying eigenvals\".format(self.species))\n\n # Get eigen values and vector from matrix\n eigval, eigvec = np.linalg.eig(cov_data)\n\n # Find negative eigen values and set to the media\n eigval[np.where(eigval < 0)] = np.median(eigval)\n\n # Reconstruct matrix with modified eigen values\n cov_data = eigvec @ np.diag(eigval) @ np.linalg.inv(eigvec)\n\n return cov_data",
"def Controlled(U):\n shp = U.shape\n new_ten = scipy.linalg.block_diag(np.eye(*shp), U)\n return new_ten.reshape(2, shp[0], 2, shp[1])",
"def calculate_covariance(self, x):\n # tx = self.reshape_tensor2d(x)\n # Calcualte the covariance\n # tx_mean = K.mean(tx, axis=0)\n # return tx_mean\n # tx_normal = tx - tx_mean\n # return tx_normal\n # tx_cov = K.dot(tx_normal.T, tx_normal) / (self.cols * self.rows - 1)\n # return tx_cov\n raise DeprecationWarning(\"deprecated, should use calculate_pre_cov to do 4D direct computation\")",
"def covariance(self,pt0,pt1):\n #raise Exception()\n cov = self.nugget\n for vario in self.variograms:\n cov += vario.covariance(pt0,pt1)\n return cov"
] | [
"0.66811705",
"0.6215715",
"0.58638555",
"0.5755085",
"0.5676975",
"0.55790585",
"0.5507209",
"0.55070263",
"0.5482315",
"0.54728806",
"0.5394122",
"0.53237647",
"0.5302575",
"0.52929914",
"0.52915114",
"0.52850443",
"0.5271727",
"0.52562267",
"0.52272123",
"0.5197573",
"0.5196312",
"0.5177512",
"0.51702464",
"0.51345277",
"0.51322377",
"0.512905",
"0.51269954",
"0.51142883",
"0.5105614",
"0.5101815"
] | 0.62268245 | 1 |
The download directory to which the AudioFile will download itself in. | def download_dir(self) -> str:
return self._download_dir | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_download_dir(self):\n return self.manager.download_dir",
"def _get_download_dir(self):\n return self.data['info']['root_downloads_dir']",
"def get_downloads_dir():\n return _DOWNLOADS_DIR",
"def download_path(self) -> str:\n return self._download_path",
"def _get_default_downloads_dir(self):\n default_downloads_dir = os.path.join(self._get_default_cache_dir(), 'downloads')\n return default_downloads_dir",
"def get_directory(self, subdir=None):\n path = settings.SUBMISSION_DIR / str(self.assignment.id) / str(self.id)\n if subdir:\n path = path / subdir\n\n return path",
"def data_directory(self):\n\n return self.get_raw(\"data_directory\")",
"def get_directory(self):\n return self.directory",
"def reset_download_dir(self):\n self._set_download_dir(self._get_default_downloads_dir())",
"def download_folder(self) -> Path:\n path = (\n config.storage_vol\n / f\"{self.device_type}/{self.patient_id}/{self.device_id}\"\n )\n path.mkdir(parents=True, exist_ok=True)\n return path",
"def directory(self) -> str:\n return self._values.get(\"directory\")",
"def get_directory() -> str:\n return directory",
"def get_download_path(self):\n if os.name == 'nt':\n import winreg\n sub_key = r'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders'\n downloads_guid = '{374DE290-123F-4565-9164-39C4925E467B}'\n with winreg.OpenKey(winreg.HKEY_CURRENT_USER, sub_key) as key:\n location = winreg.QueryValueEx(key, downloads_guid)[0]\n return location\n else:\n return os.path.join(os.path.expanduser('~'), 'downloads')",
"def get_download_path(self):\n if os.name == 'nt':\n import winreg\n sub_key = r'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders'\n downloads_guid = '{374DE290-123F-4565-9164-39C4925E467B}'\n with winreg.OpenKey(winreg.HKEY_CURRENT_USER, sub_key) as key:\n location = winreg.QueryValueEx(key, downloads_guid)[0]\n return location\n else:\n return os.path.join(os.path.expanduser('~'), 'downloads')",
"def upload_dir(self):\n return os.path.join(settings.MEDIA_ROOT,self.upload_dir_rel())",
"def data_dir(self) -> Path:\n return self._data_dir",
"def get_media_directory():\n\treturn _paths[_MEDIA_DIRECTORY_KEY]",
"def getFileDir(self):\n return os.path.dirname(self.filePath)",
"def get_default_download_dir(self, *subdirs):\r\n # Look up value for key \"path\" in the config\r\n path = self.get_config_value(self.CONFIG_NAME_PATH)\r\n\r\n # If not set in config, default to present working directory\r\n if path is None:\r\n return os.getcwd()\r\n\r\n return os.path.join(path, *subdirs)",
"def get_dir(self):\n return self.dir",
"def get_file_dir():\n filedir = os.path.join(xbmc.translatePath('special://temp/'), config.ADDON_ID)\n if not os.path.isdir(filedir):\n os.mkdir(filedir)\n return filedir",
"def GetPath(self):\r\n\r\n return self.directory",
"def dataset_dir(self):\n return self._dataset_dir",
"def getDir( self ):\n return self.dir",
"def dirname(self):\n _, tail = os.path.split(self.url)\n return self.folder + '/' + tail[:-4]",
"def output_directory(self):\n if self._output_directory is None:\n cache_filename = self._original_cache\n output_directory = settings.cache_folder / cache_filename\n output_directory.makedirs_p()\n self._output_directory = output_directory.expand()\n return Path(self._output_directory)",
"def save_dir(self):\n return self._save_dir",
"def _set_download_dir(self, path):\n assert path, 'Must input a non-empty path.'\n self.manager.download_dir = path",
"def get_download_url(self):\n\n\t\treturn self.__download_url",
"def get_folder(self):\n return os.path.join(\n settings.PRIVATE_STORAGE_ROOT, Exam.EXAM_FILES_LOCATION,\n str(self.unique_id)[0:2])"
] | [
"0.7995271",
"0.789752",
"0.7642793",
"0.72250736",
"0.71863115",
"0.6792735",
"0.6771639",
"0.6700152",
"0.6672671",
"0.666244",
"0.66117615",
"0.6591039",
"0.6510777",
"0.6510777",
"0.64992404",
"0.64594144",
"0.6452896",
"0.64474493",
"0.642287",
"0.64071625",
"0.64017254",
"0.6376559",
"0.63759327",
"0.6373974",
"0.63546205",
"0.63527167",
"0.63386714",
"0.63362384",
"0.6323744",
"0.6321777"
] | 0.828115 | 0 |
The filename of the AudioFile that it will download itself to. If the filename is not explicitly set, the filename of the file on the server reachable via the self.download_url is used. | def download_filename(self) -> str:
return self._download_filename | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_filename(self) -> str:\n return self._filename",
"def filename(self):\n if self.__filename__ is None:\n return _filename\n else:\n return self.__filename__",
"def get_filename(self):\n return self.filename",
"def get_filename(self):\n return self._filename",
"def GetFilename(self):\n return self._filename",
"def get_filename(self):\n\n return self._filename",
"def filename(self):\n return self._filename",
"def filename(self):\n return self._filename",
"def filename(self):\n return self._filename",
"def filename(self):\n return self._filename",
"def filenameAsURL(self):\n return \"/recordings/\" + self.filename + \".mp3\"",
"def get_filename(self):\n return self.__filename",
"def filename(self):\n return self.__filename",
"def getFileName(self):\n return self.filename",
"def filename(self):\n return self.config.get('filename', self.id) + f'_{self.file_suffix}'",
"def filename(self):\r\n return self._filename",
"def filename(self):\n return '%s%s' % (self.identifier, self.extension)",
"def filename(self):\n # TODO(aron): write tests for this\n\n return os.path.basename(self.file_on_disk.name)",
"def get_file_name(self):\n return self._fileName",
"def get_filename(self):\n return self.ds_filename",
"def name(self):\n return self._filename",
"def getFileName(self):\n return self.__fileName",
"def filename(self) -> str:\n return self.__location.filename",
"def filename(self):\n if self.is_persistent is True:\n return self.backend.filename\n\n return None",
"def get_file_name(self):\n return self.file_name",
"def getPlayerFilename(self):\n if (self.__playerName != \"???\"):\n return self.__filename\n else:\n return \"\"",
"def get_file_name(self):\n return str(self.get_file())",
"def get_file_name(self):\n return self.__file_name",
"def get_filename(self) -> str:\n fname = self.url.split(\"/\")[-1]\n if \",\" in fname:\n _fname, _i = fname.split(\",\")\n _split_fname = _fname.split(\".\")\n _name = _split_fname[0]\n _extension = _split_fname[-1]\n return _name + _i + \".\" + _extension\n else:\n return fname",
"def file_name(self):\n return self._file_name"
] | [
"0.77044064",
"0.769287",
"0.7569284",
"0.7548853",
"0.753745",
"0.7530441",
"0.75082684",
"0.75082684",
"0.75082684",
"0.75082684",
"0.74327564",
"0.7406752",
"0.7403629",
"0.7372957",
"0.73017526",
"0.72556186",
"0.7154353",
"0.7153562",
"0.71477526",
"0.71476734",
"0.71263885",
"0.71025896",
"0.7022565",
"0.70189166",
"0.70158887",
"0.70021427",
"0.6984189",
"0.6962764",
"0.69466937",
"0.69370234"
] | 0.810495 | 0 |
Full download path that reflects the combination of download_dir and download_filename. | def download_path(self) -> str:
return self._download_path | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_dir(self) -> str:\n return self._download_dir",
"def _get_download_dir(self):\n return self.manager.download_dir",
"def _update_full_path(self):\n if self.download_dir and self.download_filename:\n self._download_path = os.path.join(self.download_dir,\n self.download_filename)\n else:\n self._download_path = None",
"def url(self) -> str:\n if self._download_path is None:\n raise ValueError(\"No download URL given.\")\n return urljoin(self._download_path, self.filename)",
"def _get_download_dir(self):\n return self.data['info']['root_downloads_dir']",
"def get_path(download_name, filename='', test_exists=True):\n assert '/' not in download_name, \"Invalid download: %s\" % download_name\n path = join(get_downloads_dir(), download_name, filename)\n if test_exists and not exists(path):\n raise RuntimeError(\n \"Missing MHC2flurry downloadable file: %s. \"\n \"To download this data, run:\\n\\tmhc2flurry-downloads fetch %s\\n\"\n \"in a shell.\"\n % (quote(path), download_name))\n return path",
"def download_filename(self) -> str:\n return self._download_filename",
"def get_downloadPath(self, relpath=False):\n \n if 'downloadPaths' not in self.metadata.keys(): return None\n \n paths = self.metadata['downloadPaths']\n path_str = json.dumps(paths)\n path_json = json.loads(path_str)\n \n download_path = path_json[0]['local_destination']\n \n if relpath:\n return os.path.relpath(download_path)\n else:\n return download_path",
"def get_download_path(self, version=\"latest\"):\n raise NotImplementedError",
"def get_download_url(self):\n\n\t\treturn self.__download_url",
"def get_downloads_dir():\n return _DOWNLOADS_DIR",
"def generate_download_url(self):\n access_key = getattr(settings, 'AWS_ACCESS_KEY_ID')\n secret_key = getattr(settings, 'AWS_SECRET_ACCESS_KEY')\n bucket = getattr(settings, 'AWS_STORAGE_BUCKET_NAME')\n region = getattr(settings, 'S3DIRECT_REGION')\n if not bucket or not region or not access_key or not secret_key:\n return '/product-not-found/' # TODO: raise custom 404 error\n\n PROTECTED_DIR_NAME = getattr(settings, 'PROTECTED_DIR_NAME', 'protected')\n # for aws, self.file is equivalent to self.file.path in local\n path = '{base}/{file_path}'.format(base=PROTECTED_DIR_NAME, file_path=str(self.file))\n\n aws_dl_object = AWSDownload(access_key, secret_key, bucket, region)\n file_url = aws_dl_object.generate_url(path, new_filename=self.display_name)\n return file_url",
"def download_url(self, fname):\n if not fname in self.data:\n return ''\n url = '/'.join([\n self.context.absolute_url(),\n '@@download-file',\n self.id + ':' + fname\n ])\n return url",
"def download_url(self) -> str:\n return self._download_url",
"def get_download_path(self):\n if os.name == 'nt':\n import winreg\n sub_key = r'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders'\n downloads_guid = '{374DE290-123F-4565-9164-39C4925E467B}'\n with winreg.OpenKey(winreg.HKEY_CURRENT_USER, sub_key) as key:\n location = winreg.QueryValueEx(key, downloads_guid)[0]\n return location\n else:\n return os.path.join(os.path.expanduser('~'), 'downloads')",
"def get_download_path(self):\n if os.name == 'nt':\n import winreg\n sub_key = r'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders'\n downloads_guid = '{374DE290-123F-4565-9164-39C4925E467B}'\n with winreg.OpenKey(winreg.HKEY_CURRENT_USER, sub_key) as key:\n location = winreg.QueryValueEx(key, downloads_guid)[0]\n return location\n else:\n return os.path.join(os.path.expanduser('~'), 'downloads')",
"def get_download_url():\n return _DOWNLOAD",
"def download_url(self):\n return self._download_url",
"def get_download_path():\n if sys.platform == 'darwin':\n # Mac OS X\n return os.path.join(os.path.expanduser('~'), 'downloads')\n elif sys.platform == 'linux':\n home = os.path.expanduser(\"~\")\n return os.path.join(home, \"Downloads\")\n elif sys.platform in ('win32', 'cygwin') and os.name == 'nt':\n import winreg\n sub_key = r'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders'\n downloads_guid = '{374DE290-123F-4565-9164-39C4925E467B}'\n with winreg.OpenKey(winreg.HKEY_CURRENT_USER, sub_key) as key:\n location = winreg.QueryValueEx(key, downloads_guid)[0]\n return location\n else:\n log.warning(f\"unknown OS {sys.platform}\")\n # return current directory\n return os.getcwd()",
"def download_path(self, uri: str) -> Optional[str]:\n # check if URI is properly formatted & normalize\n parts = urlparse(uri)\n if (\n parts.scheme\n and parts.netloc\n and (\n self._cfg[\"download_cache\"].get_bool(\"ignore_query\")\n or not (parts.params or parts.query or parts.fragment)\n )\n ):\n uri = urlunparse((parts.scheme, parts.netloc, parts.path, \"\", \"\", \"\"))\n # check enable/disable patterns\n enable = self._cfg[\"download_cache\"].get_list(\"enable_patterns\") or [\"*\"]\n disable = self._cfg[\"download_cache\"].get_list(\"disable_patterns\")\n if next((pat for pat in enable if fnmatchcase(uri, pat)), False) and not next(\n (pat for pat in disable if fnmatchcase(uri, pat)), False\n ):\n (dn, fn) = os.path.split(parts.path)\n if fn:\n # formulate path\n dn = dn.strip(\"/\")\n if dn:\n dn = dn.replace(\"_\", \"__\")\n dn = dn.replace(\"/\", \"_\")\n return os.path.join(\n self._cfg[\"download_cache\"][\"dir\"],\n \"files\",\n parts.scheme,\n parts.netloc,\n dn,\n fn,\n )\n return None",
"def get_download_path():\n if os.name == \"nt\":\n import winreg\n sub_key = r\"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders\"\n downloads_guid = \"{374DE290-123F-4565-9164-39C4925E467B}\"\n with winreg.OpenKey(winreg.HKEY_CURRENT_USER, sub_key) as key:\n location = winreg.QueryValueEx(key, downloads_guid)[0]\n return location\n else:\n return os.path.join(os.path.expanduser(\"~\"), \"downloads\")",
"def get_download_path():\n if os.name == 'nt':\n import winreg\n sub_key = r'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders'\n downloads_guid = '{374DE290-123F-4565-9164-39C4925E467B}'\n with winreg.OpenKey(winreg.HKEY_CURRENT_USER, sub_key) as key:\n location = winreg.QueryValueEx(key, downloads_guid)[0]\n return location\n else:\n return os.path.join(os.path.expanduser('~'), 'downloads')",
"def get_download_path():\n if os.name == 'nt':\n import winreg\n sub_key = r'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders'\n downloads_guid = '{374DE290-123F-4565-9164-39C4925E467B}'\n with winreg.OpenKey(winreg.HKEY_CURRENT_USER, sub_key) as key:\n location = winreg.QueryValueEx(key, downloads_guid)[0]\n return location\n else:\n return os.path.join(os.path.expanduser('~'), 'downloads')",
"def get_download_url(self):\n # return self.file.url # This returns the path where file is stored\n return reverse('products:download', kwargs={\n 'slug': self.product.slug, 'pk': self.pk\n }) # This returns the endpoint where file download is handled",
"def get_download_path():\r\n if os.name == 'nt':\r\n import winreg\r\n sub_key = r'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders'\r\n downloads_guid = '{374DE290-123F-4565-9164-39C4925E467B}'\r\n with winreg.OpenKey(winreg.HKEY_CURRENT_USER, sub_key) as key:\r\n location = winreg.QueryValueEx(key, downloads_guid)[0]\r\n return location\r\n else:\r\n return os.path.join(os.path.expanduser('~'), 'downloads')",
"def download_release(self):\n cache = tempfile.mkdtemp('download-cache')\n download = Download(cache=cache)\n download_path, is_temp = download(self.download_url)\n return download_path",
"def get_download_filename(url, target):\n if url and os.path.isdir(target):\n target += '/' + url.split('/')[-1]\n return target\n return None",
"def get_download_path():\r\n if os.name == 'nt':\r\n import winreg\r\n sub_key = r'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders'\r\n downloads_guid = '{374DE290-123F-4565-9164-39C4925E467B}'\r\n with winreg.OpenKey(winreg.HKEY_CURRENT_USER, sub_key) as key:\r\n location = winreg.QueryValueEx(key, downloads_guid)[0]\r\n return location\r\n else:\r\n return str(os.path.join(Path.home(), \"Downloads\"))",
"def get_abs_path(self, file_name=None):\n home_path = os.path.expanduser(\"~\")\n save_path = \"/Gmail-Image-Extractor/download/\"\n abs_path = home_path + save_path\n\n if file_name:\n abs_path = abs_path + file_name + \".zip\"\n\n return abs_path",
"def localpath_download(self, *path, **kwargs):\n pathname = self.localpath(*path)\n if not os.path.exists(pathname):\n self.download.unwrapped(self, *path, **kwargs)\n return pathname"
] | [
"0.7932821",
"0.7560432",
"0.75391185",
"0.752196",
"0.7506158",
"0.7304482",
"0.7237244",
"0.7214143",
"0.7159807",
"0.7148829",
"0.714174",
"0.710438",
"0.7071977",
"0.7062645",
"0.7057241",
"0.7057241",
"0.70008653",
"0.69792736",
"0.69383055",
"0.6750141",
"0.6743837",
"0.6743757",
"0.6743757",
"0.6740721",
"0.66999954",
"0.6677072",
"0.6662667",
"0.65674305",
"0.6562667",
"0.6548085"
] | 0.822728 | 0 |
Get a human readable representation of the size in bytes. | def size_str(self) -> str:
return fmt_size_bytes(self._size) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def my_size(self):\n return u\"{} bytes\".format(self.size)",
"def size(self):\n\n return str(self.size)",
"def humanbytes(size):\n # https://stackoverflow.com/a/49361727/4723940\n if not size:\n return \"\"\n # 2 ** 10 = 1024\n power = 2**10\n raised_to_pow = 0\n dict_power_n = {0: \"\", 1: \"Ki\", 2: \"Mi\", 3: \"Gi\", 4: \"Ti\"}\n while size > power:\n size /= power\n raised_to_pow += 1\n return str(round(size, 2)) + \" \" + dict_power_n[raised_to_pow] + \"B\"",
"def get_printable_size(self):\n size = self.size\n prefix = ''\n for (s, l) in [(1024*1024*1024, 'GB'), (1024*1024, 'MB'), (1024, 'KB')]:\n if (size>s):\n size = float(size)/s\n prefix = l\n\n return '%10.2f %s' % (size, prefix)",
"def get_size(obj):\n size_bytes = sys.getsizeof(obj)\n if size_bytes == 0:\n return \"0B\"\n size_name = (\"B\", \"KB\", \"MB\", \"GB\", \"TB\", \"PB\", \"EB\", \"ZB\", \"YB\")\n i = int(math.floor(math.log(size_bytes, 1024)))\n p = math.pow(1024, i)\n s = round(size_bytes / p, 2)\n return \"%s %s\" % (s, size_name[i])",
"def size_human(self) -> str:\n self.__verify_repo_initialized()\n nbytes = folder_size(self._repo_path, recurse=True)\n return format_bytes(nbytes)",
"def human_size(size_bytes):\n if size_bytes is 0:\n return \"0B\"\n\n def ln(x):\n n = 99999999\n return n * ((x ** (1/n)) - 1)\n\n def log(x, base):\n result = ln(x)/ln(base)\n return result\n\n exp = int(log(size_bytes, 1024))\n try:\n unit = (\"B\", \"KB\", \"MB\", \"GB\", \"TB\", \"PB\", \"EB\", \"ZB\", \"YB\")[exp]\n except KeyError:\n unit = \"YB\"\n return \"{} {}\".format(round(size_bytes / (1024 ** exp), 2), unit)",
"def human_size(size_bytes):\n if size_bytes == 1:\n # because I really hate unnecessary plurals\n return \"1 byte\"\n\n suffixes_table = [('bytes', 0), ('KB', 0), ('MB', 1), ('GB', 2), ('TB', 2), ('PB', 2)]\n\n num = float(0 if size_bytes is None else size_bytes)\n for suffix, precision in suffixes_table:\n if num < 1024.0:\n break\n num /= 1024.0\n\n if precision == 0:\n formatted_size = \"%d\" % num\n else:\n formatted_size = str(round(num, ndigits=precision))\n\n return \"%s %s\" % (formatted_size, suffix)",
"def format(self,size):\n if self.__units is None:\n # Human-readable\n return bcf_utils.format_file_size(size)\n elif self.__units == 'bytes':\n # Raw bytes\n return size\n else:\n return bcf_utils.format_file_size(size,units=self.__units)[0:-1]",
"def size_str(num):\n if num > 2 ** 30:\n return \"%0.2fGB\" % (num / 2 ** 30)\n elif num > 2 ** 20:\n return \"%0.2fMB\" % (num / 2 ** 20)\n elif num > 2 ** 10:\n return \"%0.2fkB\" % (num / 2 ** 10)\n else:\n return \"%d bytes\" % num",
"def human_size(size_bytes):\n if (size_bytes == 1):\n # because I really hate unnecessary plurals\n return \"1 byte\"\n\n suffixes_table = [('bytes',0),('KB',0),('MB',1),('GB',2),('TB',2), ('PB',2)]\n\n num = float(size_bytes)\n for suffix, precision in suffixes_table:\n if (num < 1024.0):\n break\n num /= 1024.0\n\n if (precision == 0):\n formatted_size = \"%d\" % num\n else:\n formatted_size = str(round(num, ndigits=precision))\n\n return \"%s %s\" % (formatted_size, suffix)",
"def _prettifySize(self, size) -> str:\n iteration = 0\n while size >= 1024:\n size /= 1024\n iteration += 1\n size = f'{size:.2f}'.rstrip('0').rstrip('.').rjust(6) # 6 is maximal number of digits of any input\n return f'{size} {self._SIZES_SUFFIX[iteration]}'",
"def format_bytes_size(val):\n\tif not val:\n\t\treturn '0 bytes'\n\tfor sz_name in ['bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB']:\n\t\tif val < 1024.0:\n\t\t\treturn \"{0:.2f} {1}\".format(val, sz_name)\n\t\tval /= 1024.0\n\traise OverflowError()",
"def _get_display_size(self):\n return '%d MB' % self.size if self.size < 1024 else '%.2f GB' % (self.size / 1024.0)",
"def get_file_size_str(size):\n if size < 128: return f'{size}B' # only show bytes for really small < 0.1 KB sizes\n if size < (1024*1024): return f'{size/1024:.1f}KB'\n if size < (1024*1024*1024): return f'{size/(1024*1024):.1f}MB'\n return f'{size/(1024*1024):.2}GB'",
"def creation_size_bytes(self) -> str:\n return pulumi.get(self, \"creation_size_bytes\")",
"def human_readable_size(value):\n hummanize_suffixes = ('KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB')\n base = 1024\n bytes_int = float(value)\n\n if bytes_int == 1:\n return '1 Byte'\n elif bytes_int < base:\n return '%d Bytes' % bytes_int\n\n for i, suffix in enumerate(hummanize_suffixes):\n unit = base ** (i+2)\n if round((bytes_int / unit) * base) < base:\n return '%.1f %s' % ((base * bytes_int / unit), suffix)",
"def __human_size(size, padding = True):\n # the spaces after the base unit 'B' are for alignment\n powers = { 0 : \"B \", 1 : \"KiB\", 2 : \"MiB\", 3 : \"GiB\", 4 : \"TiB\", 5 : \"PiB\", 6 : \"EiB\" }\n i = 0\n orig_size = size\n size = float(size)\n while size >= 1024:\n i += 1\n size /= 1024\n if i > 6:\n print(\"Not prepared to handle this number: {:d}\".format(orig_size))\n return \"NaN\"\n val = str(round(size, 1)) + ' ' + powers[i]\n if padding: val = \" \"*(MAX_SIZE-len(val)) + val\n return val",
"def human_bytes(n):\n if n < 1024:\n return '%d B' % n\n k = n/1024\n if k < 1024:\n return '%d KB' % round(k)\n m = k/1024\n if m < 1024:\n return '%.1f MB' % m\n g = m/1024\n return '%.2f GB' % g",
"def print_size(self):\n return self.container['print_size']",
"def size_bytes(self) -> int:\n return pulumi.get(self, \"size_bytes\")",
"def pretty_bytes(num: int) -> str:\n\n # Reject weird stuff\n try:\n if num < 0:\n raise ValueError(\"negative size\")\n except TypeError:\n raise TypeError(\"non-numeric size\")\n\n if num < 2**10:\n return f\"{num} B\"\n\n for x, p in enumerate(\"kMGTPE\"):\n if num < 2 ** ((2 + x) * 10):\n num /= 2 ** ((1 + x) * 10)\n return f\"{num:.1f} {p}iB\"\n\n # overflow or something: in this case lets just go\n # with what we were given and get on with our day.\n return f\"{num} B\"",
"def getFileSizeString(size):\n\t# Si la taille est en Go\n\tif size > 1073741824*1024:\n\t\treturn \"%.2f To\"%(size / (1073741824.*1024.))\n\telif size > 1073741824:\n\t\treturn \"%.2f Go\"%(size / 1073741824.)\n\telif size > 1048576:\n\t\treturn \"%.2f Mo\"%(size / 1048576.)\n\telif size > 1024:\n\t\treturn \"%.2f Ko\"%(size / 1024.)\n\telse:\n\t\treturn \"%d octets\"%size",
"def getSize(self, precision=1):\n kilo = 1000.0\n if self.size < kilo:\n return str(self.size) + \"B\"\n elif self.size < kilo ** 2:\n return str(round(self.size / kilo, precision)) + \"K\"\n elif self.size < kilo ** 3:\n return str(round(self.size / (kilo ** 2), precision)) + \"M\"\n elif self.size < kilo ** 4:\n return str(round(self.size / (kilo ** 3), precision)) + \"G\"\n else:\n return str(round(self.size / (kilo ** 4), precision)) + \"T\"",
"def sizeof_fmt(size, suffix='B'):\n try:\n size = int(size)\n except ValueError:\n return None\n if size <= 0:\n return '0 %s' % suffix\n\n size_name = ('', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y')\n i = int(math.floor(math.log(size, 1024)))\n if i >= len(size_name):\n i = len(size_name) - 1\n p = math.pow(1024, i)\n s = size / p\n # round to 3 significant digits\n s = round(s, 2 - int(math.floor(math.log10(s))))\n if s.is_integer():\n s = int(s)\n if s > 0:\n return '%s %s%s' % (s, size_name[i], suffix)\n else:\n return '0 %s' % suffix",
"def pretty_size(number):\n float_bytes = float(number)\n scale_factor = 0\n while float_bytes >= 1000 and scale_factor < len(SCALE_UNITS) - 1:\n scale_factor += 1\n float_bytes /= 1000\n return \"{0:,.2f} {1:}Bytes\".format(float_bytes, SCALE_UNITS[scale_factor])",
"def sizestr(sizebytes, sep='', signif=3):\n # Round size to 3 significant digits\n roundbytes = roundsignificant(sizebytes, signif)\n\n if abs(sizebytes) < 10**3:\n return '{}{}B'.format(roundbytes, sep)\n elif abs(sizebytes) < 10**6:\n return '{}{}KB'.format(maybeint(roundbytes/10**3), sep)\n elif abs(sizebytes) < 10**9:\n return '{}{}MB'.format(maybeint(roundbytes/10**6), sep)\n elif abs(sizebytes) < 10**12:\n return '{}{}GB'.format(maybeint(roundbytes/10**9), sep)\n else:\n return '{}{}TB'.format(maybeint(roundbytes/10**12), sep)",
"def state(self):\n decimals = 2\n size_mb = round(self._size/1e6, decimals)\n return size_mb",
"def format_bytes(size):\n # type: (int) -> str\n kbytes = size // 1024\n mbytes = kbytes // 1024\n gbytes = mbytes // 1024\n if gbytes:\n return \"%s %s\" % (gbytes, \"GB\")\n elif mbytes:\n return \"%s %s\" % (mbytes, \"MB\")\n elif kbytes:\n return \"%s %s\" % (kbytes, \"KB\")\n else:\n return \"%s %s\" % (size, \"bytes\")",
"def bytes_to_size(size):\n if not size >> 10 or size < 0:\n return str(size)\n elif not size >> 20:\n return '{:.2f}KB'.format(size / 1024.0)\n elif not size >> 30:\n return '{:.2f}MB'.format(size / (1024.0 ** 2))\n elif not size >> 40:\n return '{:.2f}GB'.format(size / (1024.0 ** 3))\n else:\n return '{:.2f}TB'.format(size / (1024.0 ** 4))"
] | [
"0.8138241",
"0.8061652",
"0.79895395",
"0.7839657",
"0.7548729",
"0.7528001",
"0.7491658",
"0.7461993",
"0.7455769",
"0.7443719",
"0.74179405",
"0.7413462",
"0.72744954",
"0.72632736",
"0.7252593",
"0.72264695",
"0.71850353",
"0.7179262",
"0.7177082",
"0.7156043",
"0.71192956",
"0.71008676",
"0.70799637",
"0.70619076",
"0.7053378",
"0.7047099",
"0.70227027",
"0.7018163",
"0.70178235",
"0.70036983"
] | 0.86575353 | 0 |
Return if the AudioFile has been downloaded to the current download_path location. | def is_downloaded(self) -> bool:
if not self.download_path:
return False
return Path(self.download_path).exists() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _is_downloaded(self):\n return self._system.file_exists(self._tar_name)",
"def is_file_downloading(self, data_url):\n\n # Sometimes it takes too long to load the list\n self.parent.wait_for_element_displayed(DOM.DownloadManager.download_list[0],\n DOM.DownloadManager.download_list[1], 60)\n return self.get_download_status(data_url) == \"downloading\"",
"def file_downloaded(filename):\n fc = pathlib.Path(filename)\n if fc.is_file():\n return True\n else:\n return False",
"def downloaded(self) -> bool:\n return not (self.data is None)",
"def check_downloaded(self):\n for o in self.order_lst:\n for item in o.get_items():\n mdata = item.get_metadata()\n if 'downloaded' in mdata.keys():\n if str(mdata['downloaded']) == 'True':\n return True\n \n return False",
"def is_downloadable(self):\n return True",
"def is_downloadable(self):\n return False",
"def is_download_finished(folder):\n firefox_temp_file = sorted(pathlib.Path(folder).glob('*.part'))\n chrome_temp_file = sorted(pathlib.Path(folder).glob('*.crdownload'))\n downloaded_files = sorted(pathlib.Path(folder).glob('*.*'))\n if (len(firefox_temp_file) == 0) and \\\n (len(chrome_temp_file) == 0) and \\\n (len(downloaded_files) >= 1):\n return True\n else:\n return False",
"def is_downloadable(self):\n raise NotImplementedError('Implement this method.')",
"def input_data_is_downloaded(year: int, day: int, session: str) -> bool:\n cache_file = _join_path(year, day, session, file_type=\"input_file\")\n cache_file = Path(cache_file)\n return cache_file.exists()",
"def verify_if_a_file_is_downloaded(self, file_name):\n self._basket.verify_if_a_file_is_downloaded(file_name)",
"def check_if_downloaded( url, debug_print = True ):\n\t# Get pdf filename\n\tfilename = basename( url )\n\tfileno, ext_pdf = splitext( filename )\n\tfor file in listdir( getcwd() ):\n\t\tif fileno in file:\n\t\t\tif debug_print:\n\t\t\t\tprint 'Skipping %s' % ( filename )\n\t\t\treturn True\n\treturn False",
"def exist(self):\n return self.file_path.exists()",
"def check_for_file(self):\n if self.task.file_name in os.listdir(self.task.file_storage):\n return True\n return False",
"def has_local_tails_file(self) -> bool:\n tails_file_path = Path(self.get_receiving_tails_local_path())\n return tails_file_path.is_file()",
"def has_file(self) -> bool:\n return self._file is not None",
"def exists(self):\n return self.path.is_file()",
"def can_download():\n downloading = jobtracker.query(\"SELECT * FROM files \" \\\n \"WHERE status='downloading'\")\n numdownload = len(downloading)\n used = get_space_used()\n avail = get_space_available()\n \n can_dl = (numdownload < config.download.numdownloads) and \\\n (avail > config.download.min_free_space) and \\\n (used < config.download.space_to_use)\n return can_dl",
"def is_present(self):\n return self.file_is_present()",
"def has_audio(self):\n return self.__audio_format is not None",
"def test_package_check_download(self, isfile):\n isfile.return_value = False\n r = self.client.get(self.check_download_url)\n eq_(r.status_code, 200)\n eq_(r.content, '{\"ready\": false}')\n isfile.return_value = True\n r = self.client.get(self.check_download_url)\n eq_(r.status_code, 200)\n eq_(r.content, '{\"ready\": true}')",
"def download(self, overwrite=False):\n if not self.download_dir:\n raise Exception(\"A target download directory was not has not been set.\")\n\n if not self.download_url:\n raise Exception(\"A download URL has not been set.\")\n\n if not self.is_downloaded or overwrite:\n session = download_session.make_session()\n try:\n download_request = session.get(self.download_url, stream=True, timeout=120)\n if download_request.status_code == 200:\n # Maybe we should assert 'Content-Type': 'audio/mpeg' here?\n if not self.size:\n self.size = int(download_request.headers[\"Content-Length\"])\n\n with open(self.download_path, \"wb\") as local_file:\n logger.info(f\"Downloading {self.download_filename} to \\\"{self.download_dir}\\\"...\")\n shutil.copyfileobj(download_request.raw, local_file)\n\n except Exception as e:\n logger.error(f\"Failed to download \\\"{self.download_filename}\\\" from \\\"{self.download_url}\\\"\")\n logger.error(e)\n self.delete_file()\n\n else:\n if Path(self.download_path).exists():\n return True\n else:\n logger.info(f\"File \\\"{self.download_filename}\\\" exists, skipping re-downloading...\")\n return True\n\n return False",
"def file_exists(self):\r\n if os.path.exists(self.file_path):\r\n return True\r\n else:\r\n return False",
"def is_local(self):\n try:\n return os.path.isfile(self.get_absolute_path())\n except ValueError:\n logger.error(\"'%s' is not a file\", self.get_absolute_path())\n except TypeError: # no datafile available or file does not exist\n pass\n return False",
"def download(self,fn):\n\t\treturn False #TODO: implement meme download",
"def __maybeDownload():\n if not os.path.isdir(Download.DATA_ROOT): # 若 data 目录不存在，创建 data 目录\n os.mkdir(Download.DATA_ROOT)\n file_path = os.path.join(Download.DATA_ROOT, Download.FILE_NAME)\n\n if os.path.exists(file_path): # 若已存在该文件\n statinfo = os.stat(file_path)\n if statinfo.st_size == Download.FILE_SIZE: # 若该文件正确，直接返回 file_path\n print('Found and verified %s' % file_path)\n return file_path\n else: # 否则，删除文件重新下载\n os.remove(file_path)\n\n download_url = Download.URL + Download.FILE_NAME\n print('Downloading %s ...' % download_url)\n filename, _ = urlretrieve(download_url, file_path) # 下载数据\n print('Finish downloading')\n\n statinfo = os.stat(filename)\n if statinfo.st_size == Download.FILE_SIZE: # 校验数据是否正确下载\n print('Found and verified %s' % filename)\n else:\n print(statinfo.st_size)\n raise Exception('Failed to verify ' + filename + '. Can you get to it with a browser ?')\n return filename",
"def exists(self):\n\n return os.path.exists(self[\"~filename\"])",
"def file_exists(self):\n if os.path.isfile(self.file_name):\n return True\n else:\n return False",
"def is_complete(self) -> bool:\r\n return path.exists(self._has_completed_path)",
"def is_file_exist(self):\n return os.path.isfile(os.path.join(self.output_path, 'amr_corpus_ext.pickle'))"
] | [
"0.76278245",
"0.7254355",
"0.7206337",
"0.7160229",
"0.6813698",
"0.67941236",
"0.66685086",
"0.6667035",
"0.65065354",
"0.63579845",
"0.6348419",
"0.6345613",
"0.6241858",
"0.6216495",
"0.61943287",
"0.6189139",
"0.6161682",
"0.6034005",
"0.60187346",
"0.59987867",
"0.59823114",
"0.597066",
"0.5966634",
"0.59612197",
"0.59578043",
"0.59544396",
"0.5951012",
"0.59281677",
"0.59223247",
"0.5915736"
] | 0.8001392 | 0 |
Returns a genarator of strings read from a "text_iterator" (iterating over lines), where a batch consists of adjacent lines separated by an empty line. The generator yiels one string per batch, with several adjacent lines joined by the "sep" character. | def split_batch(text_iterator, sep):
current_group = []
for l in text_iterator:
if l.strip() == "":
if current_group:
yield sep.join(current_group)
current_group = []
else:
current_group.append(l.strip())
yield sep.join(current_group) # last batch | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def txt_line_iterator(path):\n with tf.io.gfile.GFile(path) as f:\n for line in f:\n yield line.strip()",
"def yield_batches(self, texts):\n batch = []\n for text in self._iter_texts(texts):\n batch.append(text)\n if len(batch) == self.batch_size:\n yield batch\n batch = []\n\n if batch:\n yield batch",
"def logicalLines(iterable, **kwargs):\n # kwargs\n kwargs = lowerKeys(kwargs)\n continueChar = kwargs.get('continuechar', '-')\n commentChar = kwargs.get('commentchar', '!')\n #\n iterable = ( line.strip() for line in iterable )\n tmp = []\n for line in iterable:\n if line.split(commentChar)[0].endswith(continueChar):\n tmp.append(line[:-1])\n else:\n if tmp:\n tmp.append(line)\n yield ' '.join(tmp)\n tmp = []\n else:\n yield line\n # flush\n if tmp:\n yield ' '.join(tmp)",
"def _batch_tokenize(self, text: List[str]) -> List[List[str]]:\n return self.bert_model.batch_tokenize([t.strip() for t in text])",
"def batchify(self, i, iterator):\n print(f'Starting Batch {i}')\n iterator = [item.strip() for item in iterator]\n max_length = self.max_seq_length - 2 # for special tokens\n\n batches = []\n n = len(iterator)\n sentence_count = 0\n index_start = 0\n index_stop = 0\n\n while index_stop < n:\n if (len(self.tokenizer.encode(' '.join(iterator[index_start:index_stop+1])).tokens) < max_length):\n index_start += 1\n index_stop += 1\n while (len(self.tokenizer.encode(' '.join(iterator[index_start:index_stop+1])).tokens) < max_length) and (index_stop<n):\n index_stop += 1\n batches.append(iterator[index_start:index_stop])\n index_start = index_stop\n print(f'Batch {i} Done')\n return batches",
"def _iterate_lines(cls, text) -> typing.Generator[str, None, None]:\n for line in text.split('\\n'):\n yield line, line.lstrip().startswith(cls._CHECKBOX)",
"def _text_generator(reference_file, candidate_file):\n assert tf.io.gfile.exists(\n reference_file), \"Reference file {} not found\".format(reference_file)\n assert tf.io.gfile.exists(\n candidate_file), \"Candidate file {} not found\".format(candidate_file)\n with tf.io.gfile.GFile(reference_file, \"r\") as ref_file:\n with tf.io.gfile.GFile(candidate_file, \"r\") as cand_file:\n for ref_sentence, cand_sentence in itertools.zip_longest(\n ref_file, cand_file, fillvalue=None):\n assert ref_sentence is not None, (\n \"Reference sentence not found, are you sure that the files have \"\n \"the same size?\")\n assert cand_sentence is not None, (\n \"Candidate sentence not found, are you sure that the files have \"\n \"the same size?\")\n yield ref_sentence, cand_sentence",
"def ped_line_reader(line):\n s = []\n for c in line:\n if c in '\\t\\n':\n yield ''.join(s)\n s = []\n continue\n\n s.append(c)",
"def get_plain_text_reader(encoding: str = \"utf-8\"):\n def reader(files: List[str]) -> Iterable[List[str]]:\n for path in files:\n\n if path.endswith(\".gz\"):\n with gzip.open(path, 'r') as f_data:\n for line in f_data:\n yield str(line, 'utf-8').strip().split(\" \")\n else:\n with open(path, encoding=encoding) as f_data:\n for line in f_data:\n yield line.strip().split(\" \")\n\n return reader",
"def partition_text(text):\n if len(text) < 3500:\n yield text\n else:\n text_list = text.split('\\n')\n l = 0 # length iterator of current block\n i = 0 # start position of block\n j = 0 # end position of block\n\n # j scans through list of lines from start position i l tracks length\n # of all characters in the current scan If length of everything from i\n # to j+1 > the limit, yield current block, joined into single string,\n # and shift the scanning position up to the start of the new block.\n for m in text_list:\n l += len(m)\n try:\n # if adding another line will breach the limit,\n # yield current block\n if l+len(text_list[j+1]) > 3500:\n indices = [i, j]\n yield '\\n'.join(\n [msg for k, msg in enumerate(text_list)\n if k in indices])\n # shift start position for the next block\n i = j+1\n l = 0\n j += 1\n except IndexError:\n yield text_list[i]",
"def sentence_iterator(corpus_iterator):\r\n current_sentence = [] #Buffer for the current sentence\r\n for l in corpus_iterator: \r\n if l is None:\r\n if current_sentence: #Reached the end of a sentence\r\n yield current_sentence\r\n current_sentence = [] #Reset buffer\r\n else: # Got empty input stream\r\n sys.stderr.write(\"WARNING: Got empty input file/stream.\\n\")\r\n raise StopIteration\r\n else:\r\n current_sentence.append(l) #Add token to the buffer\r\n\r\n if current_sentence: # If the last line was blank, we're done\r\n yield current_sentence #Otherwise when there is no more token\r\n # in the stream return the last sentence.\r",
"def _string_to_chunks(text, **kwargs):\n text_limit = kwargs.get('text_limit', 1024)\n lines = \"\"\n for line in text:\n if len(lines) + len(line) < text_limit:\n lines += line\n else:\n yield lines\n lines = line[0:text_limit]\n else:\n yield lines",
"def rows(file, prep=None,\n whitespace='[\\n\\r\\t]',\n comments='#.*',\n sep=\",\"\n ):\n doomed = re.compile('(' + whitespace + '|' + comments + ')')\n with open(file) as fs:\n for line in fs:\n line = re.sub(doomed, \"\", line)\n if line:\n row = map(lambda z: z.strip(), line.split(sep))\n if len(row) > 0:\n yield prep(row) if prep else row",
"def batch_generator(id_sent_tsv: Path,\n batch_size: int = 128 * 128) -> GEN_BATCH:\n ids = list()\n sents = list()\n with open(p.abspath(id_sent_tsv)) as tsv:\n for line in tsv:\n sent_id, sent_text = str(line).replace('\\n', '').split('\\t')\n ids.append(int(sent_id)), sents.append(str(sent_text))\n\n while len(sents):\n yield (list(ids[:batch_size]), list(sents[:batch_size]))\n ids, sents = list(ids[batch_size:]), list(sents[batch_size:])\n gc.collect()",
"def __iter__(self):\n normed_sent = preprocess(self.strings)\n for sent in split_iter(normed_sent, self.eos_placement):\n sent = ''.join(sent)\n if sent:\n yield list(tokenize(sent))",
"def _gen_txt_data(self, f):\n\t\treader = iter(f)\n\n\t\tfor line_num, line in enumerate(reader):\n\t\t\tif line_num == 0 and self.has_header:\n\t\t\t\tcontinue\n\n\t\t\tdatum = line.rstrip('\\r\\n')\n\n\t\t\tyield datum, line_num+1",
"def tokenizer(text):\n for entry in text.split('$$$$\\n'):\n if entry.rstrip():\n lines_stream = deque(entry.split('\\n'))\n else:\n continue\n\n # yield from _molfile(stream=lines_stream)\n for token in _molfile(stream=lines_stream):\n yield token\n\n if len(lines_stream):\n # yield from _sdfile(stream=lines_stream)\n for token in _sdfile(stream=lines_stream):\n yield token\n\n yield EndOfFile()",
"def __iter__(self):\n try:\n # Assume it is a file-like object and try treating it as such\n # Things that don't have seek will trigger an exception\n self.source.seek(0)\n for line in itertools.islice(self.source, self.limit):\n line = utils.to_unicode(line).split()\n i = 0\n while i < len(line):\n yield line[i: i + self.max_sentence_length]\n i += self.max_sentence_length\n except AttributeError:\n # If it didn't work like a file, use it as a string filename\n with utils.smart_open(self.source) as fin:\n for line in itertools.islice(fin, self.limit):\n line = utils.to_unicode(line).split()\n i = 0\n while i < len(line):\n yield [self.sos_token] + line[i: i + self.max_sentence_length - 2] + [self.eos_token]\n i += self.max_sentence_length",
"def get_batches(summaries, texts, batch_size):\r\n for batch_i in range(0, len(texts)//batch_size):\r\n start_i = batch_i * batch_size\r\n summaries_batch = summaries[start_i:start_i + batch_size]\r\n texts_batch = texts[start_i:start_i + batch_size]\r\n pad_summaries_batch = np.array(pad_sentence_batch(summaries_batch))\r\n pad_texts_batch = np.array(pad_sentence_batch(texts_batch))\r\n \r\n # Need the lengths for the _lengths parameters\r\n pad_summaries_lengths = []\r\n for summary in pad_summaries_batch:\r\n pad_summaries_lengths.append(len(summary))\r\n \r\n pad_texts_lengths = []\r\n for text in pad_texts_batch:\r\n pad_texts_lengths.append(len(text))\r\n \r\n yield pad_summaries_batch, pad_texts_batch, pad_summaries_lengths, pad_texts_lengths",
"def get_batches(int_text, batch_size, seq_length):\n slice_size = batch_size * seq_length\n n_batches = int(len(int_text) / slice_size)\n result = []\n\n for i in range(n_batches):\n start, stop = i * slice_size, (i + 1) * slice_size\n x = int_text[start: stop]\n x = np.pad(x, (0, slice_size - len(x)), 'constant')\n x = x.reshape([-1, seq_length])\n\n y = int_text[start + 1: stop + 1]\n y = np.pad(y, (0, slice_size - len(y)), 'constant')\n y = y.reshape([-1, seq_length])\n result.append([x, y])\n\n return np.asarray(result)",
"def reader(self):\n @contextmanager\n def generator(data):\n \"\"\"\n Args:\n data (str): could be a filename or the text to tokenize.\n Returns:\n a context manager that can be used in a `with` contruct,\n yielding each line of the tokenized `data`.\n \"\"\"\n if not os.path.exists(data):\n yield self.format(self.predict(data))\n else:\n with open(data) as f:\n yield self.format(self.predict(f.read()))\n return generator",
"def rows(self):\n with self.input().open('r') as fobj:\n for line in fobj:\n yield line.strip('\\n').split('\\t')",
"def get_batches(summaries, texts, batch_size):\n for batch_i in range(0, len(texts)//batch_size):\n start_i = batch_i * batch_size\n summaries_batch = summaries[start_i:start_i + batch_size]\n texts_batch = texts[start_i:start_i + batch_size]\n pad_summaries_batch = np.array(pad_sentence_batch(summaries_batch))\n pad_texts_batch = np.array(pad_sentence_batch(texts_batch))\n \n # Need the lengths for the _lengths parameters\n pad_summaries_lengths = []\n for summary in pad_summaries_batch:\n pad_summaries_lengths.append(len(summary))\n \n pad_texts_lengths = []\n for text in pad_texts_batch:\n pad_texts_lengths.append(len(text))\n \n yield pad_summaries_batch, pad_texts_batch, pad_summaries_lengths, pad_texts_lengths",
"def _get_load_iterators(options):\n \n #declare delimiters and field/line iterators\n field_delimiter = ','\n line_delimiter = '\\n'\n escape_char = '\\\\'\n \n line_pattern = re.compile('(?s)^(.*?)' + re.escape(line_delimiter) + '(.*)$')\n field_pattern = re.compile('(?s)^(.*?)' + re.escape(field_delimiter) + '(.*)$')\n \n def _line_iter(f):\n buffer = ''\n while True:\n next = f.read(1024 * 4)\n if next == '':\n if buffer:\n yield buffer\n \n return\n \n buffer += next\n while buffer:\n m = re.match(line_pattern, buffer)\n if m:\n yield m.group(1)\n buffer = m.group(2)\n else:\n break\n\n unescape_map = dict()\n if options['escape_eol_chars']:\n unescape_map['n'] = '\\n'\n unescape_map['t'] = '\\t'\n unescape_map['r'] = '\\r'\n\n def _unescape(s):\n in_escape = False\n for c in s:\n if in_escape:\n yield unescape_map.get(c, c)\n in_escape = False\n elif c == escape_char:\n in_escape = True\n else:\n yield c\n \n def _field_iter(s):\n while s:\n m = re.match(field_pattern, s)\n if m:\n yield ''.join(m.group(1))\n s = m.group(2)\n else:\n yield ''.join(_unescape(s))\n return\n \n return _line_iter, _field_iter",
"def get_line_iterator(iterable, special=[]):\n def helper(str):\n \"Helper str -> str\"\n pair = str.rstrip('\\n').split('#', 1)\n if special:\n if len(pair) == 1:\n return pair[0], None\n else:\n for i in special:\n if pair[1].startswith(i):\n return pair\n return pair[0], None\n else:\n return pair[0]\n\n return itertools.imap(helper, iterable)",
"def line_iter(s):\n\n i=0\n n=len(s)\n while i<n:\n j=s.find('\\n',i)\n if j<0:\n yield s[i:]\n j=n\n else:\n yield s[i:j]\n j+=1\n i=j",
"def gen_concatenate(iterators):\n for it in iterators:\n yield from it",
"def file_generator(file_object):\n while True:\n data = file_object.readline()\n if not data:\n break\n yield data.split(config.CSV_DELIMITER)",
"def __iter__(self):\n txt = self.get_comp_text()\n # split by sentences\n sentences = txt.split('\\n')\n # breaks when parsing train2 (has EOF)\n if sentences[-1] == '':\n sentences = sentences[:-1]\n # slice data\n if self.slice is not None:\n start, end = self.slice\n sentences = sentences[start:end]\n for sent_id, sentence in enumerate(sentences):\n words = sentence.split(' ')\n stripped_sentence = []\n # X, y\n tuples, tags = [], []\n # helper\n word_tag_tuples = []\n if not self.comp:\n for word in words:\n word_stripped, tag_stripped = word.split('_')\n word_tag_tuples.append((word_stripped, tag_stripped))\n stripped_sentence.append(word_stripped)\n\n for i, word_tag_tuple in enumerate(word_tag_tuples):\n tag = word_tag_tuple[1]\n tags.append(tag)\n if i == 0:\n tuples.append(('*', '*', sent_id, i))\n elif i == 1:\n tuples.append(('*', word_tag_tuples[i - 1][1], sent_id, i))\n else:\n u = word_tag_tuples[i - 2][1] # pre pre tag\n v = word_tag_tuples[i - 1][1] # pre tag\n tuples.append((u, v, sent_id, i))\n\n yield tuples, tags, stripped_sentence\n else:\n yield [(None, None, sent_id)], [], words",
"def generate_batches(source,n=20):\n blist=[]\n with open(source) as f_source:\n start=next_n_lines(f_source, n); string=gen_string(start); blist.append(string)\n while start!=[]: start=next_n_lines(f_source, n); string=gen_string(start); blist.append(string)\n print('2. Generation of batches completed!')\n return blist"
] | [
"0.5992676",
"0.58370346",
"0.57789314",
"0.56593597",
"0.56508684",
"0.55819076",
"0.5481003",
"0.54286534",
"0.54286367",
"0.5426697",
"0.5426456",
"0.54091066",
"0.53727454",
"0.5350957",
"0.5350398",
"0.52409923",
"0.52257967",
"0.51570374",
"0.51264596",
"0.5123674",
"0.51192063",
"0.51169235",
"0.51040334",
"0.50907445",
"0.50869936",
"0.5083688",
"0.5074257",
"0.5070577",
"0.50549024",
"0.50511456"
] | 0.7925198 | 0 |
Method to obtain an image for a question | def get_image_question(self, obj):
question_image = 'Sin imagen'
if QuestionImage.objects.filter(question=obj).exists():
question_image = (QuestionImage.objects.filter(question=obj)
.order_by('-upload_date').first())
question_image = (settings.IMAGE_HOST + question_image.image.url)
return question_image | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getimage(self):",
"def get_image_url():",
"def image(self, where):\n cook = cookie()\n I = Image(cook, self)\n self.call('image', cook, where)\n print(\"IMAGE\", where)\n return I",
"def getimgs():",
"def _get_image(self, name):\n document = self._control.document()\n image = document.resource(QtGui.QTextDocument.ImageResource,\n QtCore.QUrl(name))\n return image",
"def radio(subject):\n return image(data.get_radio(subject))",
"def get_image(request, image_class, image_name):\n image = image_cache[image_class][image_name]\n return HttpResponse(image, content_type='image/png')",
"def ia_img(self):\n if self.master.ia_choice == 'rock':\n return self.rockimg\n elif self.master.ia_choice == 'scissor':\n return self.scissorimg\n if self.master.ia_choice == 'paper':\n return self.paperimg",
"def image(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"image\")",
"def get_image(self):\n return self.image",
"def get_image(self):\n return self.image",
"def get_image(self):\n return self.image",
"def get_image(self):\n self.drawer.flush()\n return self.img",
"def chooseImage(prompt='Choose an Image and press OK', title='Choose an Image'):\n case = rsl.get_current('Case')\n imageNames = [ img.Name for img in case.Examinations ]\n return getChoiceFromList(choiceList=imageNames, prompt=prompt, title=title)",
"def get_image(id, frame=\"ICRS\", survey=\"DSS\", cmap=\"gray\", fov=1.0):\n\n id = id\n frame = frame\n survey = survey\n cmap = cmap\n\n # instantiate target object\n tgt = Target(id=id, frame=frame, survey=survey)\n\n # resolve target name, if this fails, quit execution and return the error code\n code = tgt.resolve_name()\n if code != 0:\n return(1)\n \n # make hips2fits query to be placed in url\n query_params = {\n 'hips': tgt.survey,\n 'object': tgt.id,\n 'ra': tgt.coords.ra.value,\n 'dec': tgt.coords.dec.value,\n 'fov': (fov * u.deg).to(u.deg).value,\n 'width': 500,\n 'height': 500,\n }\n\n url = f'http://alasky.u-strasbg.fr/hips-image-services/hips2fits?{urlencode(query_params)}'\n try:\n # try grabbing the fits file and plotting it.\n hdu = fits.open(url)\n\n im = hdu[0].data\n\n fig = plt.figure()\n ax=plt.gca()\n ax.imshow(im, origin='lower', cmap=cmap)\n plt.title(f\"{tgt.main_id}: {tgt.survey}\")\n fig.savefig(\"fig.jpg\", dpi=200)\n return(0)\n except Exception as e:\n # if the above failed, print the error and quit\n print(e)\n return(1)",
"def get_image(self):\n return self.process_raw_image(self.get_raw_image())",
"def image(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"image\")",
"def get_image():\n response = send_file(tempFileObj, as_attachment=True, attachment_filename='marked_image.png')\n return response",
"def get_image():\n return models.Image.objects.all()[0]",
"def image(self) -> str:\n return pulumi.get(self, \"image\")",
"async def imagine(self, prompt: str, size: str) -> str:\n resp = await openai.Image.acreate(prompt=prompt, size=size, n=1)\n if len(resp.data) == 0:\n raise ValueError(\"received an empty answer\")\n return resp.data[0].url",
"def get_image(self, index):\r\n \r\n # Get request to get all the links for all exercises\r\n image = requests.get(API.url_image, headers = self.headers).json()\r\n filename = download(image[index]['image'])",
"def get_image ( self, object ):\n return self.image",
"def get_input(self, idx):\r\n img_filename = self.root / \"images\" / self._image_array[idx]\r\n x = Image.open(img_filename)\r\n return x",
"def image(self) -> Optional[str]:\n return pulumi.get(self, \"image\")",
"def image(self) -> Optional[str]:\n return pulumi.get(self, \"image\")",
"def image(self) -> Optional[str]:\n return pulumi.get(self, \"image\")",
"def image(self) -> Optional[str]:\n return pulumi.get(self, \"image\")",
"def image(self) -> Optional[str]:\n return pulumi.get(self, \"image\")",
"def image(self) -> Optional[str]:\n return pulumi.get(self, \"image\")"
] | [
"0.6956642",
"0.6416805",
"0.63991195",
"0.6182699",
"0.61808884",
"0.61468655",
"0.61231196",
"0.6101426",
"0.6090693",
"0.6057402",
"0.6057402",
"0.6057402",
"0.60554934",
"0.60486346",
"0.6024556",
"0.6010983",
"0.59846336",
"0.5952543",
"0.59464836",
"0.5944744",
"0.59110284",
"0.5900241",
"0.5887497",
"0.58714145",
"0.5861704",
"0.5861704",
"0.5861704",
"0.5861704",
"0.5861704",
"0.5861704"
] | 0.7130197 | 0 |
Method to obtain a list of tags associated of a question | def get_tags(self, obj):
if QuestionTag.objects.filter(question=obj).exists():
id_tags = QuestionTag.objects.filter(question=obj).values('tag__id')
tags_obj = Tag.objects.filter(id__in=id_tags)
return TagSerializer(tags_obj, many=True).data
else:
return "No tags" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tags():",
"def getTags(self,):\n\t\treturn self.tags;",
"def get_all_tagged(self,tag_name):\n return self.tag2elements[tag_name]",
"def dataset_tags(connection):\n assert connection\n query = \"\"\"select * from tags()\"\"\"\n result = sqlio.read_sql_query(query, connection)\n return [item.strip() for item in result['name']], [tag_id.strip() for tag_id in result['tag_id']]",
"def tags(self):\n return self.get(\"tags\")",
"def tags(self) -> Sequence[str]:\n return pulumi.get(self, \"tags\")",
"def tags(self) -> list[str]:\n _args: list[Arg] = []\n _ctx = self._select(\"tags\", _args)\n return _ctx.execute_sync(list[str])",
"def getTags(number=None):",
"def get_tags(self):\n return self.tags",
"def tag_strings(self):\n return [tag.tag_text for tag in self.tags.all()]",
"def list_all_tags(self,obs):",
"def get_tags(self) -> Set[Text]:\r\n return {tag for tag in self.tags}",
"def get_tags_list(*args, **kwargs):\n return Tag.objects.active()",
"def get_tags_list(*args, **kwargs):\n return Tag.objects.active()",
"def _categorize_questions(questions):\n # type: (Dict) -> Dict[str, List[str]]\n questions_by_category_tag = defaultdict(list) # type: Dict[str, List[str]]\n for question_name, question_class in questions.items():\n template_dict = question_class.template\n tags = template_dict.get(\"instance\").get(\"tags\")\n category_tag = _categorize_question(question_name, tags)\n questions_by_category_tag[category_tag].append(question_name)\n return questions_by_category_tag",
"def tags(self):\r\n url = '{0}/tags/'.format(self.get_url())\r\n request = http.Request('GET', url)\r\n\r\n return request, parsers.parse_json",
"def tags(self):\r\n return resources.Tags(self)",
"def getTagList(self):\n if not self.proxy:\n self.proxy = self.session.service(\"ALBehaviorManager\")\n return self.proxy.getTagList()",
"def tags(self):\n return self._tags",
"def tags(self):\n return self._tags",
"def tags(self):\n return self._tags",
"def tags(self):\n return self._tags",
"def tags(self):\n return self._tags",
"def tags(self):\n return self._tags",
"def tags(self):\n return self._tags",
"def tags(self):\n return self._tags",
"def tags(self):\r\n url = '{0}/{1}'.format(self.get_url(), 'tags')\r\n\r\n return http.Request('GET', url), parsers.parse_json",
"def tags(self):\n return self._item.get(\"tags\")",
"def tags(self):\n return self.__tags[:]",
"def get_tags(self):\n\n return self.tags"
] | [
"0.68273413",
"0.6607626",
"0.6580955",
"0.64498675",
"0.64488304",
"0.6422194",
"0.6385951",
"0.6355473",
"0.6348337",
"0.63187283",
"0.62957776",
"0.62918216",
"0.6291783",
"0.6291783",
"0.62898767",
"0.6275979",
"0.62535083",
"0.6249637",
"0.6228697",
"0.6228697",
"0.6228697",
"0.6228697",
"0.6228697",
"0.6228697",
"0.6228697",
"0.6228697",
"0.62257576",
"0.6190668",
"0.617727",
"0.6153899"
] | 0.6970872 | 0 |
Method to obtain likes for a question | def get_likes(self, obj):
return QuestionPersonLike.objects.filter(question=obj,
like=True).count() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def likes(self):\r\n return Likes(self)",
"def ListLikes(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')",
"def get_has_like(self, obj):\n if 'person_id' in self.context['request'].GET:\n if (QuestionPersonLike.objects\n .filter(person__id=self.context['request'].GET['person_id'],\n question=obj).exists()):\n return (QuestionPersonLike.objects\n .filter(person__id=self.context['request']\n .GET['person_id'],\n question=obj)\n .last().id)\n return 0",
"def get_likes(self):\n source, edge = self.id, \"likes\"\n return User.graph().get_connections(source, edge, limit=100000)[\"data\"]",
"def likes(self):\n return self.get_queryset().filter(vote__gt=0)",
"def get_likes_count():\n return Flag.objects.filter(flag=Flag.LIKE_FLAG).count()",
"def likes():\n click.echo(chalk.blue(\"For whom you want to view likes for\"))\n friend_name = input().strip().lower()\n FRIENDS_FILE_PATH = get_friends_file_path(friend_name)\n\n if os.path.isfile(FRIENDS_FILE_PATH):\n with open(FRIENDS_FILE_PATH) as fin:\n contents = yaml.load(fin)\n entries = contents[\"entries\"]\n likes = []\n for entry in entries:\n if \"likes\" in entry:\n likes.extend(entry[\"likes\"])\n click.echo(\"Likes:\")\n for i, n in enumerate(likes):\n click.echo(str(i) + \": \" + n)\n else:\n click.echo(\n chalk.red(\n 'The Likes file path for this module does not exist. Please type \"yoda people like\" to create a new one'\n )\n )",
"def get_dislikes(self, obj):\n return QuestionPersonLike.objects.filter(question=obj,\n like=False).count()",
"def get_user_likes(self, data_base):\n cursor = data_base.cursor(dictionary=True)\n cursor.execute(f\"SELECT user_id FROM user_like WHERE post_id = {self.id}\")\n user_likes = tuple(map(lambda x: str(x['user_id']), cursor.fetchall()))\n if not user_likes:\n return []\n cursor.execute(f\"SELECT username FROM user WHERE id IN ({', '.join(user_likes)})\")\n users = cursor.fetchall()\n cursor.close()\n return list(map(lambda x: x['username'], users))",
"def like(self):\n self.like_count = self.like_count + 1 if self.like_count else 1",
"def get_likes_list(self, username):\n api = self.api\n api.searchUsername(username) \n result = api.LastJson\n username_id = result['user']['pk'] #Gets the user ID\n user_posts = api.getUserFeed(username_id) # gets the user feed\n result = api.LastJson\n media_id = result['items'][0]['id'] #gets the most recent post\n api.getMediaLikers(media_id) #gets users who liked\n users = api.LastJson('users')\n for user in users: #appends the users to the list\n users_list.append({'pk':user['pk'], 'username':user['username']})",
"def parseLikeData(self):\n att: dict = self.src.xpath('//div[@class=\"f-single-foot\"]//a[@class=\"praise qz_like_prase\"]')[0].attrib\n assert att\n return att['data-islike'], att['data-likecnt'], att['data-showcount'], att['data-unikey'], att['data-curkey']",
"def GetLike(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')",
"def get_likes_message(self, mid):\n cursor = self.get_cursor()\n query = 'SELECT count(*) FROM vote WHERE mid = %s AND upvote = TRUE'\n cursor.execute(query, (mid,))\n return cursor.fetchall()",
"def likeSongComment(self, commentID, songID, like = True):\n currAPIVersion = self.config['apiVersion']\n currAPIURL = URL_NEAPIS[sys._getframe().f_code.co_name]\n currAPIURL = currAPIURL[min(currAPIVersion, len(currAPIURL) - 1)]\n\n rid = \"R_SO_4_%s\" % songID\n\n currDict = {\n \"commentID\" : commentID,\n \"threadID\" : rid,\n \"like\" : repr(like).lower()\n }\n\n currC, currR = self._mySubmit(currAPIURL, currDict, (\"un\",\"\")[like])\n self.apiLog.info(\"%s Json Loads Begin\", sys._getframe().f_code.co_name)\n currR = json.loads(currR)\n self.apiLog.info(\"%s Json Loads End\", sys._getframe().f_code.co_name)\n self.updateCookie(currC)\n self.checkCode(currR['code'])\n #liking a liked comment will cause 400 error\n\n return currR, currAPIURL[2]",
"def get(self, request, **kwargs):\n\n likes = None\n slug = kwargs.get('slug')\n try:\n article = Article.objects.get(slug=slug)\n except Exception:\n return Response({\"response\": no_article},\n status=status.HTTP_204_NO_CONTENT)\n likes = LikeDislikeArticle.objects.filter(article=article)\n return Response({\"response\": len(\n [like for like in likes if like.is_liked])},\n status=status.HTTP_200_OK)",
"def like(self, n: int) -> None:\n\n # YOUR CODE HERE\n self.likes += 1",
"def get_user_likes(self) -> int:\n return -1",
"def displayAlsoLike(self):\n\n result = self.client.get(\"/view_favorites\")\n self.assertIn(b\"11925205\", result.data)",
"def get_video_likes(self, response):\n return response.css(\".like-button-renderer-like-button\")\\\n .extract_first(default='')",
"def GetLikesSummary(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')",
"def test_like_activity_by_various(self):\n from .mockers import user_status_context\n from .mockers import subscribe_context, create_context\n username = 'messi'\n username_not_me = 'xavi'\n self.create_user(username)\n self.create_user(username_not_me)\n self.create_context(create_context)\n self.admin_subscribe_user_to_context(username, subscribe_context)\n self.admin_subscribe_user_to_context(username_not_me, subscribe_context)\n res = self.create_activity(username, user_status_context)\n activity_id = res.json['id']\n res = self.testapp.post('/activities/%s/likes' % activity_id, '', oauth2Header(username_not_me), status=201)\n res = self.testapp.post('/activities/%s/likes' % activity_id, '', oauth2Header(username), status=201)\n\n self.assertEqual(res.json['object']['likes'][0]['username'], username_not_me)\n self.assertEqual(res.json['object']['likes'][1]['username'], username)\n self.assertEqual(res.json['object']['liked'], True)\n self.assertEqual(res.json['object']['likesCount'], 2)",
"def post_likes(request):\n if request.method == 'POST':\n if not request.user.is_authenticated:\n raise PermissionDenied\n pk = request.POST.get('post_id')\n try:\n post = PostsModel.objects.get(id=pk)\n except PostsModel.DoesNotExist:\n post = None\n try:\n likes = LikesModel.objects.get(user=request.user, post=post)\n except LikesModel.DoesNotExist:\n likes = None\n\n\n if likes == None:\n likes = LikesModel.objects.create(user=request.user, post=post)\n post.likes_count = F('likes_count') + 1\n post.save(update_fields=[\"likes_count\"])\n class_likes = 'fa fa-heart mx-2'\n else:\n if likes.is_liked == True:\n likes.is_liked = False\n likes.save()\n post.likes_count = F('likes_count') - 1\n post.save(update_fields=[\"likes_count\"])\n class_likes = 'fa fa-heart-o mx-2'\n elif likes.is_liked == False:\n likes.is_liked = True\n likes.save()\n post.likes_count = F('likes_count') + 1\n post.save(update_fields=[\"likes_count\"])\n class_likes = 'fa fa-heart mx-2'\n post.refresh_from_db()\n response_data = {'_code' : 0, '_status' : 'ok', '_likes': post.likes_count, '_class_likes': class_likes}\n else:\n response_data = {'_code' : 1, '_status' : 'no' }\n\n return JsonResponse(response_data)",
"def test_like_topic_viewset(self):\n\n topic = TopicFactory(author=self.user)\n response = self.client.post(reverse('api:topics-like', kwargs={'topic_id': topic.id}))\n self.assertEqual(response.status_code, status.HTTP_201_CREATED)\n obj_type = ContentType.objects.get_for_model(topic)\n likes = Like.objects.filter(\n content_type=obj_type, object_id=topic.id, user=self.user)\n self.assertTrue(likes.exists())",
"def get(self, request, **kwargs):\n\n try:\n disliked_article = get_article(kwargs)\n except Exception:\n return Response({\"response\": \"No article found\"},\n status=status.HTTP_204_NO_CONTENT)\n dislikes = LikeDislikeArticle.objects.filter(\n article=disliked_article)\n dislikes_number = [\n dislike for dislike in dislikes if dislike.is_disliked]\n return Response({\"response\": len(dislikes_number)},\n status=status.HTTP_200_OK)",
"def LikeArticle(request):\n try:\n if not request.user.is_authenticated():\n return HttpResponse(json.dumps({\n \"result\": \"1\"\n }))\n\n like = request.GET.get('like', '')\n article_id = request.GET.get('article_id', '')\n\n if str(like).lower() != 'true':\n like = 'false'\n else:\n like = 'true'\n \n record = UserLikedArticles.objects.filter(user=request.user.id, article=article_id)\n\n if like == 'false':\n if record != None and len(record) > 0:\n record[0].delete()\n else:\n if record == None or len(record) == 0:\n like = UserLikedArticles()\n like.user = request.user.id\n like.article=Article.objects.filter(id=article_id)[0]\n like.save()\n \n article = Article.objects.filter(id=article_id)[0]\n article.likes = len(UserLikedArticles.objects.filter(article=article_id))\n article.save()\n \n return HttpResponse(json.dumps({\n \"result\": 0\n }))\n except Exception, e:\n return HttpResponse(json.dumps({\n \"result\": e\n }))",
"def like_cafes():\n if CURR_USER_KEY in session:\n cafe_id = request.args.get(\"cafe_id\")\n user = g.user\n print(user.id)\n print(user.likes)\n for like in user.likes:\n if like.cafe_id == int(cafe_id or 0):\n print(\"get True\")\n return jsonify({\"likes\": True})\n\n return jsonify({\"likes\": False})\n\n return jsonify({\"error\": \"Not logged in\"})",
"def like_tweet(self, tag):\n self.bot.get('https://twitter.com/search?q=' + tag + '&src=typed')\n self.__wait(3, 3)\n for i in range(1, 3):\n self.bot.execute_script('window.scrollTo(0,document.body.scrollHeight)')\n self.__wait(2, 3)\n tweets = self.bot.find_elements_by_tag_name('article')\n\n links = []\n for tweet in tweets:\n sub_links = tweet.find_elements_by_tag_name('a')\n links += [sub_link.get_attribute('href')\n for sub_link in sub_links if 'status' in sub_link.get_attribute('href')]\n\n print('Started to like {} tweets'.format(len(links)))\n\n for link in links:\n self.bot.get(link)\n self.__wait(3, 5)\n likes = self.bot.find_elements_by_css_selector('div[data-testid=\"like\"')\n for like in likes:\n like.click()\n self.__wait(3, 5)",
"def artwork_like(request):\n artwork_number = request.GET.get('id')\n following_page = 'artwork_detail?id='+str(artwork_number)\n if 'following' in request.GET:\n following_page = request.GET.get('following')\n artwork = Artwork.objects.get(id=artwork_number)\n user = request.user\n like = Like(user=user, artwork=artwork)\n \"\"\" Save the like in the database, attached to the correct artwork piece using its unique ID \"\"\"\n like.save()\n return HttpResponseRedirect(following_page)",
"def calc_likes_from_post(self, post):\n postlikes = len(post['likes'])\n comments = post['comments']\n commentslikes = 0\n if comments: # not empty\n # DataFrame to avoid iterating over each comment\n commentsdf = pd.DataFrame(comments)\n commentslikes = commentsdf['like_count'].sum()\n likes = {'post_likes': postlikes, 'comments_likes': commentslikes}\n return likes"
] | [
"0.6586108",
"0.6507531",
"0.6450978",
"0.63749194",
"0.6362392",
"0.6258385",
"0.62290895",
"0.61731577",
"0.60842955",
"0.60090333",
"0.59624845",
"0.5902437",
"0.5881919",
"0.58568496",
"0.58214945",
"0.5808337",
"0.58071214",
"0.5805473",
"0.57909113",
"0.57903504",
"0.57665235",
"0.5765442",
"0.57619655",
"0.57596916",
"0.5744004",
"0.57208145",
"0.5707976",
"0.5705667",
"0.5701031",
"0.56886625"
] | 0.7416896 | 0 |
Method to obtain dislikes for a question | def get_dislikes(self, obj):
return QuestionPersonLike.objects.filter(question=obj,
like=False).count() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dislikes(self):\n return self.get_queryset().filter(vote__lt=0)",
"def get_video_dislikes(self, response):\n return response.css(\".like-button-renderer-dislike-button\")\\\n .extract_first(default='')",
"def test_unauthenticated_user_disliking(self):\n self.like_dislike(self.like_url(6))",
"def test_unauthenticated_user_liking(self):\n self.like_dislike(self.dislike_url(5))",
"def get_meals_user_disliked(username):\n meals_user_disliked = []\n user_disliked = Rating.objects.filter(member__username=username, like=False)\n for ratting in user_disliked:\n meals_user_disliked.append(ratting.meal)\n return meals_user_disliked",
"def meal_disliked(request, meal_pk):\n meal_pk = int(meal_pk)\n meal = Meal.objects.get(pk=meal_pk)\n like = False\n member = request.user\n\n try:\n rating = Rating.objects.get(member=member, meal=meal)\n r_percent = meal.percent()\n except ObjectDoesNotExist:\n Rating.objects.create_rating(member, meal, like)\n r_percent = meal.percent()\n\n rating.like = like\n rating.save()\n r_percent = meal.percent()\n return HttpResponse(r_percent)",
"def dislike_comment(request, pk, pk1):\r\n comment = get_object_or_404(Comment, id=request.POST.get('id'))\r\n disliked = False\r\n if comment.dislikes.filter(id=request.user.id).exists():\r\n comment.dislikes.remove(request.user)\r\n disliked = False\r\n else:\r\n comment.dislikes.add(request.user)\r\n disliked = True\r\n\r\n context = {\r\n 'is_liked': disliked,\r\n 'total_dislikes': comment.dislikes.count()\r\n }\r\n\r\n if request.method == 'POST':\r\n return HttpResponse(\r\n json.dumps(context),\r\n content_type=\"application/json\")",
"def dislike(self, event, number):\n\n if not hasattr(self, 'user_id') or not hasattr(self, 'top_id'):\n vk_common.dprint(2, vk_common.func_name(), f\"Не заданы атрибуты user_id = или top_id.\")\n return\n\n item_id = self.item_ids[self.top_id - 1]\n if item_id is None:\n vk_common.dprint(2, vk_common.func_name(), f\"Атрибут item_id = None.\")\n return\n else:\n vk_common.dprint(2, vk_common.func_name(), f\"number = {number}; item_id = {item_id}\")\n\n vk_common.dprint(2, vk_common.func_name(), f\"number = {number}; item_id = {item_id}\")\n vk_common.dprint(1, f\"имя файла с фото = \\\"{self.user_id}_{self.top_id}\\\"; \"\n f\"ссылка = https://vk.com/id{self.user_id}\")\n\n err, msg, likes = vk_common.dislike_photo(self.user_id, item_id)\n if err != 0:\n mb.showinfo(\"Информация\", f\"Не смогли убрать лайк у фото пользователя с id = {self.user_id}.\")\n vk_common.dprint(2, \"Не смогли убрать лайк.\")\n return\n mb.showinfo(\"Информация\", f\"Убрали лайк у фото пользователя с id = {self.user_id}.\")\n vk_common.dprint(2, f\"Убрали лайк: owner_id = {self.user_id}; item_id = {item_id}\")",
"def get(self, request, **kwargs):\n\n try:\n disliked_article = get_article(kwargs)\n except Exception:\n return Response({\"response\": \"No article found\"},\n status=status.HTTP_204_NO_CONTENT)\n dislikes = LikeDislikeArticle.objects.filter(\n article=disliked_article)\n dislikes_number = [\n dislike for dislike in dislikes if dislike.is_disliked]\n return Response({\"response\": len(dislikes_number)},\n status=status.HTTP_200_OK)",
"def dislike(request, pk):\n update_posts_expiration()\n post = 0;\n post = Post.objects.get(id=pk)\n if post.is_expired == True:\n return Response(\"You can't interact with a expired post\")\n else:\n if request.method == \"POST\":\n if request.user != post.user:\n post.dislikes_count += 1\n post.save()\n serializer = DislikeSerializer(data=request.data)\n if serializer.is_valid():\n serializer.save(user=request.user, disliked_post=post)\n return Response(\"you disliked the post with title: \" + post.title)\n else:\n return Response(serializer.errors)\n else:\n return Response(\"you can't dislike your own post\")\n \n\n return Response(\"you didn't dislike the post yet\")",
"def dislike_post(request, pk):\r\n post = get_object_or_404(Post, id=request.POST.get('id'))\r\n disliked = False\r\n if post.dislikes.filter(id=request.user.id).exists():\r\n post.dislikes.remove(request.user)\r\n disliked = False\r\n else:\r\n if post.likes.filter(id=request.user.id).exists():\r\n post.likes.remove(request.user)\r\n post.dislikes.add(request.user)\r\n disliked = True\r\n\r\n if request.is_ajax():\r\n return JsonResponse({'total_dislikes': post.dislikes.count(),\r\n 'total_likes': post.likes.count(),\r\n 'disliked': disliked})",
"def test_disliking_non_existent_comment(self):\n self.non_existing(self.dislike_url(4))",
"def unlike(self, request, pk=None):\n\n obj = self.get_object()\n like_func.remove_like(obj, request.user)\n return Response(status=status.HTTP_202_ACCEPTED)",
"def test_unlike_activity_get_other_likes(self):\n from .mockers import user_status_context\n from .mockers import subscribe_context, create_context\n username = 'messi'\n username_not_me = 'xavi'\n self.create_user(username)\n self.create_user(username_not_me)\n self.create_context(create_context)\n self.admin_subscribe_user_to_context(username, subscribe_context)\n self.admin_subscribe_user_to_context(username_not_me, subscribe_context)\n res = self.create_activity(username, user_status_context)\n activity_id = res.json['id']\n res = self.testapp.post('/activities/%s/likes' % activity_id, '', oauth2Header(username_not_me), status=201)\n res = self.testapp.post('/activities/%s/likes' % activity_id, '', oauth2Header(username), status=201)\n res = self.testapp.delete('/activities/%s/likes/%s' % (activity_id, username_not_me), '', oauth2Header(username_not_me), status=204)\n\n activity = self.testapp.get('/activities/%s' % activity_id, '', oauth2Header(username), status=200)\n\n self.assertEqual(activity.json['likes'][0]['username'], username)\n self.assertEqual(activity.json['liked'], True)\n self.assertEqual(activity.json['likesCount'], 1)",
"def is_disliked_by(self, user):\n return user.disliked_articles.filter(pk=self.pk).exists()",
"def like_unlike_comment(self, pk='1', action='like'):\n return self.client.post(reverse('posts:like_unlike_comment',\n kwargs={\n 'pk': pk,\n 'action': action\n }))",
"def unlike_comment_API(id):\n\n count = float(-1)\n redis_obj.zincrby('add_like', id, count)\n\n \"\"\" Invalidating cache \"\"\"\n redis_obj.delete('leaderboard-key')\n return jsonify(username=g.user[1], Message=\"Success! Message unliked successfully. \", Status_code=status.HTTP_200_OK)",
"def get_list_of_dislikers_message(self, mid):\n cursor = self.get_cursor()\n query = 'SELECT users.uid,users.first_name, users.last_name, users.username, ' \\\n 'vote.voted_on ' \\\n 'FROM users INNER JOIN vote ON users.uid = vote.uid AND vote.upvote = FALSE ' \\\n 'INNER JOIN messages ON messages.mid = vote.mid AND messages.mid = %s'\n cursor.execute(query, (mid,))\n return cursor.fetchall()",
"def test_a_user_can_dislike_an_article(self):\n article = self.create_article()\n\n slug = article.data['data']['slug']\n dislike = self.client.post('/api/articles/{}/dislike/'.format(slug),\n HTTP_AUTHORIZATION='Bearer ' +\n self.token,\n format='json')\n\n self.assertEqual(dislike.status_code, 200)",
"def test_unauthorized_user_like_field(self):\n response = self.client.get(reverse('lessons-detail', args=(1,)))\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertNotIn('like', response.data)",
"def unlike():\n if CURR_USER_KEY in session:\n cafe_id = int(request.json[\"cafe_id\"])\n user_id = g.user.id\n Like.query.filter_by(cafe_id=cafe_id, user_id=user_id).delete()\n db.session.commit()\n\n return jsonify({\"unliked\": cafe_id})\n return jsonify({\"error\": \"Not logged in\"})",
"def _remove_dislikes(bad_movies, good_movies_vec, rejected_list=[], harshness=1):\n bad_vec = _aggregate_vectors(bad_movies, rejected_list)\n bad_vec = bad_vec / harshness\n return good_movies_vec - bad_vec",
"def likes(self):\n return self.get_queryset().filter(vote__gt=0)",
"def ListLikes(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')",
"def unlike(self, request, pk=None):\n\n user_wall_post = self.get_object()\n user_wall_post.likes.remove(self.request.user)\n return Response(status=201)",
"def test_like_unlike_works_without_error(self):\n create_response = self.client.post(reverse('posts:comment_create'),\n data={\n 'post': self.post.id,\n 'user': self.user.id,\n 'comment_description':\n 'This is a test_comment'\n }, format='json')\n self.assertEqual(create_response.status_code, status.HTTP_201_CREATED)\n # initial stars_count is zero, so when liked must increase by 1\n like_response = self.like_unlike_comment()\n self.assertEqual(like_response.status_code, status.HTTP_200_OK)\n self.assertEqual(like_response.data['stars_count'], 1)\n like_again = self.like_unlike_comment()\n self.assertEqual(like_again.status_code, status.HTTP_200_OK)\n self.assertEqual(like_again.data['stars_count'], 2)\n # current likes/stars count is 2 so if unliked should become 1\n unlike_comment_response = self.like_unlike_comment(pk='1',\n action='unlike')\n self.assertEqual(unlike_comment_response.status_code,\n status.HTTP_200_OK)\n self.assertEqual(unlike_comment_response.data['stars_count'], 1)\n # current likes/stars count is 1 so if unliked should become 0\n unlike_comment_response = self.like_unlike_comment(pk='1',\n action='unlike')\n self.assertEqual(unlike_comment_response.status_code,\n status.HTTP_200_OK)\n self.assertEqual(unlike_comment_response.data['stars_count'], 0)\n # current likes/stars count is 0 so if unliked should remain 0\n unlike_comment_response = self.like_unlike_comment(pk='1',\n action='unlike')\n self.assertEqual(unlike_comment_response.status_code,\n status.HTTP_200_OK)\n self.assertEqual(unlike_comment_response.data['stars_count'], 0)",
"def test_unlike_topic_viewset(self):\n\n topic = TopicFactory(author=self.user)\n self.client.post(reverse('api:topics-like', kwargs={'topic_id': topic.id}))\n response = self.client.post(reverse('api:topics-unlike', kwargs={'topic_id': topic.id}))\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n obj_type = ContentType.objects.get_for_model(topic)\n likes = Like.objects.filter(\n content_type=obj_type, object_id=topic.id, user=self.user)\n self.assertFalse(likes.exists())",
"def get(self, request, *args, **kwargs):\n return super(DislikedSongsView, self).get(request, query=app.DISLIKED_SONGS, *args, **kwargs)",
"def test_unlike(self):\n\n message = Message(text=\"hello world\", user_id=self.testuser2.id)\n \n db.session.add(message)\n db.session.commit()\n\n like = Likes(message_id=message.id, user_id=self.testuser.id)\n \n db.session.add(like)\n db.session.commit()\n \n message_id = message.id\n\n with self.client as c:\n with c.session_transaction() as session:\n session[CURR_USER_KEY] = self.testuser.id\n \n response = c.post(f\"/messages/{message_id}/like\", follow_redirects=True)\n \n self.assertEqual(response.status_code, 200)\n\n likes = Likes.query.filter(Likes.message_id==message_id).all()\n self.assertEqual(len(likes), 0)",
"def dislike_potential_friend(other_id):\n\n if not g.user:\n return _get_json_message(INVALID_CREDENTIALS_MSG, INVALID_CREDENTIALS_STATUS_CODE)\n\n user_options = User.get_list_of_potential_friends(g.user)\n other_user = User.query.get_or_404(other_id)\n\n if other_user not in user_options:\n return _get_json_message(\"user-not-potential-friend\", INVALID_CREDENTIALS_STATUS_CODE)\n\n g.user.dislikes.append(other_user)\n db.session.commit()\n\n return jsonify(status=\"user-disliked\")"
] | [
"0.73568493",
"0.6755147",
"0.6446478",
"0.626404",
"0.6240039",
"0.617614",
"0.6168667",
"0.6094948",
"0.6049946",
"0.601232",
"0.59809875",
"0.5943443",
"0.5925991",
"0.59026235",
"0.58979905",
"0.5856151",
"0.5781004",
"0.57581604",
"0.5747891",
"0.5728713",
"0.56589115",
"0.5638082",
"0.5579948",
"0.55401915",
"0.54763037",
"0.5456049",
"0.54541034",
"0.54471505",
"0.5442105",
"0.5411539"
] | 0.761897 | 0 |
Return the name used in the html form for the given form instance and field name. | def get_html_name(form, name):
return form.add_prefix(name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_field_name(self, instance):\n fields = getattr(instance, \"_fields\")\n return fields[self.id]",
"def form_name(self):\n \n # Unpack\n request = self.request\n context = request.context\n \n # Prepare\n first_btn = len(self.buttons) and self.buttons[0]\n btn_is_create = first_btn and first_btn.lower() == u'create'\n action = u'Create new' if btn_is_create else u'Edit'\n name = self.__class__.__name__\n \n # Try to use the ``request.context``.\n if context:\n name = getattr(context, 'name', context.__name__)\n \n # Return concatenated, e.g. `Edit Foo`.\n return u'{0} {1}'.format(action, name)",
"def NAME(self) -> str:\n return self._field_name",
"def name_field(self):\r\n return 'name'",
"def getname(self):\n if self.instance is not None:\n return '%s_%s' % (self.name,self.instance)\n else:\n return self.name",
"def get_field_name(self):\n if self.language is None:\n lang = \"i18n\"\n else:\n lang = self.get_language()\n\n return build_localized_fieldname(self.original_name, lang)",
"def name(self):\n if self.table:\n return \"{}.{}\".format(self.table, self.field_name)\n return self.field_name",
"def fieldName(self):\n return self._field.name",
"def get_index_fieldname(self, f):\n return f.name",
"def get_name(self, field_name='NAME'):\n return self.get_default(field_name)",
"def varname(self) -> str:\n var = getattr(self.parent, \"varname\", None) if self.parent else None\n if var:\n return f\"{var}.{self.name}\"\n else:\n if self.name is None:\n raise SerdeError(\"Field name is None.\")\n return self.name",
"def get_field_by_name(form, field_name):\n if field_name in form.fields:\n return form[field_name]\n return None",
"def field_label(field_name, bushfire=None):\r\n field_name = FIELD_MAPPING.get(field_name) or field_name\r\n if bushfire:\r\n try:\r\n return bushfire._meta.get_field(field_name).verbose_name\r\n except:\r\n return field_name\r\n else:\r\n return field_name",
"def get_field_class_name(field):\n return field.capitalize() + \"Field\"",
"def _field_name(self) -> str:\n name = self._resolve_field_name()\n if name is None:\n # pylint: disable=consider-using-f-string\n raise FieldNameError(\n \"No field name found among: explicit name = {}, inferred name = {}\".format(\n self.__name_explicit, self.__name_contextual\n )\n )\n return name",
"def label_for_field(instance, arg):\n if isinstance(instance, QuerySet):\n instance = instance.model\n try:\n return instance._meta.get_field(arg).verbose_name\n except FieldDoesNotExist:\n return ''",
"def name(self):\n\n return self._get_field(\"name\")",
"def field_name(self, name):\n\t\tlogging.info(\"Getting the field name \" + str(name))\n\t\ttry:\n\t\t\tfieldName = self.fields.keys()[self.fields.values().index(name)]\n\t\t\tlogging.info(\"The field name for \" + str(name) + \" is \" + str(fieldName))\n\t\t\treturn fieldName\n\t\texcept:\n\t\t\tlogging.error(str(name)+ \" Field Name was not found\")\n\t\t\treturn False",
"def getRegisterNameFromFieldName(self, name):\n pass",
"def namehack(field):\n if field.endswith((\"attribute\", \"views\")):\n return field + \"__name\"\n else:\n return field",
"def name(self, value):\n\t\tself.form.setObjectName(value)",
"def field_names(self):\n\n entry_time_name = forms_builder.forms.models.FormEntry._meta.get_field('entry_time').verbose_name.title()\n document_title_name = Document._meta.get_field('name').verbose_name.title()\n document_url_name = Document._meta.get_field('url').verbose_name.title()\n\n form = self.form.all()[0]\n return ['user'] \\\n + [document_title_name, document_url_name] \\\n + [f.label\n for f in form.fields.all()] \\\n + [entry_time_name]",
"def get_name(self, ):\n return self.get_parameter('name')",
"def get_name(self):\n return self.options['name']",
"def name ( self ) :\n return self.__name if self.__name else ''",
"def name(self, name):\n return self.name",
"def _get_name(self):\n return self.__name",
"def _get_name(self):\n return self.__name",
"def _get_name(self):\n return self.__name",
"def _get_name(self):\n return self.__name"
] | [
"0.7348436",
"0.71176386",
"0.6880881",
"0.685868",
"0.6820191",
"0.6801114",
"0.6696409",
"0.66775125",
"0.65721667",
"0.6490497",
"0.6363262",
"0.6351724",
"0.6348922",
"0.6331888",
"0.6311538",
"0.63034886",
"0.6261783",
"0.62236905",
"0.62060416",
"0.61982995",
"0.6181344",
"0.6154327",
"0.61292547",
"0.6053802",
"0.6027959",
"0.5986216",
"0.5966243",
"0.5966243",
"0.5966243",
"0.5966243"
] | 0.7297755 | 1 |
For the given named field, get the attrs as determined by the field and widget settings. | def get_format_attrs(self, name, field, alt_field_info={}):
# important_props = ('initial', 'autofocus', 'widget')
if name in alt_field_info:
field = deepcopy(field)
for prop, value in alt_field_info[name].items():
setattr(field, prop, value)
initial = field.initial
initial = initial() if callable(initial) else initial
attrs, result = {}, []
if initial and not isinstance(field.widget, Textarea):
attrs['value'] = str(initial)
data_val = self.form.data.get(get_html_name(self.form, name), None)
if data_val not in ('', None):
attrs['value'] = data_val
attrs.update(field.widget_attrs(field.widget))
result = ''.join(f'{key}="{val}" ' for key, val in attrs.items())
if getattr(field, 'autofocus', None):
result += 'autofocus '
if issubclass(self.form.__class__, FormOverrideMixIn):
# TODO: Expand for actual output when using FormOverrideMixIn, or a sub-class of it.
result += '%(attrs)s' # content '%(attrs)s'
else:
result = '%(attrs)s' + result # '%(attrs)s' content
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_field_attributes(self, fieldname):\n return self.read_field(fieldname).attributes",
"def get_field_attr(name):\n # de variant met een repeating group (entiteit, dataitem) levert hier nog een probleem op.\n # is dat omdat er twee entiteiten in 1 scherm staan?\n fields = []\n opts = my.rectypes[name]._meta\n for x in opts.get_fields(): # fields:\n fldname = x.name\n fldtype = x.get_internal_type()\n if fldname == 'id' or fldtype in ('ForeignKey', 'ManyToManyField'):\n # if fldname == 'id' or any((x.many2one, x.many2many, x.one2many))\n continue\n try:\n length = x.max_length\n except AttributeError:\n length = -1\n fields.append((fldname, fldtype[:-5], length))\n return fields",
"def addattrs(field, my_attrs):\n my_attrs = my_attrs.split(',')\n my_attrs = dict([attr.split('=') for attr in my_attrs])\n return field.as_widget(attrs=my_attrs)",
"def __getattr__(self, name):\n if not name in self._attrs.iterkeys():\n raise AttributeError(name)\n return self._attrs[name]",
"def model_field_attr(model, field, attr):\n fields = {field.name: field for field in model._meta.fields}\n return getattr(fields[field], attr)",
"def get_field(self, name):\n for field_name, field in self._all_fields.iteritems():\n if name == self._sanitize_field_name(field_name):\n return field",
"def get_field(self, field):\n return self.extra_fields[field]",
"def get_field(self, field_name):\n for attr_name, field in self:\n if field_name == attr_name:\n return field\n\n raise errors.FieldNotFound('Field not found', field_name)",
"def _attrs(self):\n for field in self.model._meta.get_fields():\n if isinstance(field, (models.OneToOneField, models.ManyToOneRel)):\n # Skip non-field attributes\n continue\n if field is self._geom_field:\n # Skip the geometry field, which is not an attribute\n continue\n yield field",
"def getAttr(self, name, *args):\n if len(args) > 0:\n return self.attrs.get( name, args[0] )\n return self.attrs[name]",
"def get_switched_form_field_attrs(self, prefix, input_type, name):\n attributes = {'class': 'switched', 'data-switch-on': prefix + 'field'}\n attributes['data-' + prefix + 'field-' + input_type] = name\n return attributes",
"def get_attribute(self, name):\n\n pass",
"def get_attrs_with_name(self, name):\n return self.get_matches([lambda attr: attr.name == name])",
"def get_field(self, field_name):\n all_fields = self._fields.items(self._fields.root)\n print(\"all_fields\", all_fields)\n for name, field in all_fields:\n print(name, field_name)\n if name == field_name:\n return field",
"def __get_attr_helper(self, object, field, default=None):\n # TODO: Make PR to fix this ^ bug\n if hasattr(object, field):\n return getattr(object, field)\n\n return default",
"def set_field_widget_attributes(field, widget_attributes):\n for key, value in widget_attributes.items():\n field.widget.attrs[key] = value\n if key == \"class\":\n # djangular overwrites widget classes using the built-in \"widget_css_classes\" attribute\n # so be sure to re-set it here\n field.widget_css_classes = value",
"def get_attribute_by_name(self, name):\n if name in self._attributes:\n return self._attributes[name]",
"def date_attrs(name):\n attrs = battrs(name)\n attrs.update({'class': 'form-control datepicker'})\n return attrs",
"def map_field_name_to_attribute() -> typing.Dict:\n return {\n \"tag\": \"tag\",\n \"contact\": \"contact\",\n }",
"def get_attrs_field_names(env, arch, model, editable):\n VIEW_TYPES = {item[0] for item in type(env['ir.ui.view']).type.selection}\n symbols = _get_attrs_symbols() | {None}\n result = []\n\n def get_name(node):\n \"\"\" return the name from an AST node, or None \"\"\"\n if isinstance(node, ast.Name):\n return node.id\n\n def get_subname(get, node):\n \"\"\" return the subfield name from an AST node, or None \"\"\"\n if isinstance(node, ast.Attribute) and get(node.value) == 'parent':\n return node.attr\n\n def process_expr(expr, get, key, val):\n \"\"\" parse `expr` and collect triples \"\"\"\n for node in ast.walk(ast.parse(expr.strip(), mode='eval')):\n name = get(node)\n if name not in symbols:\n result.append((name, key, val))\n\n def process_attrs(expr, get, key, val):\n \"\"\" parse `expr` and collect field names in lhs of conditions. \"\"\"\n for domain in safe_eval(expr).values():\n if not isinstance(domain, list):\n continue\n for arg in domain:\n if isinstance(arg, (tuple, list)):\n process_expr(str(arg[0]), get, key, expr)\n\n def process(node, model, editable, get=get_name):\n \"\"\" traverse `node` and collect triples \"\"\"\n if node.tag in VIEW_TYPES:\n # determine whether this view is editable\n editable = editable and _view_is_editable(node)\n elif node.tag in ('field', 'groupby'):\n # determine whether the field is editable\n field = model._fields.get(node.get('name'))\n if field:\n editable = editable and field_is_editable(field, node)\n\n for key, val in node.items():\n if not val:\n continue\n if key in ATTRS_WITH_FIELD_NAMES:\n process_expr(val, get, key, val)\n elif key == 'attrs':\n process_attrs(val, get, key, val)\n\n if node.tag in ('field', 'groupby') and field and field.relational:\n if editable and not node.get('domain'):\n domain = field._description_domain(env)\n # process the field's domain as if it was in the view\n if isinstance(domain, str):\n process_expr(domain, get, 'domain', domain)\n # retrieve subfields of 'parent'\n model = env[field.comodel_name]\n get = partial(get_subname, get)\n\n for child in node:\n if node.tag == 'search' and child.tag == 'searchpanel':\n # searchpanel part has to be validated independently\n continue\n process(child, model, editable, get)\n\n process(arch, model, editable)\n return result",
"def getattribute(self, name):\n return self.attributes[name]",
"def _get_field(self, field_name: str):\n backcompat_prefix = \"extra__grpc__\"\n if field_name.startswith(\"extra__\"):\n raise ValueError(\n f\"Got prefixed name {field_name}; please remove the '{backcompat_prefix}' prefix \"\n \"when using this method.\"\n )\n if field_name in self.extras:\n return self.extras[field_name]\n prefixed_name = f\"{backcompat_prefix}{field_name}\"\n if prefixed_name in self.extras:\n return self.extras[prefixed_name]\n raise KeyError(f\"Param {field_name} not found in extra dict\")",
"def _iter_attrs_for_field_type(cls, field_type):\n return six.iterkeys(cls._get_defaults_for_field_type(field_type))",
"def _iter_attrs_for_field_type(cls, field_type):\n return six.iterkeys(cls._get_defaults_for_field_type(field_type))",
"def get_attr(self, name: str):\n return self.call(name)",
"def update_field_widget_attributes(field, widget_attributes):\n for key, value in widget_attributes.items():\n try:\n current_attributes = field.widget.attrs[key]\n field.widget.attrs[key] = \"%s %s\" % (current_attributes, value)\n except KeyError:\n field.widget.attrs[key] = value\n if key == \"class\":\n # djangular overwrites widget classes using the built-in \"widget_css_classes\" attribute\n # so be sure to re-set it here\n try:\n current_widget_css_classes = field.widget_css_classes\n field.widget_css_classes = \"%s %s\" % (current_widget_css_classes, value)\n except AttributeError:\n field.widget_css_classes = value",
"def field_by_name(self, name):\r\n return self._by_name[name]",
"def get_field(self, field):\n try:\n values = getattr(self, field)\n return values\n except AttributeError:\n return {\n \"message\": \"Ensure the field passed is valid.\",\n \"help\": \"The field should be an attribute of the object.\"\n }",
"def get_attr(self, name, varname=None):\n if varname is None:\n return self.root_group.getncattr(name)\n else:\n return self.root_group[varname].getncattr(name)",
"def widget_attrs(self, widget):\n\n attrs = super(RelateField, self).widget_attrs(widget)\n\n attrs.update({'content_type': self.content_types})\n\n return attrs"
] | [
"0.66450113",
"0.59228253",
"0.5825731",
"0.5723031",
"0.56653965",
"0.5607219",
"0.5606834",
"0.56044406",
"0.5507906",
"0.54786855",
"0.54504424",
"0.54347646",
"0.5379743",
"0.5346478",
"0.5339721",
"0.53374994",
"0.53265065",
"0.5322189",
"0.53207207",
"0.531892",
"0.52985275",
"0.52819633",
"0.52429736",
"0.52429736",
"0.52291644",
"0.51955706",
"0.51879764",
"0.51788795",
"0.51770514",
"0.5173509"
] | 0.64204663 | 1 |
Used for constructing expected format for field & top errors for FormFieldsetMixIn or default html. | def error_format(self, as_type, error, **kwargs):
error = str(error)
multi_field_row, txt, attr = None, '', ''
errors_own_row = kwargs.get('errors_on_separate_row', None)
errors_own_row = True if as_type == 'as_p' and errors_own_row is None else errors_own_row
context = 'default_row' if errors_own_row else 'default'
if issubclass(self.form.__class__, FormFieldsetMixIn):
context = 'special'
multi_field_row = kwargs.get('multi_field_row', False)
if errors_own_row:
context = 'row_multi' if multi_field_row else 'row'
tag = kwargs.get('col_tag', 'span') if multi_field_row else kwargs.get('single_col_tag', '')
if as_type in ('as_table', 'table'):
tag = 'td'
colspan = 2 if multi_field_row else 2 * kwargs.get('col_count', 1)
attr += ' colspan="{}"'.format(colspan)
txt = error if not tag else self.form._html_tag(tag, error, attr) # used if as_type not in format_error
format_error = {
'as_table': {
'default': '%s',
'default_row': '<tr><td colspan="2">%s</td></tr>',
'normal_row': '<tr%(html_class_attr)s><th>%(label)s</th><td>%(errors)s%(field)s%(help_text)s</td></tr>',
'special': '%s',
'row': '<tr><td%s>%s</td></tr>',
'row_multi': '<td%s>%s</td>',
'special_col_data': '%(errors)s%(field)s%(help_text)s',
},
'as_ul': {
'default': '%s',
'default_row': '<li>%s</li>',
'normal_row': '<li%(html_class_attr)s>%(errors)s%(label)s %(field)s%(help_text)s</li>',
'special': '%s',
'row': '<li>%s</li>',
'row_multi': '<span>%s</span>',
'special_col_data': '%(errors)s%(label)s %(field)s%(help_text)s',
},
'as_p': {
'default': '%s',
'default_row': '%s', # errors_on_separate_row=True is the default only for 'as_p'.
'normal_row': '<p%(html_class_attr)s>%(label)s %(field)s%(help_text)s</p>',
'special': '%s',
'row': '<p>%s</p>',
'row_multi': '<span>%s</span>',
'special_col_data': '%(label)s %(field)s%(help_text)s',
},
'as_fieldset': {
'default': '',
'default_row': '',
'normal_row': '',
'special': '%s',
'row': '<p>%s</p>',
'row_multi': '<span>%s</span>',
'special_col_data': '%(errors)s%(label)s %(field)s%(help_text)s',
},
}
if as_type in format_error:
error = (attr, error) if attr else error
txt = format_error[as_type][context] % error
if errors_own_row and not multi_field_row:
txt += '\n'
return txt | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_expected_format(self, setup):\n form = setup.pop('form', self.form)\n as_type = setup['as_type']\n setup.update(attrs='')\n alt_field_info = {}\n if issubclass(self.form_class, FormOverrideMixIn):\n size_default = form.get_overrides().get('_default_', {}).get('size', None)\n override_attrs = '' if not size_default else f'size=\"{size_default}\" '\n setup.update(attrs=override_attrs)\n alt_field_info = self.form.get_alt_field_info()\n if issubclass(self.form_class, FocusMixIn): # has method: assign_focus_field\n focused = getattr(self.form, 'given_focus', None) or getattr(self.form, 'named_focus', None)\n if not focused:\n ls = [name for name, field in self.form.fields.items()\n if not field.disabled and not isinstance(field.widget, (HiddenInput, MultipleHiddenInput))]\n focused = ls[0] if ls else None\n if focused: # Using alt_field_info to track assigning focus here, but 'autofocus' is not a field property.\n alt_field_info[focused] = alt_field_info.get(focused, {})\n alt_field_info[focused].update({'autofocus': True})\n field_formats = FIELD_FORMATS.copy()\n if issubclass(self.form_class, ComputedUsernameMixIn):\n name_for_email = form.name_for_email or form._meta.model.get_email_field() or 'email'\n name_for_user = form.name_for_user or form._meta.model.USERNAME_FIELD or 'username'\n if 'email' in field_formats:\n field_formats[name_for_email] = field_formats.pop('email')\n if 'username' in field_formats:\n field_formats[name_for_user] = field_formats.pop('username')\n order = ['first_name', 'last_name', name_for_email, name_for_user, 'password1', 'password2', ]\n form.order_fields(order)\n form_list, hidden_list = [], []\n top_errors = form.non_field_errors().copy() # If data not submitted, this will trigger full_clean method.\n if issubclass(self.form_class, FormFieldsetMixIn):\n setup['error_kwargs'] = self.make_error_kwargs(setup)\n if top_errors:\n html_args = setup['error_kwargs']['html_args']\n col_attr = ' id=\"top_errors\"'\n row_attr = ''\n data = ' '.join(top_errors)\n form_col_count = setup['error_kwargs']['form_col_count']\n error_row = form.make_headless_row(html_args, data, form_col_count, col_attr, row_attr)\n form_list.append(error_row)\n elif top_errors:\n error_row = self.error_format(as_type, top_errors, **setup.get('error_kwargs', {}))\n form_list.append(error_row)\n\n for name, field in form.fields.items():\n if isinstance(field.widget, (HiddenInput, MultipleHiddenInput, )):\n hide_re = DEFAULT_RE.copy()\n hide_re.update({'name': name, 'input_type': 'hidden', 'end_tag': ''})\n hide_re['attrs'] = f'value=\"{field.initial}\" '\n txt = BASE_INPUT % hide_re\n hidden_list.append(txt) # TODO: Account for hidden field errors being added to top errors.\n continue\n cur_replace = DEFAULT_RE.copy()\n cur_replace.update({'name': name, 'pretty': field.label or pretty_name(name)})\n cur_replace['required'] = REQUIRED if field.required else ''\n if field.disabled:\n cur_replace['required'] += 'disabled '\n cur_replace['attrs'] = self.get_format_attrs(name, field, alt_field_info)\n if isinstance(field, EmailField) and name not in field_formats:\n cur_replace['input_type'] = 'email'\n elif isinstance(field.widget, Textarea):\n cur_replace['initial'] = getattr(field, 'initial', None) or ''\n attrs = ''\n cols = field.widget.attrs.get('cols', None)\n rows = field.widget.attrs.get('rows', None)\n if cols:\n attrs += f'cols=\"{cols}\" '\n if rows:\n attrs += f'rows=\"{rows}\" '\n cur_replace['attrs'] = attrs\n field_formats[name] = AREA_TXT\n elif isinstance(field.widget, (CheckboxSelectMultiple, RadioSelect)):\n input_type = 'radio' if isinstance(field.widget, RadioSelect) else 'checkbox'\n required = REQUIRED if field.required else ''\n if isinstance(field.widget, CheckboxSelectMultiple):\n required = ''\n options_re = {'name': name, 'required': required, 'input_type': input_type}\n option_list = []\n for num, each in enumerate(field.choices):\n val, display = each\n opt_replace = options_re.copy()\n opt_replace.update({'num': str(num), 'val': str(val), 'display_choice': str(display)})\n option = OTHER_OPTION_TXT % opt_replace\n option_list.append(option)\n cur_replace['options'] = ''.join(option_list)\n field_formats[name] = RADIO_TXT if isinstance(field.widget, RadioSelect) else CHECK_TXT\n elif isinstance(field, BooleanField) or isinstance(field.widget, CheckboxInput):\n cur_replace['input_type'] = 'checkbox'\n cur_replace['attrs'] = ''\n if field.initial or form.data.get(get_html_name(form, name), None):\n cur_replace['last'] = ' checked'\n elif isinstance(field.widget, (Select, SelectMultiple)):\n option_list = []\n for num, each in enumerate(field.choices):\n val, display = each\n option = OPTION_TXT % {'val': str(val), 'display_choice': str(display)}\n option_list.append(option)\n cur_replace['options'] = ''.join(option_list)\n cur_replace['multiple'] = MULTIPLE\n if not isinstance(field.widget, SelectMultiple):\n cur_replace['multiple'] = ''\n cur_replace['required'] = ''\n field_formats[name] = SELECT_TXT\n field_error = form.errors.get(name, None)\n if field_error:\n error_string = self.error_format(as_type, field_error, **setup.get('error_kwargs', {}))\n if as_type == 'as_table':\n cur_replace['label_end'] += error_string\n elif as_type in ('as_ul', 'as_fieldset'):\n cur_replace['start_tag'] += error_string\n elif as_type == 'as_p':\n cur_replace['start_tag'] = error_string + cur_replace['start_tag']\n else:\n cur_replace['error'] = error_string\n txt = field_formats.get(name, DEFAULT_TXT) % cur_replace\n form_list.append(txt)\n str_hidden = ''.join(hidden_list)\n if len(form_list) > 0:\n last_row = form_list[-1]\n default_re = DEFAULT_RE.copy()\n default_re.update({'attrs': '%(attrs)s', 'end_tag': str_hidden + '%(end_tag)s'})\n form_list[-1] = last_row % default_re\n else:\n form_list.append(str_hidden)\n expected = ''.join(form_list) % setup\n return expected.strip()",
"def test_top_errors_at_top_html(self):\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form._errors = ErrorDict()\n self.form.cleaned_data = {}\n test_error = \"This non-field error is placed here just to pick on you. \"\n self.form.add_error(None, test_error)\n self.form.make_fieldsets()\n row_tag = 'p'\n html_output = self.form._html_output_new( # replicates as_p()\n row_tag=row_tag,\n col_head_tag=None,\n col_tag='span',\n single_col_tag='',\n col_head_data='',\n col_data='%(label)s %(field)s%(help_text)s',\n help_text_br=False,\n errors_on_separate_row=True,\n as_type='p'\n )\n html_rows = html_output.split('\\n')\n actual_top_html = html_rows[0]\n expected_top_html = self.form._html_tag(row_tag, test_error, ' id=\"top_errors\"')\n\n self.assertIn(NON_FIELD_ERRORS, self.form._errors)\n self.assertEqual(expected_top_html, actual_top_html)\n\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def display_errors(self):\r\n\r\n def format_name(field_name):\r\n \"\"\"Formats field names for error display\"\"\"\r\n if field_name == \"celebration_tier\":\r\n return \"{wLargesse{n\"\r\n return \"{w%s{n\" % field_name.capitalize()\r\n\r\n msg = \"Please correct the following errors:\\n\"\r\n msg += \"\\n\".join(\r\n \"%s: {r%s{n\" % (format_name(field), \", \".join(errs))\r\n for field, errs in self.errors.items()\r\n )\r\n return msg",
"def make_error_kwargs(self, setup):\n as_type = setup['as_type']\n kwargs = setup.get('error_kwargs', {})\n kwargs.setdefault('col_tag', 'td' if as_type in ('as_table', 'table') else 'span')\n kwargs.setdefault('single_col_tag', 'td' if as_type in ('as_table', 'table') else '')\n kwargs.setdefault('col_head_tag', 'th' if as_type in ('as_table', 'table') else None)\n row_tag = 'tr' if as_type in ('as_table', 'table') else 'li' if as_type in ('as_ul', 'ul') else 'p'\n kwargs.setdefault('row_tag', row_tag)\n guess_col_count = 4 if as_type in ('as_table', 'table') else 2\n kwargs.setdefault('form_col_count', setup.get('form_col_count', guess_col_count))\n if as_type in ('as_fieldset', 'fieldset'):\n kwargs['form_col_count'] = 1\n html_args = [kwargs[key] for key in ('row_tag', 'col_head_tag', 'col_tag', 'single_col_tag')]\n html_args.extend((as_type, as_type == 'fieldset', ))\n kwargs['html_args'] = html_args\n return kwargs",
"def setup_error_data(self, field_setup, error_names, is_table=False, col_tag='span', single_col_tag=''):\n backup_fieldset_fields = [\n ('first', 'second'),\n 'billing_address_1',\n ('billing_city', 'billing_country_area', 'billing_postcode'),\n 'last',\n ]\n field_setup = field_setup or backup_fieldset_fields\n error_names = set(error_names or flatten(field_setup))\n col_count = max([1 if isinstance(ea, str) else len(ea) for ea in field_setup])\n error_txt = \"This is a {} test error. \"\n row_info = []\n for row in field_setup:\n if isinstance(row, str):\n row = [row]\n multi_col_row = len(row) > 1\n if is_table:\n cur_tag = 'td'\n error_settings = (cur_tag, multi_col_row, col_count, True, True)\n attr = ' colspan=\"{}\"'.format(2 if multi_col_row else 2 * col_count)\n else:\n cur_tag = col_tag if multi_col_row else single_col_tag\n error_settings = (cur_tag, multi_col_row, col_count, False, False)\n attr = ''\n error_list = [error_txt.format(name) if name in error_names else '' for name in row]\n columns = [{'errors': ea} for ea in error_list]\n expected = [err if not cur_tag else self.form._html_tag(cur_tag, err, attr) for err in error_list]\n if all(ea == '' for ea in error_list):\n expected = []\n actual = self.form.get_error_data(columns, error_settings)\n row_summary = {'expected': expected, 'actual': actual, 'field_names': row, 'settings': error_settings}\n row_summary['columns'] = columns\n row_info.append(row_summary)\n return row_info",
"def _render_errors(field):\n template = '{0}/layout/field_errors.html'.format(getattr(settings, 'CRISPY_TEMPLATE_PACK', 'bootstrap3'))\n return render_to_string(template, {\n 'field': field,\n 'form_show_errors': True,\n })",
"def multi_col_error_format(self, as_type, errors, **kwargs):\n error_data = [self.error_format(as_type, error, **kwargs) for error in errors]\n row_tag = 'tr' if as_type == 'as_table' else 'li' if as_type == 'ul' else 'p'\n row_tag = kwargs.get('row_tag', row_tag)\n error_row = self.form._html_tag(row_tag, ' '.join(error_data))\n return error_row",
"def as_bootstrap(self):\n top_errors = self.non_field_errors() # Errors that should be displayed above all fields.\n output, hidden_fields = [], []\n normal_row = u'<div%(html_class_attr)s>%(label)s<div class=\"controls\">%(field)s%(help_text)s</div>%(errors)s</div>'\n boolean_row = u'<div%(html_class_attr)s><div class=\"controls\">%(label_and_field)s%(help_text)s</div>%(errors)s</div>'\n error_row = u'<div class=\"alert alert-error\">%s</div>'\n row_ender = u'</div>'\n help_text_html = u'<span class=\"help-inline\">%s</span>'\n errors_on_separate_row = False\n\n for name, field in self.fields.items():\n html_class_attr = ''\n bf = self[name]\n is_boolean = isinstance(field, forms.fields.BooleanField)\n bf_errors = self.error_class([conditional_escape(error) for error in bf.errors]) # Escape and cache in local variable.\n if bf.is_hidden:\n if bf_errors:\n top_errors.extend([u'(Hidden field %s) %s' % (name, force_unicode(e)) for e in bf_errors])\n hidden_fields.append(unicode(bf))\n else:\n # Create a 'class=\"...\"' atribute if the row should have any\n # CSS classes applied.\n css_classes = bf.css_classes(extra_classes='control-group')\n if css_classes:\n html_class_attr = ' class=\"%s\"' % css_classes\n\n if errors_on_separate_row and bf_errors:\n output.append(error_row % force_unicode(bf_errors))\n\n if bf.label:\n label = conditional_escape(force_unicode(bf.label))\n if is_boolean:\n label = bf.label_tag(unicode(bf) + label,\n attrs={'class': 'checkbox'}) or ''\n else:\n # Only add the suffix if the label does not end in\n # punctuation.\n if self.label_suffix:\n if label[-1] not in ':?.!':\n label += self.label_suffix\n\n label = bf.label_tag(label,\n attrs={'class': 'control-label'}) or ''\n else:\n label = ''\n\n if field.help_text:\n help_text = help_text_html % force_unicode(field.help_text)\n else:\n help_text = u''\n\n if bf_errors:\n errors = u' '.join([error_row % force_unicode(error)\n for error in bf_errors])\n else:\n errors = u''\n\n if is_boolean:\n output.append(boolean_row % {\n 'errors': errors,\n 'label_and_field': force_unicode(label),\n 'help_text': help_text,\n 'html_class_attr': html_class_attr\n })\n else:\n output.append(normal_row % {\n 'errors': errors,\n 'label': force_unicode(label),\n 'field': unicode(bf),\n 'help_text': help_text,\n 'html_class_attr': html_class_attr\n })\n\n if top_errors:\n output.insert(0, error_row % force_unicode(top_errors))\n\n if hidden_fields: # Insert any hidden fields in the last row.\n str_hidden = u''.join(hidden_fields)\n if output:\n last_row = output[-1]\n # Chop off the trailing row_ender (e.g. '</td></tr>') and\n # insert the hidden fields.\n if not last_row.endswith(row_ender):\n # This can happen in the as_p() case (and possibly others\n # that users write): if there are only top errors, we may\n # not be able to conscript the last row for our purposes,\n # so insert a new, empty row.\n last_row = (normal_row % {'errors': '', 'label': '',\n 'field': '', 'help_text': '',\n 'html_class_attr': html_class_attr})\n output.append(last_row)\n output[-1] = last_row[:-len(row_ender)] + str_hidden + row_ender\n else:\n # If there aren't any rows in the output, just append the\n # hidden fields.\n output.append(str_hidden)\n return mark_safe(u'\\n'.join(output))",
"def after_init(self):\n if self.options.format.appended:\n self.error_format = self.options.format.appended[0]",
"def formatErrors(self):\n errorlist = []\n xepsWithErrors = sorted(\n set(self.getParseErrors() + self.getBuildErrors()),\n key=lambda x: str(x))\n if self.getErrors() or xepsWithErrors:\n if self.getErrors():\n errorlist.append(\"********** Read errors **********\")\n for error in self.getErrors():\n errorlist.append(error)\n for xep in xepsWithErrors:\n errorlist.append(\n \"********** Error report for {} **********\".format(str(xep)))\n if xep.parseErrors:\n errorlist.append(\"********** Parsing Errors **********\")\n errors = list(set(xep.parseErrors))\n for error in errors:\n errorlist.append(error)\n if xep.buildErrors:\n errorlist.append(\"********** Build Errors **********\")\n for error in xep.buildErrors:\n if len(error.splitlines()) > 4:\n error = ''.join(error.splitlines()[:4])\n errorlist.append(error)\n return '\\n'.join(errorlist)\n else:\n return None",
"def test_error_html_using_options(self):\n pass",
"def get_wtf_errors(self, wtf_errors):\n\t\tmessages = []\n\t\tmessages.append('<ol class=\"wtf-errors\">')\n\t\tfor field, errors in wtf_errors.iteritems():\n\t\t\tmessages.append(\"<li>\"+field+\": <br />\")\n\t\t\tfor error in errors:\n\t\t\t\tmessages.append(\"— \"+error+ \"<br />\")\n\t\t\tmessages.append(\"</li>\")\n\t\tmessages.append(\"</ol>\")\n\t\treturn \"\".join(messages)",
"def test_error_html_using_patch(self):\n pass",
"def formatError(self,error):\n return '<font color=\"#f00\"><b><i>%s</i></b></font><br />\\n' % error",
"def render_errors(form):\n return {\n \"form\": form\n }",
"def get_field_errors(self, bound_field):\r\n errors = super(NgFormValidationMixin, self).get_field_errors(bound_field)\r\n identifier = format_html('{0}.{1}', self.form_name, self.add_prefix(bound_field.name))\r\n errors_function = '{0}_angular_errors'.format(bound_field.field.__class__.__name__)\r\n try:\r\n errors_function = getattr(VALIDATION_MAPPING_MODULE, errors_function)\r\n potential_errors = types.MethodType(errors_function, bound_field.field)()\r\n except (TypeError, AttributeError):\r\n errors_function = getattr(VALIDATION_MAPPING_MODULE, 'Default_angular_errors')\r\n potential_errors = types.MethodType(errors_function, bound_field.field)()\r\n errors.append(SafeTuple((identifier, '$dirty', '$valid', 'valid', ''))) # for valid fields\r\n errors.extend([SafeTuple((identifier, '$dirty', pe[0], 'invalid', force_text(pe[1])))\r\n for pe in potential_errors])\r\n return errors",
"def test_prep_fields_called_html_output(self):\n pass",
"def setup_fmt(self, ctx):\n ctx.implicit_errors = False",
"def format_error(invalid, doc_type):\n # using string for checking is probably not ideal,\n # but voluptuous does not have specific sub error\n # types for these errors\n if invalid.error_message == 'extra keys not allowed':\n msg = \"Key '{}' is not allowed\".format(invalid.path[0])\n elif invalid.error_message == 'required key not provided':\n msg = \"{} '{}' is missing\".format(doc_type, invalid.path[0])\n else:\n msg = invalid.message\n return {'message': msg, 'field': str(invalid.path[0])}",
"def _exceptions_formatter(field):\n heads = ['throws']\n types = _or_types(field)\n if types:\n heads.append(types)\n tail = field.get('description', '')\n return heads, tail",
"def formatError(self, test, err):\n test.capturedOutput = output = self.buffer\n self._buf = None\n if not output:\n # Don't return None as that will prevent other\n # formatters from formatting and remove earlier formatters\n # formats, instead return the err we got\n return err\n ec, ev, tb = err\n return (ec, self.addCaptureToErr(ev, output), tb)",
"def error_message(self, error_field=None, **kwargs):\n\n if error_field:\n return \"Validation failed in Validator \\\"{}\\\" on field \\\"{}\\\"\".format(self.__class__.__name__, error_field)\n return \"Validation failed in Validator \\\"{}\\\"\".format(self.__class__.__name__)",
"def make_error( title, *args, **kwargs ):\n blocks = list()\n blocks.append( '<h1>{}</h1>'.format( title ) )\n if args:\n blocks.append( '<h4>{}</h4>'.format( args[ 0 ] ) )\n for arg in args[ 1 : ]:\n blocks.append( '<p>{}</p>'.format( arg ) )\n if kwargs:\n dl = list()\n for key, value in kwargs.items():\n dl.append( '<dt>{}</dt><dd>{}</dd>'.format( key, value ) )\n blocks.append( '<dl>\\n{}\\n</dl>'.format( '\\n'.join( dl ) ) )\n return _html.format(\n title = title,\n head = '',\n body = '\\n'.join( blocks )\n )",
"def format_errors(num_errors: int) -> str:\n if num_errors == 1:\n return ' 1 | ERROR\\n'\n return f' {num_errors:>4} | ERRORS\\n'",
"def get_field_errors(self, field):\r\n identifier = format_html('{0}.{1}', self.form_name, field.name)\r\n return self.error_class([SafeTuple((identifier, '$pristine', '$pristine', 'invalid', e))\r\n for e in self.errors.get(field.name, [])])",
"def decorate_error(self, element, error):\n if error is None:\n return element\n\n div = self.div(class_='nagare-error-input')\n div.append(element)\n\n return self.div(\n div,\n self.div(error, class_='nagare-error-message'),\n class_='nagare-error-field'\n )",
"def __str__(self):\n base_message = self.base_message.format(filename=self.yaml_file_path)\n error_message = ERROR_MESSAGE.format(key=self.key, expected=self.expected)\n return base_message + error_message",
"def _fields_as_repr(self):\n return ', '.join([\n 'required(%s)' % repr(field.name)\n if field.required else\n repr(field.name)\n for field in self.fields\n ])",
"def test_as_fieldset(self):\n # form._html_output(self, row_tag, col_head_tag, col_tag, single_col_tag, col_head_data, col_data,\n # help_text_br, errors_on_separate_row, as_type=None, strict_columns=False)\n pass",
"def set_field_attributes(fields, errors):\n for field in fields:\n field_instance = fields[field]\n widget = field_instance.widget\n if isinstance(field_instance, forms.DateField) and isinstance(widget, forms.TextInput):\n field_instance.format = '%d/%m/%Y'\n add_class_to_widget(widget, 'date')\n widget.attrs['type'] = 'text'\n elif isinstance(field_instance, forms.DateTimeField):\n field_instance.format = '%d/%m/%Y %H:%M'\n if isinstance(widget, forms.TextInput):\n add_class_to_widget(widget, 'datetime')\n elif isinstance(widget, DatetimeInput):\n add_class_to_widget(widget.widgets[0], 'date')\n elif isinstance(field_instance, forms.FloatField) and isinstance(widget, forms.TextInput):\n add_class_to_widget(widget, 'float')\n elif isinstance(field_instance, forms.IntegerField) and isinstance(widget, forms.TextInput):\n add_class_to_widget(widget, 'int')\n elif isinstance(field_instance, forms.CharField) and isinstance(widget, forms.TextInput):\n add_class_to_widget(widget, 'char')\n\n if isinstance(widget, forms.CheckboxSelectMultiple):\n add_class_to_widget(widget, 'checkbox-multiple-select')\n\n if field in errors:\n add_class_to_widget(widget, 'with_errors')\n if 'title' not in widget.attrs:\n widget.attrs['title'] = '; '.join(errors[field])\n\n add_class_to_widget(widget, 'form-control')"
] | [
"0.67704564",
"0.6728421",
"0.66664016",
"0.66186965",
"0.65348",
"0.64916956",
"0.62855846",
"0.6223227",
"0.6135441",
"0.6113346",
"0.607899",
"0.6025238",
"0.59972215",
"0.5962001",
"0.5957512",
"0.59342605",
"0.5921345",
"0.5884591",
"0.57812124",
"0.57583904",
"0.57560563",
"0.56985843",
"0.56848234",
"0.5667142",
"0.5662657",
"0.56350225",
"0.56319267",
"0.5626174",
"0.55910176",
"0.55829674"
] | 0.732005 | 0 |
Confirm the expected user_type was made, using the expected mock or actual user model setup. | def test_made_user(self, user=None):
user_attr = dict(is_active=True, is_authenticated=True, is_anonymous=False, is_staff=False, is_superuser=False)
attr_by_type = {
'anonymous': {'is_active': False, 'is_authenticated': False, 'is_anonymous': True},
'superuser': {'is_staff': True, 'is_superuser': True},
'staff': {'is_staff': True, 'is_superuser': False},
'user': {'is_staff': False, 'is_superuser': False},
'inactive': {'is_staff': False, 'is_superuser': False, 'is_active': False},
}
user_attr.update(attr_by_type.get(self.user_type, {}))
lookup_type = {'anonymous': AnonymousUser, 'superuser': MockSuperUser, 'staff': MockStaffUser, 'user': MockUser}
user_class = lookup_type.get(self.user_type, None)
if not self.mock_users and not self.user_type == 'anonymous':
user_class = get_user_model()
user = user or self.user
self.assertIsNotNone(getattr(self, 'user', None))
self.assertIsNotNone(user_class)
self.assertIsInstance(user, user_class)
for key, value in user_attr.items():
self.assertEqual(value, getattr(self.user, key, None)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_user_instance(self):\n self.assertIsInstance(self.new_user, User)",
"def test_types(self):\n user = User()\n self.assertEqual(type(user.email), str)\n self.assertEqual(type(user.password), str)\n self.assertEqual(type(user.first_name), str)\n self.assertEqual(type(user.last_name), str)",
"def test_user_creation(self):\r\n \r\n self.assertIsInstance(self.user, User)",
"def test_user_model():\n assert isinstance(user_model_instance, UserModel), \"user model not correctly instatiating\"\n # TODO add more tests here to confirm user_model_instance",
"def test_model(self):\n self.assertEqual(USER_MODEL, CustomUser)",
"def test_save_user(self):\n self.new_user.save_user()\n self.assertEqual(len(User.UserDetails), 1)",
"def test_create_user_invalid_type(self):\r\n print(\"Create user invalid type\")\r\n u_id = 3\r\n username = \"newtestuser\"\r\n password = \"password\"\r\n u_type = 5\r\n\r\n prev_noUsers = len(User.query.all())\r\n self.assertEqual(self.system.create_user(u_id, username, password, u_type), 0)\r\n curr_noUsers = len(User.query.all())\r\n self.assertEqual(prev_noUsers, curr_noUsers)",
"def test_user(self):\n return True",
"def test_instance(self):\n self.assertIsInstance(self.user_1, User)",
"def test_valid_account_create_is_a_developer(self):\n ident_choice = UserIdentificationLabel.objects.get(slug=\"ident1\")\n form_data = {\n 'invitation_code': '1234',\n 'email': '[email protected]',\n 'organization_name': 'transhealth',\n 'password1': 'BEDrocks@123',\n 'password2': 'BEDrocks@123',\n 'first_name': 'Hank',\n 'last_name': 'Flinstone',\n 'identification_choice': str(ident_choice.pk),\n }\n self.client.post(self.url, form_data, follow=True)\n up = UserProfile.objects.get(user__email='[email protected]')\n self.assertEqual(up.user_type, 'DEV')",
"def test_verify_user(self):\n user = User.query.filter_by(id=4).first()\n self.assertFalse(user.is_verified)\n self.assertFalse(user.verification_date)\n data = {'rank_id': 1}\n res = self.post(url='/verify/4', data=data, role='admin')\n self.assertEqual(res.status_code, 201)\n user = User.query.filter_by(id=4).first()\n self.assertTrue(user.is_verified)\n self.assertTrue(isinstance(user.verification_date, datetime.datetime))",
"def test_confirm_user(self):\n user = User(email=\"[email protected]\", password=\"testpassword\")\n\n self.assertFalse(user.confirmed)\n self.assertIsNone(user.confirmed_at)\n self.assertIsNotNone(user.confirmation_token)\n\n user.confirm()\n\n self.assertTrue(user.confirmed)\n self.assertIsNotNone(user.confirmed_at)\n self.assertIsNone(user.confirmation_token)",
"def test_is_instance(self):\n self.assertTrue(type(self.new) is User)",
"def test_check_user(self):\n self.new_user.save_user()\n test_user = User(\"Test\", \"user\", \"test\", \"walIas15\")\n test_user.save_user()\n test_user.check_user(\"test\", \"walIas15\")",
"def test_user_(self):\n obj = User()\n self.assertIsInstance(obj.email, str)\n self.assertIsInstance(obj.password, str)\n self.assertIsInstance(obj.first_name, str)\n self.assertIsInstance(obj.last_name, str)",
"def test_set_user_status(self):\n pass",
"def test_user2(self):\n my_user2 = User()\n my_user2.email = \"[email protected]\"\n my_user2.password = \"user2\"\n my_user2.first_name = \"Hedy\"\n my_user2.last_name = \"Lamar\"\n my_user2.save()\n self.assertEqual(my_user2.email, \"[email protected]\")\n self.assertEqual(my_user2.password, \"user2\")\n self.assertEqual(my_user2.first_name, \"Hedy\")\n self.assertEqual(my_user2.last_name, \"Lamar\")\n self.assertTrue(type(my_user2.email), str)\n self.assertEqual(type(my_user2.password), str)\n self.assertEqual(type(my_user2.first_name), str)\n self.assertEqual(type(my_user2.last_name), str)",
"def test_create_user(self):\n user = User(email=\"[email protected]\", password=\"testpassword\")\n\n self.assertEqual(user.email, \"[email protected]\")\n self.assertNotEqual(user.password, \"testpassword\")\n self.assertFalse(user.confirmed)\n self.assertIsNone(user.confirmed_at)\n self.assertIsNotNone(user.created_at)\n self.assertIsNotNone(user.confirmation_token)",
"def test_attribute_types(self):\n self.assertIsInstance(self.user_1.email, str)\n self.assertIsInstance(self.user_1.password, str)\n self.assertIsInstance(self.user_1.first_name, str)\n self.assertIsInstance(self.user_1.last_name, str)",
"def inner_test(param: models.User):\n self.assertEqual(param, user)",
"def test_user_instances(self):\n obj = User()\n self.assertIsInstance(obj, User)",
"def _make_real_user(self, user_type=None, **user_setup):\n UserModel = get_user_model()\n user_type = user_type or self.user_type\n user = None\n if 'username' not in user_setup:\n user_setup['username'] = user_setup.get('email', '')\n if user_type == 'anonymous':\n return AnonymousUser()\n elif user_type == 'superuser':\n temp = {'is_staff': True, 'is_superuser': True}\n user_setup.update(temp)\n user = UserModel.objects.create_superuser(**user_setup)\n elif user_type == 'staff':\n temp = {'is_staff': True, 'is_superuser': False}\n user_setup.update(temp)\n user = UserModel.objects.create_user(**user_setup)\n elif user_type == 'user':\n temp = {'is_staff': False, 'is_superuser': False}\n user_setup.update(temp)\n user = UserModel.objects.create_user(**user_setup)\n elif user_type == 'inactive': # Assume normal 'user' type, but inactive.\n temp = {'is_staff': False, 'is_superuser': False, 'is_active': False}\n user_setup.update(temp)\n user = UserModel.objects.create_user(**user_setup)\n user.save()\n return user",
"def test_set_user_field(self):\n pass",
"def test_User_instance(self):\n obj = User()\n self.assertIsInstance(obj, User)\n self.assertIsInstance(obj, BaseModel)",
"def test_user_is_verified(self):\r\n user = UserFactory.create()\r\n attempt = SoftwareSecurePhotoVerification(user=user)\r\n attempt.save()\r\n\r\n # If it's any of these, they're not verified...\r\n for status in [\"created\", \"ready\", \"denied\", \"submitted\", \"must_retry\"]:\r\n attempt.status = status\r\n attempt.save()\r\n assert_false(SoftwareSecurePhotoVerification.user_is_verified(user), status)\r\n\r\n attempt.status = \"approved\"\r\n attempt.save()\r\n assert_true(SoftwareSecurePhotoVerification.user_is_verified(user), status)",
"def test_patch_user(self):\n pass",
"def test_user_model(self):\n\n self.user.save()\n self.assertEqual(User.query.count(), 1)",
"def testSetIsAllowed(self):\n self.users.set([(u'user', u'secret', u'New', u'[email protected]',\n None)])\n self.assertEqual(u'[email protected]', self.user.email)\n self.assertEqual(u'New', self.user.fullname)",
"def test_valid_admin_approval(self):\n\n new_user = self.registration_profile.objects.create_inactive_user(\n site=Site.objects.get_current(), **self.user_info)\n profile = self.registration_profile.objects.get(user=new_user)\n user, activated = self.registration_profile.objects.activate_user(\n profile.activation_key, Site.objects.get_current())\n\n self.assertIsInstance(user, UserModel())\n\n user = self.registration_profile.objects.admin_approve_user(\n profile.id, Site.objects.get_current())\n self.assertIsInstance(user, UserModel())\n self.assertIs(user.is_active, True)",
"def test_create_user(self):\n pass"
] | [
"0.6708035",
"0.6635206",
"0.66030097",
"0.65733236",
"0.64285797",
"0.62816226",
"0.6239699",
"0.6232441",
"0.622803",
"0.62261146",
"0.61945903",
"0.61739534",
"0.612075",
"0.61204076",
"0.6098736",
"0.60581166",
"0.6035631",
"0.5991678",
"0.5978381",
"0.59691936",
"0.5960659",
"0.59474134",
"0.5898058",
"0.5891876",
"0.58708775",
"0.58666766",
"0.5852809",
"0.584726",
"0.581953",
"0.58148444"
] | 0.72495323 | 0 |
All forms should return HTML table rows when .as_table is called. | def test_as_table(self, output=None, form=None):
setup = {'start_tag': '<tr><th>', 'label_end': '</th><td>', 'input_end': '<br>', 'end_tag': '</td></tr>'}
setup['as_type'] = as_type = 'as_table'
setup['form'] = form or self.form
output = output or setup['form'].as_table().strip()
expected = self.get_expected_format(setup)
errors = []
if output != expected:
errors = self.log_html_diff(expected, output, as_type=as_type, full=False)
message = "Suite {}, had {} lines of HTML errors for {} ".format(self.__class__.__name__, len(errors), as_type)
self.assertNotEqual('', output)
self.assertEqual(expected, output, message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display_as_table(form):\n return {'form': form}",
"def _repr_html_(self):\n return html_table(self)",
"def as_table(self, field_name=None):\r\n if field_name is None:\r\n normal_row = u'<tr><th>%(label)s</th><td>%(errors)s%(field)s' \\\r\n u'%(help_text)s</td></tr>'\r\n error_row = u'<tr><td colspan=\"2\">%s</td></tr>'\r\n return self._html_output(normal_row, error_row, '</td></tr>',\r\n u'<br />%s', False)\r\n else:\r\n # Only render a single field as a table row\r\n self.backup_fields = self.fields\r\n self.fields = {\r\n field_name: self.backup_fields[field_name]\r\n }\r\n normal_row = u'<tr><th>%(label)s</th><td>%(errors)s%(field)s' \\\r\n u'%(help_text)s</td></tr>'\r\n error_row = u'<tr><td colspan=\"2\">%s</td></tr>'\r\n result = self._html_output(normal_row, error_row, '</td></tr>',\r\n u'<br />%s', False)\r\n self.fields = self.backup_fields\r\n return result",
"def table(data):\n res = \"\"\n res += \"\"\"\n<form method=\"get\">\n <table class=\"table\">\n <thead>\n <tr>\n <th scope=\"col\">#</th>\n <th scope=\"col\">Name</th>\n <th scope=\"col\">Email</th>\n </tr>\n </thead>\"\"\"\n res += rows(data)\n res += \"\"\"\n <tfoot>\n <tr>\n <td colspan=\"4\" align=\"center\"> \n <button name=\"op\" value=\"new\" type=\"submit\" \n class=\"btn btn-default\">New Contact</button>\n <button name=\"op\" value=\"edit\" type=\"submit\" \n class=\"btn btn-default\">Edit Contact</button>\n <button name=\"op\" value=\"delete\" type=\"submit\" \n class=\"btn btn-default\">Delete Contact</button>\n </td>\n <tr>\n </tfoot>\n </table>\n</form>\"\"\" \n return res",
"def as_html(self):\r\n template = get_template(self.template)\r\n request = build_request()\r\n return template.render(RequestContext(request, {'table': self}))",
"def rows(docs):\n res = \"<tbody>\"\n for row in docs:\n res += \"\"\"\n <tr>\n <td scope=\"row\">\n <input name=\"id\" value=\"%s\" type=\"radio\">\n </td>\n <td>%s</td>\n <td>%s</td>\n </tr>\n\"\"\" % (row[\"id\"], row[\"name\"], row[\"email\"])\n return res+\"</tbody>\"",
"def as_html(self): # pragma: no cover\n\n return render_to_string(\n self._meta.template,\n { \"table\": self } )",
"def generate_table(df, max_rows: int=20):\n return html.Table([\n html.Thead(\n html.Tr([html.Th(col) for col in df.columns])\n ),\n html.Tbody([\n html.Tr([\n html.Td(df.iloc[i][col]) for col in df.columns\n ]) for i in range(min(len(df), max_rows))\n ])\n ])",
"def generate_table(dataframe, max_rows=10):\n return html.Table([\n html.Thead(\n html.Tr([html.Th(col) for col in dataframe.columns])\n ),\n html.Tbody([\n html.Tr([\n html.Td(dataframe.iloc[i][col]) for col in dataframe.columns\n ]) for i in range(min(len(dataframe), max_rows))\n ])\n ])",
"def test_make_headless_row_include_table(self):\n for as_type in ('p', 'ul', 'fieldset', 'table'):\n if as_type == 'table':\n row_tag, col_tag, single_col_tag, col_head_tag = 'tr', 'td', 'td', 'th'\n else:\n row_tag = 'li' if as_type == 'ul' else 'p'\n col_tag, single_col_tag, col_head_tag = 'span', 'div', None\n html_args = (row_tag, col_head_tag, col_tag, single_col_tag, as_type, False)\n html_el = \"This is some test content. \"\n column_count = 3\n col_attr = ' id=\"test-col\"'\n row_attr = ' class=\"row\"'\n result = self.form.make_headless_row(html_args, html_el, column_count, col_attr, row_attr)\n if single_col_tag != '':\n if as_type == 'table':\n col_attr += ' colspan=\"{}\"'.format(column_count * 2 if col_head_tag else column_count)\n html_el = self.form._html_tag(single_col_tag, html_el, col_attr)\n col_attr = ''\n expected = self.form._html_tag(row_tag, html_el, row_attr + col_attr)\n self.assertEqual(expected, result, f\"Failed on as_{as_type}. \")",
"def make_table(self, content):\n html = '<table class=\"table table-condensed\">'\n\n # Check for list or tuple\n if type(content) is list or type(content) is tuple:\n if len(content) > 0:\n # If first item in list is dictionary continue\n if type(content[0]) is dict:\n # Make table header for every key\n html += '<thead><tr>'\n for key in content[0].keys():\n html += '<th>' + key + '</th>'\n html += '</tr></thead>'\n\n # Make table body\n html += '<tbody>'\n for dictonary in content:\n # New table row for every dict item in list\n html += '<tr>'\n # New column for every value in dictionary\n for value in dictonary.values():\n html += '<td>' + str(value) + '</td>'\n html += '</tr>'\n html += '</tbody>'\n else:\n html += 'No content available'\n\n html += '</table>'\n\n self.table = html\n\n return html",
"def as_html(table): \n if isinstance(table,Table):\n html = \"<table width=\\\"\" + str(table.total_width()) + \"\\\"\" + table.html_attributes + \" ><colgroup>\\n\"\n if table.col_width_dict:\n for i in range(table.no_of_columns()):\n html += \"<col width=\\\"\" + str(table.col_width_percent(i)) + \"%\\\"/>\\n\"\n html += \"</colgroup><tbody>\\n\" \n row = \"<tr>\"\n for c in range(table.no_of_columns()):\n row += \"<th width=\\\"\"+str(table.col_width_percent(c))+\"%\\\">\" + table.cell(0,c) +\"</th>\"\n row += \"</tr>\\n\"\n html += row\n for r in range(1,table.no_of_rows()):\n row = \"<tr>\"\n for c in range(table.no_of_columns()):\n row += \"<td>\" + table.cell(r,c) + \"</td>\"\n row += \"</tr>\\n\"\n html += row\n return mark_safe(html)\n else:\n return table",
"def csv_bootstrap_table():\n if request.method == 'POST':\n # check if the post request has the file part\n if 'file' not in request.files:\n flash('No file part')\n return redirect(request.url)\n file = request.files['file']\n if file.filename == '':\n flash('No selected file')\n return redirect(request.url)\n if file and allowed_file(file.filename):\n #filename = secure_filename(file.filename)\n html_text = csv_html_converter(file)\n html = Markup(html_text)\n return render_template('bootstrap_table.html', html=html, html_code=html_text)\n return render_template('form.html')",
"def table_html(table_rows: List[str]) -> str:\n return \"<table>{}</table>\".format(\"\".join(table_rows))",
"def table(self):\n if self._table is None:\n self._table = list(self._iter_rows())\n\n return self._table",
"def form_SequenceOfSequencesAsTextArea(request):\n schema = schemaish.Structure()\n schema.add('table', schemaish.Sequence(schemaish.Tuple( (schemaish.String(), schemaish.Integer(), schemaish.Date()) )))\n form = formish.Form(schema)\n form['table'].widget = formish.TextArea()\n return form",
"def htmlValue(self, REQUEST):\n\n value = REQUEST.form.get(self.__name__, 'No Input')\n\n header = ''\n for col in self.columnDefs:\n header += \"<th>%s</th>\" % col['columnTitle']\n\n res = '<table class=\"listing\"><thead><tr>%s</tr></thead><tbody>' % header\n for adict in value:\n if adict.get('orderindex_', '') != 'template_row_marker':\n res += \"<tr>\"\n for col in self.columnDefs:\n akey = col['columnId']\n if col['columnType'] == \"File\":\n file = adict[akey]\n file.seek(0)\n fdata = file.read()\n filename = file.filename\n mimetype, enc = guess_content_type(filename, fdata, None)\n out = \"%s %s: %s bytes\" % (filename, mimetype, len(fdata))\n res = \"%s\\n<td>%s</td>\" % (res, cgi.escape(out))\n else:\n res = \"%s\\n<td>%s</td>\" % (res, cgi.escape(adict[akey]))\n res += \"</tr>\"\n\n return \"%s</tbody></table>\" % res",
"def _html_repr(self):\n html = '<table id=%s>' % (self._id,)\n\n for row in range(self.rows):\n html += '<tr>'\n for col in range(self.columns):\n if row == 0 and self.header_row or col == 0 and self.header_column:\n tag = 'th'\n else:\n tag = 'td'\n html += '<%(tag)s id=%(id)s></%(tag)s>' % {\n 'tag': tag,\n 'id': self._get_cell_id(row, col),\n }\n html += '</tr>'\n html += '</table>'\n return html",
"def generate_table(self, rows):\n ...",
"def test_form_works_with_table_pagination_on_second_page(self):\n n_traits = TABLE_PER_PAGE + 2\n factories.HarmonizedTraitFactory.create_batch(n_traits, i_description='lorem ipsum')\n response = self.client.get(self.get_url(), {'description': 'lorem', 'page': 2})\n context = response.context\n self.assertIn('form', context)\n self.assertTrue(context['has_results'])\n self.assertIsInstance(context['results_table'], tables.HarmonizedTraitTable)\n self.assertEqual(len(context['results_table'].rows), n_traits)",
"def form_SequenceOfStructuresGridWidget(request):\n schema = schemaish.Structure()\n schema.add('rows', schemaish.Sequence(schemaish.Structure([\n ('a', schemaish.Boolean()),\n ('b', schemaish.String()),])))\n\n form = formish.Form(schema, 'form')\n form['rows'].widget = formish.Grid()\n form['rows.*.a'].widget = formish.Checkbox()\n form.defaults = {'rows': [{'a':True,'b':'2'},{'a':False,'b':'4'},{'a':False,'b':'6'}]}\n return form",
"def test_form_main_rows_html_fieldset(self):\n # form.form_main_rows(self, html_args, fieldsets, form_col_count)\n # html_args = (row_tag, col_head_tag, col_tag, single_col_tag, as_type, all_fieldsets)\n pass",
"def _html_table(self):\n return '</i>'.join(APtable._repr_html_(self).split('</i>')[1:])",
"def TableFieldWidget(field, request):\n return widget.FieldWidget(field, TableWidget(request))",
"def test_form_main_rows_all_fieldsets(self):\n # form.form_main_rows(self, html_args, fieldsets, form_col_count)\n # html_args = (row_tag, col_head_tag, col_tag, single_col_tag, as_type, all_fieldsets)\n pass",
"def as_bootstrap(self):\n top_errors = self.non_field_errors() # Errors that should be displayed above all fields.\n output, hidden_fields = [], []\n normal_row = u'<div%(html_class_attr)s>%(label)s<div class=\"controls\">%(field)s%(help_text)s</div>%(errors)s</div>'\n boolean_row = u'<div%(html_class_attr)s><div class=\"controls\">%(label_and_field)s%(help_text)s</div>%(errors)s</div>'\n error_row = u'<div class=\"alert alert-error\">%s</div>'\n row_ender = u'</div>'\n help_text_html = u'<span class=\"help-inline\">%s</span>'\n errors_on_separate_row = False\n\n for name, field in self.fields.items():\n html_class_attr = ''\n bf = self[name]\n is_boolean = isinstance(field, forms.fields.BooleanField)\n bf_errors = self.error_class([conditional_escape(error) for error in bf.errors]) # Escape and cache in local variable.\n if bf.is_hidden:\n if bf_errors:\n top_errors.extend([u'(Hidden field %s) %s' % (name, force_unicode(e)) for e in bf_errors])\n hidden_fields.append(unicode(bf))\n else:\n # Create a 'class=\"...\"' atribute if the row should have any\n # CSS classes applied.\n css_classes = bf.css_classes(extra_classes='control-group')\n if css_classes:\n html_class_attr = ' class=\"%s\"' % css_classes\n\n if errors_on_separate_row and bf_errors:\n output.append(error_row % force_unicode(bf_errors))\n\n if bf.label:\n label = conditional_escape(force_unicode(bf.label))\n if is_boolean:\n label = bf.label_tag(unicode(bf) + label,\n attrs={'class': 'checkbox'}) or ''\n else:\n # Only add the suffix if the label does not end in\n # punctuation.\n if self.label_suffix:\n if label[-1] not in ':?.!':\n label += self.label_suffix\n\n label = bf.label_tag(label,\n attrs={'class': 'control-label'}) or ''\n else:\n label = ''\n\n if field.help_text:\n help_text = help_text_html % force_unicode(field.help_text)\n else:\n help_text = u''\n\n if bf_errors:\n errors = u' '.join([error_row % force_unicode(error)\n for error in bf_errors])\n else:\n errors = u''\n\n if is_boolean:\n output.append(boolean_row % {\n 'errors': errors,\n 'label_and_field': force_unicode(label),\n 'help_text': help_text,\n 'html_class_attr': html_class_attr\n })\n else:\n output.append(normal_row % {\n 'errors': errors,\n 'label': force_unicode(label),\n 'field': unicode(bf),\n 'help_text': help_text,\n 'html_class_attr': html_class_attr\n })\n\n if top_errors:\n output.insert(0, error_row % force_unicode(top_errors))\n\n if hidden_fields: # Insert any hidden fields in the last row.\n str_hidden = u''.join(hidden_fields)\n if output:\n last_row = output[-1]\n # Chop off the trailing row_ender (e.g. '</td></tr>') and\n # insert the hidden fields.\n if not last_row.endswith(row_ender):\n # This can happen in the as_p() case (and possibly others\n # that users write): if there are only top errors, we may\n # not be able to conscript the last row for our purposes,\n # so insert a new, empty row.\n last_row = (normal_row % {'errors': '', 'label': '',\n 'field': '', 'help_text': '',\n 'html_class_attr': html_class_attr})\n output.append(last_row)\n output[-1] = last_row[:-len(row_ender)] + str_hidden + row_ender\n else:\n # If there aren't any rows in the output, just append the\n # hidden fields.\n output.append(str_hidden)\n return mark_safe(u'\\n'.join(output))",
"def table_builder(request):\n kind=request.param\n def _builder(data, columns):\n if kind==\"array\":\n return np.array(data)\n elif kind==\"table\":\n return DataTable(data,columns,transposed=False)\n else:\n return pd.DataFrame(data,columns=columns)\n _builder.kind=kind\n return _builder",
"def _create_table_html(self, table):\n if table != {} and table is not None:\n html_output = [['<hr>']]\n else:\n html_output = []\n\n for t in self._util_func.dict_key_list(table.keys()):\n html_output.append(table[t])\n\n return html_output",
"def get_onlineformincoming_html(dbo, collationid):\n h = []\n h.append('<table width=\"100%\">')\n for f in get_onlineformincoming_detail(dbo, collationid):\n label = f[\"LABEL\"]\n if label is None or label == \"\": label = f[\"FIELDNAME\"]\n h.append('<tr>')\n h.append('<td>%s</td>' % label )\n h.append('<td>%s</td>' % f[\"VALUE\"])\n h.append('</tr>')\n h.append('</table>')\n return \"\\n\".join(h)",
"def table_row(self, content):\n return ['<tr>\\n%s</tr>\\n'] + content"
] | [
"0.7701475",
"0.66434586",
"0.66034126",
"0.64598995",
"0.64371777",
"0.6176933",
"0.6121198",
"0.605766",
"0.60159713",
"0.5942964",
"0.5915406",
"0.58860743",
"0.5879036",
"0.5878051",
"0.5855618",
"0.5853942",
"0.5805384",
"0.57895756",
"0.57610744",
"0.57559323",
"0.57558686",
"0.571426",
"0.5694777",
"0.5693856",
"0.56904477",
"0.5687122",
"0.5681204",
"0.56730056",
"0.56686306",
"0.56384665"
] | 0.68445253 | 1 |
All forms should return HTML s when .as_ul is called. | def test_as_ul(self, output=None, form=None):
setup = {'start_tag': '<li>', 'end_tag': '</li>', 'label_end': ' ', 'input_end': ' '}
setup['as_type'] = as_type = 'as_ul'
setup['form'] = form or self.form
output = output or setup['form'].as_ul().strip()
expected = self.get_expected_format(setup)
errors = []
if output != expected:
errors = self.log_html_diff(expected, output, as_type=as_type, full=False)
message = "Suite {}, had {} lines of HTML errors for {} ".format(self.__class__.__name__, len(errors), as_type)
self.assertNotEqual('', output)
self.assertEqual(expected, output, message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render_form_content(self):\n return mark_safe(self.render_as_object() + self.render_missing_fields())",
"def render_form():",
"def render_form(self):\n s = [f.render() for f in self.fields]\n r = [f.render() for f in self.refs]\n return view.render_form('form.html', {\n 'fields': ''.join(s),\n 'refs': ''.join(r),\n 'errors': self.get_errors(),\n 'id': self.model.id\n })",
"def render(self):\n id_ = self.attrs.get('id')\n output = []\n for i, choice in enumerate(self.choices):\n choice_value, choice_label = choice\n if isinstance(choice_label, (tuple, list)):\n attrs_plus = self.attrs.copy()\n if id_:\n attrs_plus['id'] += '_{}'.format(i)\n sub_ul_renderer = self.__class__(\n name=self.name,\n value=self.value,\n attrs=attrs_plus,\n choices=choice_label,\n )\n sub_ul_renderer.choice_input_class = self.choice_input_class\n output.append(format_html(\n self.inner_html, choice_value=choice_value,\n sub_widgets=sub_ul_renderer.render(),\n ))\n else:\n w = self.choice_input_class(self.name, self.value, self.attrs.copy(), choice, i)\n output.append(format_html(self.inner_html, choice_value=force_text(w), sub_widgets=''))\n return format_html(\n self.outer_html,\n id_attr=format_html(' id=\"{}\"', id_) if id_ else '',\n content=mark_safe('\\n'.join(output)),\n )",
"def toFormMarkup(self, form_tag_attrs=None):\n return self.fields.toFormMarkup(\n self.request.return_to, form_tag_attrs=form_tag_attrs)",
"def render_form(form: wtforms.Form) -> Markup:\n # the defaults for checkboxes and submits are weird and the API limited,\n # hence this hacky fix\n checkboxes = [field.name for field in form if isinstance(field.widget, wtforms.widgets.CheckboxInput)]\n submits = [field.name for field in form if isinstance(field.widget, wtforms.widgets.SubmitInput)]\n return (\n wtforms_bootstrap5.RendererContext()\n .form()\n .default_field(\n row_class=\"row mb-3\",\n label_class=\"form-label col-sm-3 col-form-label\",\n field_wrapper_class=\"col-sm-9\",\n field_wrapper_enabled=True,\n )\n .field(\n *checkboxes,\n wrapper_class=\"offset-sm-3 col-sm-9\",\n wrapper_enabled=True,\n field_wrapper_enabled=False,\n )\n .field(\n *submits,\n field_wrapper_class=\"offset-sm-3 col-sm-9\",\n field_wrapper_enabled=True,\n )\n ).render(form)",
"def renderAsForm(self):\n return self.whichEncoding() == ENCODE_HTML_FORM",
"def __html__(self):\n return self.html",
"def _close_list(self):\n list_type = self.current_parent_element['attrs']['class']\n tag = LIST_TYPES[list_type]\n\n html = '</{t}>'.format(\n t=tag\n )\n self.cleaned_html += html\n self.current_parent_element['tag'] = ''\n self.current_parent_element['attrs'] = {}",
"def form_SequenceOfSimpleStructures(request):\n substructure = schemaish.Structure()\n substructure.add( 'a', schemaish.String() )\n substructure.add( 'b', schemaish.Integer() )\n\n schema = schemaish.Structure()\n schema.add( 'myList', schemaish.Sequence( substructure ))\n\n form = formish.Form(schema, 'form')\n form['myList'].widget = formish.SequenceDefault()\n return form",
"def render(self):\n if self.can_render():\n output = '<ul>'\n for item in self.items:\n output += \"<li>{0}</li>\".format(item)\n return output + '</ul>'\n return ''",
"def form_SequenceOfStrings(request):\n schema = schemaish.Structure()\n schema.add( 'myList', schemaish.Sequence( schemaish.String() ))\n\n form = formish.Form(schema,'formname')\n return form",
"def htmlize(self, obj, rooturl):\n\n\t\tif isinstance(obj, basestring):\n\t\t\tif obj.startswith(\"@\"):\n\n\t\t\t\t# Button link...\n\t\t\t\ttry:\n\t\t\t\t\tmod, ns, objid, value = obj[1:].split(\":\")\n\t\t\t\texcept ValueError:\n\t\t\t\t\tpass\n\t\t\t\telse:\n\t\t\t\t\ttarget_url = rooturl + mod + \"/\" + ns + \"/\" + objid\n\t\t\t\t\tfl = \"<form method=\\\"post\\\" action=\\\"\" + cgi.escape(target_url, True)\n\t\t\t\t\tfl += \"\\\"><input type=\\\"submit\\\" name=\\\"cmd\\\" value=\\\"\"\n\t\t\t\t\tfl += cgi.escape(value, True) + \"\\\"/></form>\"\n\t\t\t\t\treturn fl\n\n\t\t\tif obj == '':\n\t\t\t\treturn \"<br/>\"\n\n\t\t\treturn cgi.escape(obj)\n\n\t\tif isinstance(obj, list):\n\t\t\tout = \"</li><li>\".join(self.htmlize(item, rooturl) for item in obj)\n\t\t\treturn \"<ul><li>\" + out + \"</li></ul>\"\n\n\t\tif isinstance(obj, tuple):\n\t\t\tout = \"\".join(self.htmlize(item, rooturl) for item in obj)\n\t\t\treturn out\n\t\t\t#return \"<p>\" + out + \"</p>\"\n\n\t\tif isinstance(obj, dict) or isinstance(obj, weakref.WeakValueDictionary):\n\t\t\tout = \"</li><li>\".join(\n\t\t\t\t\"<b>\" + cgi.escape(repr(k)) + \"</b>: \" + self.htmlize(obj[k], rooturl)\n\t\t\t\tfor k\n\t\t\t\tin sorted(obj.iterkeys())\n\t\t\t)\n\t\t\treturn \"<ul><li>\" + out + \"</li></ul>\"\n\n\t\tif hasattr(obj, '_chiral_introspect') \\\n\t\t and hasattr(obj._chiral_introspect, 'im_self') \\\n\t\t and obj._chiral_introspect.im_self is not None:\n\t\t\treturn \"<a href=\\\"\" + cgi.escape(\n\t\t\t\trooturl + obj._chiral_introspect.__module__ + (\"/%s/%s\" % obj._chiral_introspect())\n\t\t\t) + \"\\\">\" + cgi.escape(repr(obj)) + \"</a>\"\n\n\t\treturn \"<i>\" + cgi.escape(repr(obj)) + \"</i>\"",
"def make_form(self):",
"def render(self):\n start_tag = format_html('<div {}>', mark_safe(' '.join(self.field_attrs)))\n output = [start_tag]\n for widget in self:\n output.append(force_text(widget))\n output.append('</div>')\n return mark_safe('\\n'.join(output))",
"def toHTML(self):\n return oidutil.autoSubmitHTML(self.toFormMarkup())",
"def render_fields(form, args):\n output = \"\"\n fields = get_fields(form, args)\n for field in fields:\n output += render_field(field)\n return mark_safe(output)",
"def form():\n return render_template(\n 'form.html'\n )",
"def html_sequence(seq_esc: \"Sequence\") -> str:\n items = (f\"<li>{htmlize(item)}</li>\" for item in seq_esc)\n return \"<ul>\\n\" + \"\\n\".join(items) + \"\\n</ul>\"",
"def toFormMarkup(self):\n return self.toMessage().toFormMarkup(self.getReturnTo())",
"def form_SequenceOfStringsWithoutFormName(request):\n schema = schemaish.Structure()\n schema.add( 'myList', schemaish.Sequence( schemaish.String() ))\n\n form = formish.Form(schema)\n return form",
"def _repr_html_(self):\n return util.tree_sequence_html(self)",
"def _repr_html_(self):\n return util.tree_html(self)",
"def render(self):\n content = self._render_pre_content('ul')\n for widget in self._child_widgets:\n content += widget.render()\n content += self._render_post_content('ul')\n self._widget_content = content + \"\\n\" + self._attach_script() + \"\\n\" + self._attach_css()\n return self._widget_content",
"def render_form(form):\n return {\n 'form': form,\n }",
"def render(self, name, value, attrs=None, choices=()):\n self.name = name\n return mark_safe(u'<ul>\\n%s\\n</ul>' % u'\\n'.join(\n [u'<li>%s</li>' % force_unicode(w) for w in self],\n ))",
"def form_ValidationOnSequenceItemTextArea(request):\n schema = schemaish.Structure()\n schema.add( 'myList', schemaish.Sequence( schemaish.String(validator=validatish.Email()) ))\n\n form = formish.Form(schema, 'form')\n form['myList'].widget = formish.TextArea()\n return form",
"def as_bootstrap(self):\n top_errors = self.non_field_errors() # Errors that should be displayed above all fields.\n output, hidden_fields = [], []\n normal_row = u'<div%(html_class_attr)s>%(label)s<div class=\"controls\">%(field)s%(help_text)s</div>%(errors)s</div>'\n boolean_row = u'<div%(html_class_attr)s><div class=\"controls\">%(label_and_field)s%(help_text)s</div>%(errors)s</div>'\n error_row = u'<div class=\"alert alert-error\">%s</div>'\n row_ender = u'</div>'\n help_text_html = u'<span class=\"help-inline\">%s</span>'\n errors_on_separate_row = False\n\n for name, field in self.fields.items():\n html_class_attr = ''\n bf = self[name]\n is_boolean = isinstance(field, forms.fields.BooleanField)\n bf_errors = self.error_class([conditional_escape(error) for error in bf.errors]) # Escape and cache in local variable.\n if bf.is_hidden:\n if bf_errors:\n top_errors.extend([u'(Hidden field %s) %s' % (name, force_unicode(e)) for e in bf_errors])\n hidden_fields.append(unicode(bf))\n else:\n # Create a 'class=\"...\"' atribute if the row should have any\n # CSS classes applied.\n css_classes = bf.css_classes(extra_classes='control-group')\n if css_classes:\n html_class_attr = ' class=\"%s\"' % css_classes\n\n if errors_on_separate_row and bf_errors:\n output.append(error_row % force_unicode(bf_errors))\n\n if bf.label:\n label = conditional_escape(force_unicode(bf.label))\n if is_boolean:\n label = bf.label_tag(unicode(bf) + label,\n attrs={'class': 'checkbox'}) or ''\n else:\n # Only add the suffix if the label does not end in\n # punctuation.\n if self.label_suffix:\n if label[-1] not in ':?.!':\n label += self.label_suffix\n\n label = bf.label_tag(label,\n attrs={'class': 'control-label'}) or ''\n else:\n label = ''\n\n if field.help_text:\n help_text = help_text_html % force_unicode(field.help_text)\n else:\n help_text = u''\n\n if bf_errors:\n errors = u' '.join([error_row % force_unicode(error)\n for error in bf_errors])\n else:\n errors = u''\n\n if is_boolean:\n output.append(boolean_row % {\n 'errors': errors,\n 'label_and_field': force_unicode(label),\n 'help_text': help_text,\n 'html_class_attr': html_class_attr\n })\n else:\n output.append(normal_row % {\n 'errors': errors,\n 'label': force_unicode(label),\n 'field': unicode(bf),\n 'help_text': help_text,\n 'html_class_attr': html_class_attr\n })\n\n if top_errors:\n output.insert(0, error_row % force_unicode(top_errors))\n\n if hidden_fields: # Insert any hidden fields in the last row.\n str_hidden = u''.join(hidden_fields)\n if output:\n last_row = output[-1]\n # Chop off the trailing row_ender (e.g. '</td></tr>') and\n # insert the hidden fields.\n if not last_row.endswith(row_ender):\n # This can happen in the as_p() case (and possibly others\n # that users write): if there are only top errors, we may\n # not be able to conscript the last row for our purposes,\n # so insert a new, empty row.\n last_row = (normal_row % {'errors': '', 'label': '',\n 'field': '', 'help_text': '',\n 'html_class_attr': html_class_attr})\n output.append(last_row)\n output[-1] = last_row[:-len(row_ender)] + str_hidden + row_ender\n else:\n # If there aren't any rows in the output, just append the\n # hidden fields.\n output.append(str_hidden)\n return mark_safe(u'\\n'.join(output))",
"def unordered_list_html(list_items: List[str]) -> str:\n return \"<ul>{}</ul>\".format(\"\".join(list_items))",
"def html_unordered_list(items):\n if not items:\n return \"\"\n\n inner = \"\".join(map(html_list_item, items))\n if inner == \"\":\n return \"\"\n\n return \"<ul>\\n\" + inner + \"</ul>\\n\""
] | [
"0.6513047",
"0.6463842",
"0.6252335",
"0.5958505",
"0.59378386",
"0.59344834",
"0.58983976",
"0.5804516",
"0.577028",
"0.574896",
"0.57450455",
"0.57045156",
"0.5641969",
"0.56327015",
"0.56324124",
"0.562148",
"0.56147474",
"0.5611882",
"0.5600873",
"0.5544296",
"0.54834974",
"0.5482125",
"0.54726726",
"0.54580486",
"0.54232407",
"0.5422264",
"0.54215413",
"0.5418848",
"0.53716785",
"0.5368195"
] | 0.6899708 | 0 |
All forms should return HTML s when .as_p is called. | def test_as_p(self, output=None, form=None):
setup = {'start_tag': '<p>', 'end_tag': '</p>', 'label_end': ' ', 'input_end': ' '}
setup['as_type'] = as_type = 'as_p'
setup['form'] = form or self.form
output = output or setup['form'].as_p().strip()
expected = self.get_expected_format(setup)
errors = []
if output != expected:
errors = self.log_html_diff(expected, output, as_type=as_type, full=False)
message = "Suite {}, had {} lines of HTML errors for {} ".format(self.__class__.__name__, len(errors), as_type)
self.assertNotEqual('', output)
self.assertEqual(expected, output, message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render_form_content(self):\n return mark_safe(self.render_as_object() + self.render_missing_fields())",
"def render_form():",
"def __html__(self):\n return self.html",
"def toFormMarkup(self, form_tag_attrs=None):\n return self.fields.toFormMarkup(\n self.request.return_to, form_tag_attrs=form_tag_attrs)",
"def toFormMarkup(self):\n return self.toMessage().toFormMarkup(self.getReturnTo())",
"def renderAsForm(self):\n return self.whichEncoding() == ENCODE_HTML_FORM",
"def toHTML(self):\n return oidutil.autoSubmitHTML(self.toFormMarkup())",
"def _repr_html_(self):\n return self.__repr__()",
"def _repr_html_(self):\n return self.__repr__()",
"def render_form(self):\n s = [f.render() for f in self.fields]\n r = [f.render() for f in self.refs]\n return view.render_form('form.html', {\n 'fields': ''.join(s),\n 'refs': ''.join(r),\n 'errors': self.get_errors(),\n 'id': self.model.id\n })",
"def html(self):\n dis = ('disabled' if not self._enabled else '')\n met = ('post' if self._html_post else 'get')\n act = escape(self._action)\n txt = escape(self._text)\n return '<button %s formaction=\"%s\" formmethod=\"%s\">%s</button>' % (dis, act, met, txt)",
"def _repr_html_(self):\n\n return self._repr__base(rich_output=True)",
"def _repr_html_(self):\n\n return self._repr__base(rich_output=True)",
"def get_html(self):\r\n pass",
"def render_form(form):\n return {\n 'form': form,\n }",
"def form():\n return render_template(\n 'form.html'\n )",
"def _repr_html_(self):\n return self.data.to_html()",
"def test_prep_fields_called_html_output(self):\n pass",
"def __html__(self):\n return str(self)",
"def preview_handler(self, _, __):\r\n template = self.system.render_template('lti_form.html', self.get_context())\r\n return Response(template, content_type='text/html')",
"def _repr_html_(self) -> str:\n output_html = self.template_base.render(context=self.context)\n return output_html",
"def create_form_html():\n data_file = os.path.join('data', 'data.csv')\n data = pd.read_csv(data_file, index_col=0)\n example1 = data.iloc[0, :178]\n example2 = data.iloc[4340, : 178]\n placeholder = ', '.join(example1.astype(str))\n example_str1 = textwrap.fill(placeholder, 80)\n example_str2 = textwrap.fill(', '.join(example2.astype(str)), 80)\n form_html = ('''\n <html><body>\n <h1>Binary classifier for Epileptic Seizure Recognition Data \n Set</h1>\n <h2>Please enter features for classification</h1>\n (178 integers, separated by commas)\n <form method=\"post\" action=\"\">\n <textarea name=\"query\" cols=\"80\" rows=\"10\">'''\n + placeholder\n + ''' </textarea>\n <input type=\"submit\">\n </form>\n <p> Example non-seizure data point:\n '''\n + example_str1\n + '''<p> Example seizure data point: '''\n + example_str2\n + '''</body></html>''')\n return form_html",
"def rawHTMLrendered(self):",
"def _repr_html_(self):\n return self._frame._repr_html_()",
"def get_rendered_html_form(self, data, view, method, request):\n # See issue #2089 for refactoring this.\n serializer = getattr(data, 'serializer', None)\n if serializer and not getattr(serializer, 'many', False):\n instance = getattr(serializer, 'instance', None)\n if isinstance(instance, Page):\n instance = None\n else:\n instance = None\n\n # If this is valid serializer data, and the form is for the same\n # HTTP method as was used in the request then use the existing\n # serializer instance, rather than dynamically creating a new one.\n if request.method == method and serializer is not None:\n try:\n kwargs = {'data': request.data}\n except ParseError:\n kwargs = {}\n existing_serializer = serializer\n else:\n kwargs = {}\n existing_serializer = None\n\n with override_method(view, request, method) as request:\n if not self.show_form_for_method(view, method, request, instance):\n return\n\n if method in ('DELETE', 'OPTIONS'):\n return True # Don't actually need to return a form\n\n has_serializer = getattr(view, 'get_serializer', None)\n has_serializer_class = getattr(view, 'serializer_class', None)\n\n if (\n (not has_serializer and not has_serializer_class) or\n not any(is_form_media_type(parser.media_type) for parser in view.parser_classes)\n ):\n return\n\n if existing_serializer is not None:\n try:\n return self.render_form_for_serializer(existing_serializer)\n except TypeError:\n pass\n\n if has_serializer:\n if method in ('PUT', 'PATCH'):\n serializer = view.get_serializer(instance=instance, **kwargs)\n else:\n serializer = view.get_serializer(**kwargs)\n else:\n # at this point we must have a serializer_class\n if method in ('PUT', 'PATCH'):\n serializer = self._get_serializer(view.serializer_class, view,\n request, instance=instance, **kwargs)\n else:\n serializer = self._get_serializer(view.serializer_class, view,\n request, **kwargs)\n\n return self.render_form_for_serializer(serializer)",
"def get(self):\n response = make_response(render_template_string(self.form_html), 200)\n response.headers['mime-type'] = 'text/html'\n return response",
"def html(self):\n lbl = escape(self._label)\n dis = ('disabled' if not self._enabled else '')\n typ = ('password' if self._password else 'text')\n nam = escape(self._name)\n val = escape(self._value)\n return '%s <input name=\"%s\" %s type=\"%s\" value=\"%s\" size=\"%i\">' % (lbl, nam, dis, typ, val, self._size)",
"def show_form():\n\n return render_template(\"form.html\")",
"def make_form(self):",
"def toHTML(self, form_tag_attrs=None):\n return oidutil.autoSubmitHTML(self.toFormMarkup(form_tag_attrs))"
] | [
"0.6810297",
"0.6472013",
"0.6343937",
"0.62592846",
"0.62355494",
"0.61389494",
"0.61310256",
"0.60670376",
"0.60670376",
"0.6013662",
"0.59986526",
"0.5965411",
"0.5965411",
"0.592587",
"0.5887663",
"0.5844421",
"0.5843759",
"0.5825722",
"0.5807929",
"0.5801746",
"0.5789513",
"0.57886565",
"0.57848155",
"0.57781273",
"0.57741857",
"0.5754485",
"0.57501334",
"0.57242316",
"0.57227004",
"0.57204556"
] | 0.6754369 | 1 |
Returns a list of all fields that have been given an HTML attribute of 'autofocus'. | def find_focus_field(self):
fields = self.get_current_fields()
found_names = []
for field_name, field in fields.items():
has_focus = field.widget.attrs.get('autofocus', None)
if has_focus:
found_names.append(field_name)
return found_names | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_focus_on_limited_fields(self):\n original_named_focus = self.form.named_focus\n original_fields_focus = self.form.fields_focus\n original_given_focus = self.form.given_focus\n original_fields = self.form.fields\n self.form.named_focus = None\n self.form.given_focus = None\n allowed = [name for name, field in self.form.fields.items()\n if not field.disabled and not isinstance(field.widget, (HiddenInput, MultipleHiddenInput))]\n self.assertGreater(len(allowed), 1)\n fields_focus = allowed[1:]\n self.form.fields_focus = fields_focus\n expected = fields_focus[0]\n actual = self.form.assign_focus_field(None, fields=self.form.fields_focus)\n\n self.assertEqual(expected, actual)\n self.assertEqual(self.form.given_focus, actual)\n\n self.form.name_focus = original_named_focus\n self.form.fields_focus = original_fields_focus\n self.form.given_focus = original_given_focus\n self.form.fields = original_fields",
"def input_fields(self):\r\n return self.input.fields",
"def run_autofocus(self):\n raise NotImplementedError",
"def get_fields(self):\n for field in self.fields_box.children:\n if isinstance(field, MyTextField):\n yield field",
"def _get_all_fields():\n participant_form = custom_form_factory(ParticipantEditForm)\n return list(participant_form().exclude([\n CustomField.CHECKBOX,\n CustomField.IMAGE,\n CustomField.EVENT\n ]))",
"def list_fields(fc):\n return [f.name for f in arcpy.ListFields(fc)]",
"def get_required_fields(self) -> Iterable[fields.Field]:\n for model_field in self.get_fields():\n if model_field.required:\n yield model_field",
"def get_fields(self):\n field_list = []\n for field in self._meta.local_fields:\n if not field.primary_key:\n field_list.append([field.verbose_name.title(),\n self.__getattribute__(field.name),\n field.get_internal_type()])\n return field_list",
"def gf_fieldnames(fn=\"forms-fields.txt\"):\n\tif fn is None: \n\t\treturn None\n\twith open(fn) as f:\n\t\tfieldnames = [fieldname.split(\":\")[0] for fieldname in f]\n\t\treturn fieldnames",
"def _select_fields(self):\r\n return []",
"def getFocus(*args):",
"def getFocus(*args):",
"def getFocus(*args):",
"def getFocus(*args):",
"def get_fields_list(self):\n return self.description[\"fields\"][\"values\"].keys()",
"def get_attribute_list(self):\n attributes = [attr for attr in vars(self.entries[0]) if not attr.startswith('__')]\n return attributes",
"def getFields(iface):\n return getFieldsInOrder(iface)",
"def test_focus(self, name=None):\n focus_func = getattr(self.form, 'assign_focus_field', None)\n fields = self.get_current_fields()\n if focus_func and issubclass(self.__class__, FocusMixIn):\n name = name or getattr(self.form, 'named_focus', None)\n expected = focus_func(name, fields)\n else:\n expected = 'username' if 'username' in fields else None\n expected = name or expected or None\n if not expected:\n self.assertTrue(True)\n return\n focus_list = self.find_focus_field()\n self.assertEqual(1, len(focus_list))\n self.assertEqual(expected, focus_list[0])",
"def get_fields(self):\n for child in self.children:\n if isinstance(child, MyTextField):\n yield child",
"def get_all_fields(self):\n fields = []\n for f in self._meta.fields:\n\n fname = f.name \n # resolve picklists/choices, with get_xyz_display() function\n get_choice = 'get_'+fname+'_display'\n if hasattr( self, get_choice):\n value = getattr( self, get_choice)()\n else:\n try :\n value = getattr(self, fname)\n except User.DoesNotExist:\n value = None\n\n # only display fields with values and skip some fields entirely\n if f.editable and value and f.name not in ('id', 'status', 'workshop', 'user', 'complete') :\n\n fields.append(\n {\n 'label':f.verbose_name, \n 'name':f.name, \n 'value':value,\n }\n )\n return fields",
"def getRichTextFields(self):\n fields_list = []\n if hasattr(self, 'questionTextArea'):\n fields_list.append(self.questionTextArea)\n if hasattr(self, 'feedbackTextArea'):\n fields_list.append(self.feedbackTextArea)\n return fields_list",
"def fields(self) -> List[SingleField]:\n return self._fields",
"def get_fields(self) -> Iterable[fields.Field]:\n for attr_name in dir(self):\n attr = getattr(self, attr_name)\n if isinstance(attr, fields.Field):\n yield attr",
"def listFields(self):\n return self.get_json('/field')",
"def _autoinc_fields(t, module):\n result = set()\n for (fname, f) in datamodel.sorted_fields(t):\n jfname = java.name(fname)\n method = java.CamelCase(jfname)\n (java_type, type_info, ftype) = datamodel.typeref(f, module)\n if ftype and 'autoinc' in syslx.patterns(ftype.attrs):\n result.add(fname)\n return result",
"def __parse_search_form(html: str) -> List[str]:\n soup = BeautifulSoup(html, features='html.parser')\n form_names = [i['name'] for i in soup.find('form').findAll('input')]\n return form_names",
"def run_autofocus_stig(self):\n raise NotImplementedError",
"def get_fields(form, args):\n bound_fields = {}\n fields = []\n for field in form:\n bound_fields.update({field.name: field})\n for field_name in args.split(','):\n if field_name in bound_fields:\n fields.append(bound_fields[field_name])\n return fields",
"def Fields(self):\n return self._fields",
"def all_fields(item):\n return scom.all_fields(item)"
] | [
"0.52875453",
"0.5232824",
"0.5178835",
"0.5138746",
"0.5121877",
"0.5111444",
"0.499848",
"0.49805778",
"0.49702394",
"0.4962316",
"0.49381164",
"0.49381164",
"0.49381164",
"0.49381164",
"0.48813406",
"0.48727515",
"0.48725775",
"0.4858869",
"0.48553702",
"0.48552412",
"0.48355252",
"0.48335165",
"0.4829736",
"0.4809486",
"0.4795688",
"0.47764188",
"0.47622854",
"0.47301573",
"0.47117135",
"0.47080025"
] | 0.760456 | 0 |
Always True if the assign_focus_field method is absent. Otherwise checks if configured properly. | def test_focus(self, name=None):
focus_func = getattr(self.form, 'assign_focus_field', None)
fields = self.get_current_fields()
if focus_func and issubclass(self.__class__, FocusMixIn):
name = name or getattr(self.form, 'named_focus', None)
expected = focus_func(name, fields)
else:
expected = 'username' if 'username' in fields else None
expected = name or expected or None
if not expected:
self.assertTrue(True)
return
focus_list = self.find_focus_field()
self.assertEqual(1, len(focus_list))
self.assertEqual(expected, focus_list[0]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_focus_not_on_disabled(self):\n target = 'disable_field'\n field = self.form.fields.get(target, None)\n result_name = self.form.assign_focus_field(target)\n focused = self.find_focus_field()\n\n self.assertTrue(field.disabled)\n self.assertIn(target, self.form.fields)\n self.assertEqual(1, len(focused))\n self.assertNotEqual(target, focused[0])\n self.assertNotEqual(target, result_name)",
"def focus(self) -> bool:\n return self._has_focus",
"def test_focus_on_limited_fields(self):\n original_named_focus = self.form.named_focus\n original_fields_focus = self.form.fields_focus\n original_given_focus = self.form.given_focus\n original_fields = self.form.fields\n self.form.named_focus = None\n self.form.given_focus = None\n allowed = [name for name, field in self.form.fields.items()\n if not field.disabled and not isinstance(field.widget, (HiddenInput, MultipleHiddenInput))]\n self.assertGreater(len(allowed), 1)\n fields_focus = allowed[1:]\n self.form.fields_focus = fields_focus\n expected = fields_focus[0]\n actual = self.form.assign_focus_field(None, fields=self.form.fields_focus)\n\n self.assertEqual(expected, actual)\n self.assertEqual(self.form.given_focus, actual)\n\n self.form.name_focus = original_named_focus\n self.form.fields_focus = original_fields_focus\n self.form.given_focus = original_given_focus\n self.form.fields = original_fields",
"def test_html_output_default_use_focus_if_present(self):\n original_focus_called = self.form.called_assign_focus_field\n for as_type in ('as_p', 'as_ul', 'as_table'):\n self.form.called_assign_focus_field = False\n html_output = getattr(self.form, as_type + '_old')()\n message = \"The FormFieldsetMixIn OLD _html_output failed on {}\".format(as_type)\n self.assertTrue(self.form.called_assign_focus_field, message)\n self.assertIsNotNone(html_output)\n\n self.form.called_assign_focus_field = original_focus_called",
"def test_html_output_formfieldset_use_focus_if_present(self):\n original_focus_called = self.form.called_assign_focus_field\n for as_type in ('as_p', 'as_ul', 'as_table', 'as_fieldset'):\n self.form.called_assign_focus_field = False\n html_output = getattr(self.form, as_type)()\n message = \"The FormFieldsetMixIn new _html_output failed on {}\".format(as_type)\n self.assertTrue(self.form.called_assign_focus_field, message)\n self.assertIsNotNone(html_output)\n\n self.form.called_assign_focus_field = original_focus_called",
"def precheck(self):\n if self.__chardev_obj is None:\n self.logger.exception(\"[IPMI] -chardev should set.\")\n raise Exception(\"-chardev should set.\")",
"def AcceptsFocus(self):\n\n return self.IsShown() and self.IsEnabled()",
"def run_autofocus(self):\n raise NotImplementedError",
"def _check_is_editable(self, raise_error: bool = True) -> bool:",
"def is_required(self, field):\n return field.scheme.is_required and not field.scheme.is_pk",
"def required(self) -> bool:\n return self._default is None",
"def auto_assign(self) -> Optional[pulumi.Input[Union[str, 'BfdEnabled']]]:\n return pulumi.get(self, \"auto_assign\")",
"def test_focus_update_for_configure_username_confirmation(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n original_errors = getattr(self.form, '_errors', None)\n original_focus = getattr(self.form, 'named_focus', None)\n original_focus_method = getattr(self.form, 'assign_focus_field', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form.cleaned_data = {self.form.name_for_user: 'test_username', self.form.name_for_email: 'test_email'}\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n self.form.named_focus = ''\n if original_focus_method is None:\n def mock_focus_method(name, *args, **kwargs): return name\n setattr(self.form, 'assign_focus_field', mock_focus_method)\n message = self.form.configure_username_confirmation()\n message = None if not message else message\n expected = self.form.name_for_email\n actual = getattr(self.form, 'named_focus', None)\n\n self.assertIsNotNone(message)\n self.assertTrue(hasattr(self.form, 'assign_focus_field'))\n self.assertEqual(expected, self.form.assign_focus_field(expected))\n self.assertEqual(expected, actual)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form.named_focus = original_focus\n self.form.assign_focus_field = original_focus_method\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors\n if original_focus is None:\n del self.form.named_focus\n if original_focus_method is None:\n del self.form.assign_focus_field\n if original_cleaned_data is None:\n del self.form.cleaned_data\n if original_errors is None:\n del self.form._errors",
"def run_autofocus_stig(self):\n raise NotImplementedError",
"def AcceptsFocus(self):\r\n\r\n # overridden base class method, allows this ctrl to\r\n # participate in the tab-order, etc. It's overridable because\r\n # of deriving this class from wx.PyScrolledWindow...\r\n return True",
"def optional(self) -> bool:\n return False",
"def is_field_mandatory(self, label_text):\n field_locator = (By.XPATH, \"//div[@id='BISEContent']/descendant::label[contains(text(), '%s')]\" % label_text)\n field_element = self.wait().until(EC.presence_of_element_located(field_locator), 'field locator not found before specified time out')\n if str(field_element.get_attribute(\"class\")) == \"required-field\":\n return True\n else:\n return False",
"def trivialFieldChecker(self, event):\n\n self.widget_insert_page_item[event.widget].is_good_flag = True",
"def is_optionally_defined(self):\n return self._is_optionally_defined",
"def setFocus(*args, **kwargs)->None:\n pass",
"def editorsCheckFocusInEnabled(self):\n return self.editorsCheckFocusIn",
"def is_rule(self):\n return self._fields is not None",
"def deferrable(self) -> Optional[bool]:\n return self._deferrable",
"def is_required(self) -> bool:\n return self.required",
"def has_default(model_field: DataclassCreationFields) -> bool:\n return (model_field.field.default is not dataclasses.MISSING) or (\n model_field.field.default_factory is not dataclasses.MISSING\n )",
"def test_focus_not_on_hidden(self):\n target = 'hide_field'\n field = self.form.fields.get(target, None)\n result_name = self.form.assign_focus_field(target)\n focused = self.find_focus_field()\n\n self.assertTrue(isinstance(getattr(field, 'widget', None), (HiddenInput, MultipleHiddenInput, )))\n self.assertIn(target, self.form.fields)\n self.assertEqual(1, len(focused))\n self.assertNotEqual(target, focused[0])\n self.assertNotEqual(target, result_name)",
"def pointer_surface_has_focus(self, surface: Surface) -> bool:\n return lib.wlr_seat_pointer_surface_has_focus(self._ptr, surface._ptr)",
"def focus(self):\n raise NotImplementedError",
"def hasField(self) -> bool:\n return bool(self.__field)",
"def test_remove_previous_focus(self):\n target_1 = 'generic_field'\n result_1 = self.form.assign_focus_field(target_1)\n focused_1 = self.find_focus_field()\n\n target_2 = 'another_field'\n result_2 = self.form.assign_focus_field(target_2)\n focused_2 = self.find_focus_field()\n\n self.assertNotEqual(target_1, target_2)\n self.assertIn(target_1, self.form.fields)\n self.assertEqual(1, len(focused_1))\n self.assertEqual(target_1, focused_1[0])\n self.assertEqual(target_1, result_1)\n self.assertIn(target_2, self.form.fields)\n self.assertEqual(1, len(focused_2))\n self.assertEqual(target_2, focused_2[0])\n self.assertEqual(target_2, result_2)"
] | [
"0.6225829",
"0.6135285",
"0.6015267",
"0.5842026",
"0.5791978",
"0.570093",
"0.5611743",
"0.55692565",
"0.54178447",
"0.5409445",
"0.5406703",
"0.53621715",
"0.5328423",
"0.5315723",
"0.5312581",
"0.5309278",
"0.52890605",
"0.5272042",
"0.52682996",
"0.51996136",
"0.5184624",
"0.517283",
"0.51671904",
"0.51668066",
"0.5133052",
"0.5123844",
"0.5122558",
"0.5119526",
"0.511808",
"0.5089806"
] | 0.6568815 | 0 |
The prep_remaining method exists. Unchanged, it returns parameters unmodified. | def test_prep_remaining(self):
self.assertTrue(hasattr(self.form, 'prep_remaining'))
original_fields = self.form.fields
self.form.fields = original_fields.copy()
remaining_fields = original_fields.copy()
opts, field_rows = {'fake_opts': 'fake', 'fields': ['nope']}, [{'name': 'assigned_field'}]
args = ['arbitrary', 'input', 'args']
kwargs = {'test_1': 'data_1', 'test_2': 'data_2'}
expected = (opts.copy(), field_rows.copy(), remaining_fields.copy(), *args, kwargs.copy())
actual = self.form.prep_remaining(opts, field_rows, remaining_fields, *args, **kwargs)
self.assertEqual(expected, actual)
self.form.fields = original_fields | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pre_forward(self, *args, **kwargs):\n self.allocate_parameter()\n return args, kwargs",
"def _prepare_args(local_vars):\n return {k: v for k, v in local_vars.items() if k != 'self'}",
"def pre_forward(self, *args, **kwargs):\n batch_size = args[0].shape[0]\n if not self.instantiated:\n self.hidden_dim = args[0].shape[-1]\n self.instantiate(hidden_dim=self.hidden_dim)\n if self.past_key_reparam is None:\n past_key = self.past_key\n else:\n past_key = self.past_key_reparam\n if self.past_value_reparam is None:\n past_value = self.past_value\n else:\n past_value = self.past_value_reparam\n\n def expand_batchsize(x):\n x = x.reshape(self.prefix_token_num, self.num_heads, -1).transpose(0,1)\n x = x.unsqueeze(0).expand(batch_size, *x.shape)\n return x\n\n\n if kwargs['layer_past'] is None:\n kwargs['layer_past'] = (expand_batchsize(past_key), expand_batchsize(past_value))\n if 'attention_mask' in kwargs and kwargs['attention_mask'] is not None:\n am = kwargs['attention_mask'] # Should check the format of the attention_mask when moving to a new plm.\n kwargs['attention_mask'] = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\n return args, kwargs",
"def prepare(self):\n raise NotImplemented",
"def get_partial_arguments(self):\n return (), {}",
"def _prepare(self):",
"def _prepare(self):",
"def __returnInitialParametersLocal__(self):\n return {}",
"def prepare(self):\n\t\treturn self.api.prepare_request(self)",
"def __returnInitialParametersLocal__(self):\n return self.dmdParams",
"def pre_forward(self, *args, **kwargs):\n batch_size = args[0].shape[0]\n seq_len = args[0].shape[-2]\n if not self.instantiated:\n self.hidden_dim = args[0].shape[-1]\n self.instantiate(hidden_dim=self.hidden_dim)\n if self.past_key_reparam is None:\n past_key = self.past_key\n else:\n past_key = self.past_key_reparam\n if self.past_value_reparam is None:\n past_value = self.past_value\n else:\n past_value = self.past_value_reparam\n\n\n def expand_batchsize(x):\n x = x.reshape(self.prefix_token_num, self.num_heads, -1).transpose(0,1)\n x = x.unsqueeze(0).expand(batch_size, *x.shape)\n return x\n\n if 'position_bias' in kwargs and kwargs['position_bias'] is not None:\n if kwargs['position_bias'].shape[-1] != seq_len + self.prefix_token_num: # Then the position_bias should be re-calculated\n kwargs['position_bias'] = None\n if kwargs['past_key_value'] is None:\n kwargs['past_key_value'] = (expand_batchsize(past_key), expand_batchsize(past_value))\n\n past_key_len = kwargs['past_key_value'][0].shape[-2]\n\n if 'mask' in kwargs and kwargs['mask'] is not None:\n mask_len = kwargs['mask'].shape[-1]\n if past_key_len + seq_len == mask_len + self.prefix_token_num:\n\n am = kwargs['mask'] # Should check the format of the attention_mask when moving to a new plm.\n kwargs['mask'] = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\n return args, kwargs",
"def __prepare_parameter__(self, in_args):\n if self.__use_remote_sparse_updater__():\n self.__gradient_machine__.prefetch(in_args)\n self.__parameter_updater__.getParametersRemote()",
"def _reset_parameters(self) -> None:\n self._setup_input = {\n \"P\": csc_matrix(2.0 * self.opt.P(self.p).toarray()),\n \"q\": self.opt.q(self.p).toarray().flatten(),\n }\n if self.opt_type in CONSTRAINED_OPT:\n A = self.opt.A(self.p)\n b = self.opt.b(self.p)\n self._setup_input[\"A\"] = csc_matrix(\n cs.vertcat(self.opt.M(self.p), A, -A).toarray()\n )\n self._setup_input[\"l\"] = (\n cs.vertcat(-self.opt.c(self.p), -b, b).toarray().flatten()\n )",
"def reset_parameters(self):\n self.apply(ixvr)",
"def reset_parameters(self):\n self.apply(ixvr)",
"def shift_optional_parameters(self):\n if self.num_params() <= 1:\n return\n for i in range(1, self.num_params()):\n if self.parameters[i - 1].optional and not self.parameters[i].optional:\n self.shift_optional_parameter(i)",
"def prepare(self):",
"def __adjust(self, *args):\n return \"adjust\"",
"def prepare(self):\n pass",
"def prepare(self):\n pass",
"def prepare(self):\n pass",
"def pre_forward(self, *args, **kwargs):\n batch_size = args[0].shape[0]\n if not self.instantiated:\n self.hidden_dim = args[0].shape[-1]\n self.instantiate(hidden_dim=self.hidden_dim)\n if self.past_key_reparam is None:\n past_key = self.past_key\n else:\n past_key = self.past_key_reparam\n if self.past_value_reparam is None:\n past_value = self.past_value\n else:\n past_value = self.past_value_reparam\n\n\n def expand_batchsize(x):\n x = x.reshape(self.prefix_token_num, self.num_heads, -1).transpose(0,1)\n x = x.unsqueeze(0).expand(batch_size, *x.shape)\n return x\n # from IPython import embe\n\n if 'past_key_value' not in kwargs or kwargs['past_key_value'] is None:\n kwargs['past_key_value'] = (expand_batchsize(past_key), expand_batchsize(past_value))\n\n if 'attention_mask' in kwargs and kwargs['attention_mask'] is not None:\n am = kwargs['attention_mask'] # Should check the format of the attention_mask when moving to a new plm.\n kwargs['attention_mask'] = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\n elif len(args) >1: # attention mask is passed via positional argument\n am = args[1]\n am = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\n args = (args[0], am) + args[2:]\n # from IPython import embed\n # embed(header = \"Herein prefixroberta\")\n return args, kwargs",
"def pre_forward(self, *args, **kwargs):\n batch_size = args[0].shape[0]\n if not self.instantiated:\n self.hidden_dim = args[0].shape[-1]\n self.instantiate(hidden_dim=self.hidden_dim)\n if self.past_key_reparam is None:\n past_key = self.past_key\n else:\n past_key = self.past_key_reparam\n if self.past_value_reparam is None:\n past_value = self.past_value\n else:\n past_value = self.past_value_reparam\n\n # from IPython import embed\n # embed()\n def expand_batchsize(x):\n x = x.reshape(self.prefix_token_num, self.num_heads, -1).transpose(0,1)\n x = x.unsqueeze(0).expand(batch_size, *x.shape)\n return x\n # from IPython import embe\n\n if 'past_key_value' not in kwargs or kwargs['past_key_value'] is None:\n kwargs['past_key_value'] = (expand_batchsize(past_key), expand_batchsize(past_value))\n\n if 'attention_mask' in kwargs and kwargs['attention_mask'] is not None:\n am = kwargs['attention_mask'] # Should check the format of the attention_mask when moving to a new plm.\n kwargs['attention_mask'] = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\n elif len(args) >1: # attention mask is passed via positional argument\n am = args[1]\n am = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\n args = (args[0], am) + args[2:]\n # from IPython import embed\n # embed(header = \"Herein prefixroberta\")\n return args, kwargs",
"def preprocess_arguments(self, *args, **kwargs):\n return (args, kwargs)",
"def _prepare(self):\n logging.warning('-> preparing EMPTY experiments...')",
"def reset_parameters(self) -> None:\n \n self.classifier.apply(xavier)\n if len(self.old_cols) > 0:\n self.adaptor1.apply(xavier)\n self.adaptor2.apply(xavier)",
"def recoverParams(self):\n self.shape, self.rate = self.posterior[1] + 1, -self.posterior[0]",
"def reset_parameters(self):\n self.rnn.reset_parameters()\n self.action_lookup.reset_parameters()\n\n # self.state_dict_lookup.reset_parameters()\n self.own_c_lookup.reset.parameters()\n self.own_s_lookup.reset_parameters()\n\n self.th_1_lookup.reset_parameters()\n self.th_2_lookup.reset_parameters()\n self.th_3_lookup.reset_parameters()\n self.f_1_lookup.reset.parameters()\n self.f_2_lookup.reset_parameters()\n self.f_3_lookup.reset_parameters()\n self.f_4_lookup.reset_parameters()\n\n self.bu_msg_lookup.reset_parameters()\n\n self.i_t_lookup.reset_parameters()\n self.lives_lookup.reset_parameters()\n\n self.prev_action_lookup.reset_parameters()\n # self.message.apply(weight_reset)\n self.output.apply(weight_reset)\n for p in self.rnn.parameters():\n p.data.uniform_(*self.init_param_range)",
"def _get_remaining_input(self):\n return self.command[self.cursor:]",
"def _restore(self):\n self._logger = LOGGER\n self._param_store = pyro.get_param_store()\n self.set_state(self.best_params)\n self._alpha_guide_prior_params = dict(\n self._param_store.named_parameters()\n )"
] | [
"0.61176014",
"0.54957813",
"0.53316176",
"0.5303457",
"0.52536845",
"0.51523024",
"0.51523024",
"0.51110625",
"0.5101072",
"0.50850767",
"0.5084306",
"0.5054285",
"0.5016299",
"0.49983084",
"0.49983084",
"0.49926323",
"0.49725908",
"0.4972565",
"0.49686494",
"0.49686494",
"0.49686494",
"0.49670416",
"0.4954227",
"0.4942243",
"0.4930215",
"0.48397318",
"0.48387662",
"0.48326916",
"0.48220834",
"0.4814918"
] | 0.6892399 | 0 |
When all columns have an error, returns a list of HTML for each error from the get_error_data method. | def test_get_error_data_all_col_errors(self):
field_setup = None
error_names = None
prepared_info = self.setup_error_data(field_setup, error_names)
for row in prepared_info:
self.assertEqual(row['expected'], row['actual']) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def multi_col_error_format(self, as_type, errors, **kwargs):\n error_data = [self.error_format(as_type, error, **kwargs) for error in errors]\n row_tag = 'tr' if as_type == 'as_table' else 'li' if as_type == 'ul' else 'p'\n row_tag = kwargs.get('row_tag', row_tag)\n error_row = self.form._html_tag(row_tag, ' '.join(error_data))\n return error_row",
"def test_get_error_data_table_all_col_errors(self):\n field_setup = None\n error_names = None\n prepared_info = self.setup_error_data(field_setup, error_names, True)\n for row in prepared_info:\n self.assertEqual(row['expected'], row['actual'])",
"def setup_error_data(self, field_setup, error_names, is_table=False, col_tag='span', single_col_tag=''):\n backup_fieldset_fields = [\n ('first', 'second'),\n 'billing_address_1',\n ('billing_city', 'billing_country_area', 'billing_postcode'),\n 'last',\n ]\n field_setup = field_setup or backup_fieldset_fields\n error_names = set(error_names or flatten(field_setup))\n col_count = max([1 if isinstance(ea, str) else len(ea) for ea in field_setup])\n error_txt = \"This is a {} test error. \"\n row_info = []\n for row in field_setup:\n if isinstance(row, str):\n row = [row]\n multi_col_row = len(row) > 1\n if is_table:\n cur_tag = 'td'\n error_settings = (cur_tag, multi_col_row, col_count, True, True)\n attr = ' colspan=\"{}\"'.format(2 if multi_col_row else 2 * col_count)\n else:\n cur_tag = col_tag if multi_col_row else single_col_tag\n error_settings = (cur_tag, multi_col_row, col_count, False, False)\n attr = ''\n error_list = [error_txt.format(name) if name in error_names else '' for name in row]\n columns = [{'errors': ea} for ea in error_list]\n expected = [err if not cur_tag else self.form._html_tag(cur_tag, err, attr) for err in error_list]\n if all(ea == '' for ea in error_list):\n expected = []\n actual = self.form.get_error_data(columns, error_settings)\n row_summary = {'expected': expected, 'actual': actual, 'field_names': row, 'settings': error_settings}\n row_summary['columns'] = columns\n row_info.append(row_summary)\n return row_info",
"def test_get_error_data_some_col_errors(self):\n field_setup = None\n error_names = ['first', 'billing_address_1', 'billing_country_area']\n prepared_info = self.setup_error_data(field_setup, error_names)\n for row in prepared_info:\n self.assertEqual(row['expected'], row['actual'])\n pass",
"def test_get_error_data_table_some_col_errors(self):\n field_setup = None\n error_names = ['first', 'billing_address_1', 'billing_country_area']\n prepared_info = self.setup_error_data(field_setup, error_names, True)\n for row in prepared_info:\n self.assertEqual(row['expected'], row['actual'])\n pass",
"def get_errors(self):\n df = self.get_events()\n return df[df.error.notnull()]",
"def test_col_data_errors(self):\n help_tag = 'span'\n help_text_br = False\n label_attrs = {}\n names = ('first', 'billing_address_1')\n name = names[0]\n errors = ErrorDict()\n message = \"This is the test error message\"\n err = ValidationError(message)\n errors[name] = self.form.error_class()\n errors[name].extend(err.error_list)\n expected = [errors[name], self.form.error_class()]\n original_errors = self.form._errors\n self.form._errors = errors\n actual = []\n for name in names:\n field = self.form.fields[name]\n response = self.form.collect_col_data(name, field, help_tag, help_text_br, label_attrs)\n actual.append(response.get('errors'))\n\n for expect, got in zip(expected, actual):\n self.assertEqual(expect, got)\n\n self.form._errors = original_errors",
"def formatErrors(self):\n errorlist = []\n xepsWithErrors = sorted(\n set(self.getParseErrors() + self.getBuildErrors()),\n key=lambda x: str(x))\n if self.getErrors() or xepsWithErrors:\n if self.getErrors():\n errorlist.append(\"********** Read errors **********\")\n for error in self.getErrors():\n errorlist.append(error)\n for xep in xepsWithErrors:\n errorlist.append(\n \"********** Error report for {} **********\".format(str(xep)))\n if xep.parseErrors:\n errorlist.append(\"********** Parsing Errors **********\")\n errors = list(set(xep.parseErrors))\n for error in errors:\n errorlist.append(error)\n if xep.buildErrors:\n errorlist.append(\"********** Build Errors **********\")\n for error in xep.buildErrors:\n if len(error.splitlines()) > 4:\n error = ''.join(error.splitlines()[:4])\n errorlist.append(error)\n return '\\n'.join(errorlist)\n else:\n return None",
"def error_format(self, as_type, error, **kwargs):\n error = str(error)\n multi_field_row, txt, attr = None, '', ''\n errors_own_row = kwargs.get('errors_on_separate_row', None)\n errors_own_row = True if as_type == 'as_p' and errors_own_row is None else errors_own_row\n context = 'default_row' if errors_own_row else 'default'\n if issubclass(self.form.__class__, FormFieldsetMixIn):\n context = 'special'\n multi_field_row = kwargs.get('multi_field_row', False)\n if errors_own_row:\n context = 'row_multi' if multi_field_row else 'row'\n tag = kwargs.get('col_tag', 'span') if multi_field_row else kwargs.get('single_col_tag', '')\n if as_type in ('as_table', 'table'):\n tag = 'td'\n colspan = 2 if multi_field_row else 2 * kwargs.get('col_count', 1)\n attr += ' colspan=\"{}\"'.format(colspan)\n txt = error if not tag else self.form._html_tag(tag, error, attr) # used if as_type not in format_error\n\n format_error = {\n 'as_table': {\n 'default': '%s',\n 'default_row': '<tr><td colspan=\"2\">%s</td></tr>',\n 'normal_row': '<tr%(html_class_attr)s><th>%(label)s</th><td>%(errors)s%(field)s%(help_text)s</td></tr>',\n 'special': '%s',\n 'row': '<tr><td%s>%s</td></tr>',\n 'row_multi': '<td%s>%s</td>',\n 'special_col_data': '%(errors)s%(field)s%(help_text)s',\n },\n 'as_ul': {\n 'default': '%s',\n 'default_row': '<li>%s</li>',\n 'normal_row': '<li%(html_class_attr)s>%(errors)s%(label)s %(field)s%(help_text)s</li>',\n 'special': '%s',\n 'row': '<li>%s</li>',\n 'row_multi': '<span>%s</span>',\n 'special_col_data': '%(errors)s%(label)s %(field)s%(help_text)s',\n },\n 'as_p': {\n 'default': '%s',\n 'default_row': '%s', # errors_on_separate_row=True is the default only for 'as_p'.\n 'normal_row': '<p%(html_class_attr)s>%(label)s %(field)s%(help_text)s</p>',\n 'special': '%s',\n 'row': '<p>%s</p>',\n 'row_multi': '<span>%s</span>',\n 'special_col_data': '%(label)s %(field)s%(help_text)s',\n },\n 'as_fieldset': {\n 'default': '',\n 'default_row': '',\n 'normal_row': '',\n 'special': '%s',\n 'row': '<p>%s</p>',\n 'row_multi': '<span>%s</span>',\n 'special_col_data': '%(errors)s%(label)s %(field)s%(help_text)s',\n },\n }\n if as_type in format_error:\n error = (attr, error) if attr else error\n txt = format_error[as_type][context] % error\n if errors_own_row and not multi_field_row:\n txt += '\\n'\n return txt",
"def get_wtf_errors(self, wtf_errors):\n\t\tmessages = []\n\t\tmessages.append('<ol class=\"wtf-errors\">')\n\t\tfor field, errors in wtf_errors.iteritems():\n\t\t\tmessages.append(\"<li>\"+field+\": <br />\")\n\t\t\tfor error in errors:\n\t\t\t\tmessages.append(\"— \"+error+ \"<br />\")\n\t\t\tmessages.append(\"</li>\")\n\t\tmessages.append(\"</ol>\")\n\t\treturn \"\".join(messages)",
"def display_errors(self):\r\n\r\n def format_name(field_name):\r\n \"\"\"Formats field names for error display\"\"\"\r\n if field_name == \"celebration_tier\":\r\n return \"{wLargesse{n\"\r\n return \"{w%s{n\" % field_name.capitalize()\r\n\r\n msg = \"Please correct the following errors:\\n\"\r\n msg += \"\\n\".join(\r\n \"%s: {r%s{n\" % (format_name(field), \", \".join(errs))\r\n for field, errs in self.errors.items()\r\n )\r\n return msg",
"def _get_errors(sheet, row, col):\n field = _FIELDS['primary data']\n val = sheet.cell(row + field['row'], col + field['column']).value\n if not val:\n return []\n final_row = row + field['row']\n error = sheet.cell(final_row, col + field['column']).value\n while error:\n final_row += 1\n error = sheet.cell(final_row, col + field['column']).value\n return [sheet.cell(i, col + field['column']).value\n for i in range(row + field['row'], final_row)]",
"def print_error_data(error_data):\n\n print('\\nDays when there were more than 1% errors in HTTP :\\n')\n for day in error_data:\n print(str(day[0]) + '\\t-\\t' + str(day[1]) + '% \\n')\n print('-------------------------------------------------------\\n')",
"def format_mapping_html_data(header,\r\n mapping_data,\r\n errors,\r\n warnings):\r\n\r\n html_lines = HTML_LINES_INIT\r\n\r\n if not errors and not warnings:\r\n html_lines += \"<h1>No errors or warnings detected.<br></h1>\"\r\n # Find errors/warnings that are not in particular cells\r\n general_errors = \"\"\r\n for curr_err in errors:\r\n loc = curr_err.split('\\t')[1].strip()\r\n if loc == \"-1,-1\":\r\n general_errors += '<td bgcolor=\"red\"><font color=\"white\">' +\\\r\n curr_err.split('\\t')[0] + '<font color=\"black\"></td>'\r\n general_warnings = \"\"\r\n for curr_warning in warnings:\r\n loc = curr_warning.split('\\t')[1].strip()\r\n if loc == \"-1,-1\":\r\n general_warnings += '<td bgcolor=\"yellow\">' +\\\r\n curr_err.split('\\t')[0] + \"</td>\"\r\n\r\n html_lines += HTML_LINES_MSG % (\"+-%./ :,;_\",\r\n general_errors, general_warnings)\r\n\r\n # Check header fields, color and add popup messages if errors/warnings\r\n # are present\r\n formatted_header = \"\"\r\n for curr_field in range(len(header)):\r\n all_errs_warnings = \"\"\r\n curr_pos = \"%s,%s\" % (0, curr_field)\r\n for curr_warning in warnings:\r\n loc = curr_warning.split('\\t')[1].strip()\r\n if loc == curr_pos:\r\n bg_color = \"yellow\"\r\n font_color = \"black\"\r\n all_errs_warnings += curr_warning.split('\\t')[0] + \"<br>\"\r\n\r\n for curr_err in errors:\r\n loc = curr_err.split('\\t')[1].strip()\r\n if loc == curr_pos:\r\n bg_color = \"red\"\r\n font_color = \"white\"\r\n all_errs_warnings += curr_err.split('\\t')[0] + \"<br>\"\r\n if not all_errs_warnings:\r\n formatted_header += \"<th>%s</th>\" % header[curr_field]\r\n elif not header[curr_field]:\r\n formatted_header += \"\"\"<th bgcolor=%s><a href=\"javascript:void(0);\" onmouseover=\"return overlib('%s');\" onmouseout=\"return nd();\"><font color=%s>%s</a></th>\"\"\" % (\r\n bg_color,\r\n all_errs_warnings.replace(\r\n '\"',\r\n ''),\r\n font_color,\r\n \"missing data\")\r\n\r\n else:\r\n formatted_header += \"\"\"<th bgcolor=%s><a href=\"javascript:void(0);\" onmouseover=\"return overlib('%s');\" onmouseout=\"return nd();\"><font color=%s>%s</a></th>\"\"\" % (\r\n bg_color,\r\n all_errs_warnings.replace('\"',\r\n ''),\r\n font_color,\r\n header[curr_field])\r\n\r\n html_lines += HTML_LINES_HEADER % formatted_header\r\n\r\n formatted_data = \"\"\r\n correction_ix = 1\r\n\r\n for curr_row in range(len(mapping_data)):\r\n formatted_data += \"<tr>\"\r\n for curr_cell in range(len(mapping_data[curr_row])):\r\n all_errs_warnings = \"\"\r\n append_location = False\r\n curr_pos = \"%s,%s\" % (curr_row + correction_ix, curr_cell)\r\n for curr_warning in warnings:\r\n loc = curr_warning.split('\\t')[1].strip()\r\n if loc == curr_pos:\r\n append_location = True\r\n bg_color = \"yellow\"\r\n font_color = \"black\"\r\n all_errs_warnings += curr_warning.split('\\t')[0] + \"<br>\"\r\n\r\n for curr_err in errors:\r\n loc = curr_err.split('\\t')[1].strip()\r\n if loc == curr_pos:\r\n append_location = True\r\n bg_color = \"red\"\r\n font_color = \"white\"\r\n all_errs_warnings += curr_err.split('\\t')[0] + \"<br>\"\r\n if append_location:\r\n if len(mapping_data[curr_row][0]) == 0:\r\n sample_id_name = \"missing sample id\"\r\n else:\r\n sample_id_name = mapping_data[curr_row][0]\r\n try:\r\n header_location = header[curr_cell]\r\n except IndexError:\r\n header_location = \"no header\"\r\n location_desc = \"Location (SampleID,Header Field)<br>%s,%s\" %\\\r\n (sample_id_name, header_location)\r\n if not all_errs_warnings:\r\n formatted_data += \"<th><tt>%s</tt></th>\" %\\\r\n mapping_data[curr_row][curr_cell]\r\n elif len(mapping_data[curr_row][curr_cell].replace('\\n', '')) == 0:\r\n formatted_data += \"\"\"<th bgcolor=%s><a href=\"javascript:void(0);\" onmouseover=\"return overlib('%s');\" onmouseout=\"return nd();\"><font color=%s><tt>%s</tt></a></th>\"\"\" % (\r\n bg_color,\r\n all_errs_warnings.replace(\r\n '\"',\r\n '').replace(\r\n \"'\",\r\n \"\") + location_desc,\r\n font_color,\r\n \"missing data\")\r\n else:\r\n formatted_data += \"\"\"<th bgcolor=%s><a href=\"javascript:void(0);\" onmouseover=\"return overlib('%s');\" onmouseout=\"return nd();\"><font color=%s><tt>%s</tt></a></th>\"\"\" % (\r\n bg_color,\r\n all_errs_warnings.replace('\"',\r\n '').replace(\"'\",\r\n \"\") + location_desc,\r\n font_color,\r\n mapping_data[curr_row][curr_cell])\r\n\r\n formatted_data += \"</tr>\"\r\n html_lines += HTML_LINES_DATA % formatted_data\r\n\r\n return html_lines",
"def _find_errors_in_page(self, response):\n if response.status_code == 403:\n return \"Could not check for errors, as response was a 403 response\\\n forbidden. User asking for this url did not have permission.\"\n \n \n errors = re.search('<ul class=\"errorlist\">(.*)</ul>', \n response.content, \n re.IGNORECASE)\n\n if errors: \n #show a little around the actual error to scan for variables that\n # might have caused it\n span = errors.span()\n wide_start = max(span[0]-200,0)\n wide_end = min(span[1]+200,len(response.content)) \n wide_error = response.content[wide_start:wide_end]\n return wide_error\n \n return \"\"",
"def output_errors(self) -> List[str]:\n output = list()\n for error in sorted(self.errors):\n if len(error) == 2:\n line = f\"{error[0]} - Could not find {error[1]} in map names!\"\n else:\n line = f\"{error[0]} - {error[1]}: Could not find {error[2]} in map names!\"\n logger.error(line)\n output.append(line)\n return output",
"def test_row_from_columns_has_errors_table(self):\n errors_on_separate_row = True\n field_setup = None\n error_names = ['first', 'billing_address_1', 'billing_country_area']\n for as_type in ('p', 'ul', 'fieldset'):\n setup = self.setup_row_from_columns(as_type, field_setup, error_names, errors_on_separate_row)\n has_no_errors = setup[-1]\n for row in setup:\n if row == has_no_errors:\n self.assertEqual(len(row['expected']), 1)\n self.assertEqual(len(row['actual']), 1)\n else:\n self.assertGreater(len(row['expected']), 1)\n self.assertGreater(len(row['actual']), 1)\n self.assertEqual(row['expected'], row['actual'])",
"def columns(self):\n if self._saved_columns is None:\n # append error columns\n err_col = HXLColumn(hxlTag='#x_errors', headerText='Error messages')\n tag_col = HXLColumn(hxlTag='#x_tags', headerText='Error tag')\n row_col = HXLColumn(hxlTag='#x_rows', headerText='Error row number (source)')\n col_col = HXLColumn(hxlTag='#x_cols', headerText='Error column number (source)')\n self._saved_columns = self.source.columns + [err_col, tag_col, row_col, col_col]\n return self._saved_columns",
"def test_get_error_data_table_when_no_errors(self):\n field_setup = None\n error_names = ['non-field_name', 'not_a_field']\n prepared_info = self.setup_error_data(field_setup, error_names, True)\n for row in prepared_info:\n self.assertEqual(row['expected'], row['actual'])",
"def getErrorTable(self, *args):\n return _libsbml.LayoutExtension_getErrorTable(self, *args)",
"def get_error(self) -> List[str]:\n return []",
"def get_error(self) -> List[str]:\n return []",
"def printError(queryResults):\n print (queryResults[1])\n # For loop created for the httpErrors array\n for results in queryResults[0]:\n print (\n results[0], \"-\",\n str(results[1]) + \"% errors\")",
"def setup_row_from_columns(self, as_type, field_setup=None, error_names=None, errors_on_separate_row=True):\n col_args = ('span', as_type == 'table', {})\n is_table = as_type == 'table'\n if is_table:\n row_tag = 'tr',\n tag_info = ('th', 'td', 'td', '%(label)s', '%(errors)s%(field)s%(help_text)s')\n else:\n row_tag = 'li' if as_type == 'ul' else 'p'\n col_data = '%(errors)s%(label)s %(field)s%(help_text)s'\n if as_type == 'p':\n col_data = '%(label)s %(field)s%(help_text)s'\n tag_info = (None, 'span', '', '', col_data)\n col_html, single_col_html = self.form.column_formats(*tag_info)\n error_setup = self.setup_error_data(field_setup, error_names, is_table)\n result = []\n for row in error_setup:\n error_settings = row['settings']\n multi_field_row = error_settings[1]\n col_ct = error_settings[2]\n col_settings = (multi_field_row, col_ct, True, True) if is_table else (multi_field_row, col_ct, True, True)\n row_data = {name: self.form.fields[name] for name in row['field_names']}\n columns = self.form.collect_columns(row_data, col_settings, *col_args)\n for num, ea in enumerate(columns): # update each column with the artificial error data\n ea.update(row['columns'][num])\n html_row_attr = '' if multi_field_row or is_table else columns[0]['html_col_attr']\n cur_format = col_html if multi_field_row else single_col_html\n row_settings = (cur_format, html_row_attr, *error_settings)\n col_data = [cur_format % ea for ea in columns]\n err_data = row['actual'] if errors_on_separate_row else []\n expected = self.form.make_row(col_data, err_data, row_tag, html_row_attr)\n actual = self.form.row_from_columns(columns, row_tag, errors_on_separate_row, row_settings)\n result.append({'expected': expected, 'actual': actual})\n return result",
"def test_get_error_data_when_no_errors(self):\n field_setup = None\n error_names = ['non-field_name', 'not_a_field']\n prepared_info = self.setup_error_data(field_setup, error_names)\n for row in prepared_info:\n self.assertEqual(row['expected'], row['actual'])",
"def query_errors():\r\n conn, cur = connect()\r\n query3 = (\"select * from errors where error >1\")\r\n cur.execute(query3)\r\n res3 = cur.fetchall()\r\n conn.close()\r\n print(\"\\nDays with more than 1% of requests lead to errors:\\n\")\r\n for i in range(0, len(res3), 1):\r\n print(str(res3[i][0]) + \" --> \" + str(round(res3[i][1], 2))+\" %errors\")",
"def error_wrapper(x):\n errors = list()\n for error_key, error_list in list(x.items()):\n for error in error_list:\n if error_key == 'non_field_errors':\n errors.append(error)\n else:\n errors.append(\"%s: %s\" % (error_key, error))\n return errors",
"def test_row_from_columns_has_errors(self):\n errors_on_separate_row = True\n field_setup = None\n error_names = ['first', 'billing_address_1', 'billing_country_area']\n for as_type in ('p', 'ul', 'fieldset'):\n setup = self.setup_row_from_columns(as_type, field_setup, error_names, errors_on_separate_row)\n has_no_errors = setup[-1]\n for row in setup:\n if row == has_no_errors:\n self.assertEqual(len(row['expected']), 1)\n self.assertEqual(len(row['actual']), 1)\n else:\n self.assertGreater(len(row['expected']), 1)\n self.assertGreater(len(row['actual']), 1)\n self.assertEqual(row['expected'], row['actual'])",
"def catch_error(html_content):\n html_content = html_content.replace(\"<i>\", \"\").replace(\"</i>\", \"\")\n reg_rule = '\\( ! \\)<\\/span>([\\s\\S]*?)<\\/th>'\n res = re.findall(reg_rule, html_content)\n error_type = []\n error_info = []\n for i in res:\n error_type.append(i.split(':', 1)[0].strip())\n error_info.append(i.split(':', 1)[1].strip())\n return error_type, error_info",
"def get_error_table(errors, mean_square_wind, print_tex_string=False):\n table = pd.DataFrame()\n u = mean_square_wind\n for model in errors.columns:\n mean = errors[model].mean()\n std = errors[model].std()/len(errors.index)**0.5\n #table = \\\n # table.append({\"name\": model, \"nMSE\": mean, \"nMSEci\": 2*std, \"MSE\": mean*u, \"MSEci\": 2*std*u}, ignore_index=True)\n table = \\\n table.append({\"name\": model, \"nMSE\": mean, \"nMSEci\": 2 * std, \"MSE\": mean * u, \"MSEci\": 2 * std * u},\n ignore_index=True)\n\n table = table.sort_values(\"nMSE\", ascending=False)\n if print_tex_string:\n for _, row in table.iterrows():\n model = row[\"name\"]\n nmean = row[\"nMSE\"]\n nstd = row[\"nMSEci\"]\n mean = row[\"MSE\"]\n std = row[\"MSEci\"]\n print(f\"{model} & {nmean:.3f} $\\pm$ {nstd:.3f} & {mean:.3f} $\\pm$ {std:.3f} \\\\\\\\\")\n return table"
] | [
"0.6514373",
"0.63945425",
"0.633298",
"0.6190096",
"0.615535",
"0.6126942",
"0.6110843",
"0.604707",
"0.59112227",
"0.58642846",
"0.5820168",
"0.5799477",
"0.5793237",
"0.572578",
"0.56842726",
"0.56616896",
"0.56543785",
"0.5636649",
"0.56153303",
"0.56017125",
"0.5576056",
"0.5576056",
"0.5563915",
"0.55563277",
"0.55189675",
"0.5502886",
"0.54988194",
"0.54978037",
"0.542633",
"0.5424927"
] | 0.64467424 | 1 |
For as_table, but no errors, returns an empty list from the get_error_data method. | def test_get_error_data_table_when_no_errors(self):
field_setup = None
error_names = ['non-field_name', 'not_a_field']
prepared_info = self.setup_error_data(field_setup, error_names, True)
for row in prepared_info:
self.assertEqual(row['expected'], row['actual']) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fail_table(self):\n return self._table(self.missing())",
"def check_table(self):\n self.missing()\n return self._table(self._data_list)",
"def get_errors(self):\n df = self.get_events()\n return df[df.error.notnull()]",
"def getErrorTable(self, *args):\n return _libsbml.LayoutExtension_getErrorTable(self, *args)",
"def test_get_error_data_when_no_errors(self):\n field_setup = None\n error_names = ['non-field_name', 'not_a_field']\n prepared_info = self.setup_error_data(field_setup, error_names)\n for row in prepared_info:\n self.assertEqual(row['expected'], row['actual'])",
"def test_get_error_data_table_all_col_errors(self):\n field_setup = None\n error_names = None\n prepared_info = self.setup_error_data(field_setup, error_names, True)\n for row in prepared_info:\n self.assertEqual(row['expected'], row['actual'])",
"def error_data(self):\n\n if not self.__settings:\n return []\n\n return self.__transaction_errors",
"def GetAll(self):\n return self._errors.copy()",
"def getErrorTable(self, *args):\n return _libsbml.MultiExtension_getErrorTable(self, *args)",
"def getErrorTable(self, *args):\n return _libsbml.CompExtension_getErrorTable(self, *args)",
"def get_errors(self):\n return [result for result in self.values() if result.outcome == Result.ERROR]",
"def test_get_error_data_all_col_errors(self):\n field_setup = None\n error_names = None\n prepared_info = self.setup_error_data(field_setup, error_names)\n for row in prepared_info:\n self.assertEqual(row['expected'], row['actual'])",
"def errors(self) -> List[Error]:",
"def getErrorTable(self, *args):\n return _libsbml.QualExtension_getErrorTable(self, *args)",
"def test_get_error_data_table_some_col_errors(self):\n field_setup = None\n error_names = ['first', 'billing_address_1', 'billing_country_area']\n prepared_info = self.setup_error_data(field_setup, error_names, True)\n for row in prepared_info:\n self.assertEqual(row['expected'], row['actual'])\n pass",
"def validate_oee_error_1(self):\n sql = \"\"\"SELECT b.ROWID, b.* FROM bdefile b \n LEFT OUTER JOIN recordcode r ON b.f1=r.code WHERE code IS NULL\n \"\"\"\n lines = self.c.execute(sql).fetchall()\n return lines==[], lines",
"def getErrorTable(self, *args):\n return _libsbml.GroupsExtension_getErrorTable(self, *args)",
"def test_convert_dicts_to_teradata_rows_returns_empty_list():\n data = []\n output = row_handling.convert_dicts_to_teradata_rows(data)\n assert output == []",
"def get_error(self) -> List[str]:\n return []",
"def get_error(self) -> List[str]:\n return []",
"def test_row_from_columns_no_errors_table(self):\n errors_on_separate_row = True\n field_setup = None\n error_names = ['non-field_name', 'not_a_field']\n for as_type in ('p', 'ul', 'fieldset'):\n setup = self.setup_row_from_columns(as_type, field_setup, error_names, errors_on_separate_row)\n for row in setup:\n self.assertEqual(len(row['expected']), 1)\n self.assertEqual(len(row['actual']), 1)\n self.assertEqual(row['expected'], row['actual'])",
"def getErrorsList(self):\n return self.__errors",
"def get(self, table):\n \"\"\"Get all data entries from a specified table \"\"\"\n data = Select('*', table).all()\n if data == []:\n return {\"Error\": f\"No entries found in {table}\"}, 404\n if \"Error\" in str(data):\n return data, 500\n return data",
"def test_get_error_data_some_col_errors(self):\n field_setup = None\n error_names = ['first', 'billing_address_1', 'billing_country_area']\n prepared_info = self.setup_error_data(field_setup, error_names)\n for row in prepared_info:\n self.assertEqual(row['expected'], row['actual'])\n pass",
"def check_set_errors(self):\n response = self.read()\n return [] if response == \"\" else [response]",
"def test_row_from_columns_has_errors_table(self):\n errors_on_separate_row = True\n field_setup = None\n error_names = ['first', 'billing_address_1', 'billing_country_area']\n for as_type in ('p', 'ul', 'fieldset'):\n setup = self.setup_row_from_columns(as_type, field_setup, error_names, errors_on_separate_row)\n has_no_errors = setup[-1]\n for row in setup:\n if row == has_no_errors:\n self.assertEqual(len(row['expected']), 1)\n self.assertEqual(len(row['actual']), 1)\n else:\n self.assertGreater(len(row['expected']), 1)\n self.assertGreater(len(row['actual']), 1)\n self.assertEqual(row['expected'], row['actual'])",
"def _get_errors(sheet, row, col):\n field = _FIELDS['primary data']\n val = sheet.cell(row + field['row'], col + field['column']).value\n if not val:\n return []\n final_row = row + field['row']\n error = sheet.cell(final_row, col + field['column']).value\n while error:\n final_row += 1\n error = sheet.cell(final_row, col + field['column']).value\n return [sheet.cell(i, col + field['column']).value\n for i in range(row + field['row'], final_row)]",
"def getErrors(self) -> java.util.Collection:\n ...",
"def test_tabledata_none(self):\n self.check_response(\n '/attributes/tabledata.json',\n (r'{\"rows\": [], \"total\": 0}'))",
"def parse_error(self):\n\n # Check the table_parse_error flag\n return self.__table_parse_error"
] | [
"0.72233516",
"0.7046056",
"0.68150246",
"0.66112614",
"0.65986466",
"0.6566071",
"0.6397619",
"0.63746923",
"0.6374066",
"0.63721627",
"0.63696045",
"0.62999004",
"0.62786764",
"0.6249668",
"0.6141945",
"0.61023694",
"0.60779744",
"0.60368246",
"0.6036796",
"0.6036796",
"0.5992975",
"0.5962805",
"0.5901657",
"0.58970994",
"0.58907914",
"0.5877771",
"0.5830723",
"0.5818344",
"0.5794873",
"0.5765003"
] | 0.70959044 | 1 |
The determine_label_width method returns empty values if there are not multiple rows of a single field. | def test_label_width_not_enough_single_field_rows(self):
name, *names = list(self.form.fields.keys())
field_rows = [{name: self.form.fields[name]}]
if len(names) > 1:
double_row = {name: self.form.fields[name] for name in names[:2]}
field_rows.append(double_row)
expected = {}
actual = self.form.determine_label_width(field_rows)
self.assertEqual(expected, actual) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_determine_label_width(self):\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed_fields = self.get_allowed_width_fields()\n test_fields = allowed_fields.copy() # TODO: ? Try an input with some double and some single column rows?\n labels = [field.label or pretty_name(name) for name, field in test_fields.items()]\n full_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch\n word_width = max(len(word) for label in labels for word in label.split()) // 2\n expected_width = full_width if full_width < self.form.max_label_width else word_width\n expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(expected_width)}\n expected_attrs = {name: expected_attrs for name in list(test_fields.keys())}\n actual_attrs = self.form.determine_label_width(self.form.fields)\n\n self.assertLess(word_width, self.form.max_label_width)\n self.assertEqual(expected_attrs, actual_attrs)\n\n self.form.adjust_label_width = original_setting",
"def test_label_width_fits_full_label_if_small_enough(self):\n original_max = self.form.max_label_width\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed_fields = self.get_allowed_width_fields()\n labels = [field.label or pretty_name(name) for name, field in allowed_fields.items()]\n full_label_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch\n expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(full_label_width)}\n expected_attrs = {name: expected_attrs for name in allowed_fields}\n max_width = full_label_width + 5\n self.form.max_label_width = max_width\n actual_attrs = self.form.determine_label_width(self.form.fields)\n\n self.assertGreater(max_width, full_label_width)\n self.assertEqual(expected_attrs, actual_attrs)\n\n self.form.max_label_width = original_max\n self.form.adjust_label_width = original_setting",
"def test_word_wrap_label_width(self):\n original_max = self.form.max_label_width\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed_fields = self.get_allowed_width_fields()\n labels = [field.label or pretty_name(name) for name, field in allowed_fields.items()]\n full_label_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch\n word_width = max(len(word) for label in labels for word in label.split()) // 2\n expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(word_width)}\n expected_attrs = {name: expected_attrs for name in allowed_fields}\n max_width = word_width + 1\n self.form.max_label_width = max_width\n actual_attrs = self.form.determine_label_width(self.form.fields)\n\n self.assertLess(max_width, full_label_width)\n self.assertEqual(expected_attrs, actual_attrs)\n\n self.form.max_label_width = original_max\n self.form.adjust_label_width = original_setting",
"def label_width(self):\n return self._label_width",
"def _label_width(text):\n width = 0\n for lineno, line in enumerate(text.split(u'\\n')):\n size = [_BIG_FONT, _SMALL_FONT][lineno > 0] # Cool idiom, huh?\n width = max(width, size * len(line))\n return width",
"def test_raises_too_wide_label_width(self):\n original_max = self.form.max_label_width\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n max_width = 2\n self.form.max_label_width = max_width\n allowed_fields = self.get_allowed_width_fields()\n group_keys = list(allowed_fields.keys())\n message = \"The max_label_width of {} is not enough for the fields: {} \".format(max_width, group_keys)\n\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.determine_label_width(self.form.fields)\n\n self.form.max_label_width = original_max\n self.form.adjust_label_width = original_setting",
"def label_width(self, start, end, numlabels=None, char_width=None):\n return self.formatter.estimate_width(start, end, numlabels, char_width,\n ticker=self)",
"def estimate_width(start, end, numlabels=None, char_width=None):\n return 0, 0",
"def getWidth(self, l):\n\n return max(len(repr(s)) for s in l)",
"def test_not_adjust_label_width(self):\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = False\n expected = {}\n actual = self.form.determine_label_width(self.form.fields)\n self.assertFalse(self.form.adjust_label_width)\n self.assertEqual(expected, actual)\n self.form.adjust_label_width = original_setting",
"def test_only_correct_widget_classes(self):\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed = self.get_allowed_width_fields()\n reject_fields = {name: field for name, field in self.form.fields.items() if name not in allowed}\n expected = {}\n actual = self.form.determine_label_width(reject_fields)\n self.assertEqual(expected, actual)\n self.form.adjust_label_width = original_setting",
"def updateWidthFromLabel(self):\n prevWidth = self.rect().width()\n width = self.text.boundingRect().width() + \\\n CurrentTheme.VERSION_LABEL_MARGIN[0] - 4\n r = self.rect()\n r.setX(r.x()+(prevWidth-width)/2.0)\n r.setWidth(width)\n self.setRect(r)\n self.update()",
"def width(self):\n return len(self.rows[0])",
"def __len__(self):\n return len(self.label)",
"def test_html_output_label_attrs_table(self):\n self.label_calls = []\n def fake_label_width(rows): self.label_calls.append(rows); return {}\n original_adjust_label_width = self.form.adjust_label_width\n self.form.adjust_label_width = True\n original_label_method = self.form.determine_label_width\n self.form.determine_label_width = fake_label_width\n collected = []\n for as_type in ('as_p', 'as_ul', 'as_table', 'as_fieldset'):\n collected.append({'type': as_type, 'html': getattr(self.form, as_type)(), 'calls': self.label_calls})\n self.label_calls = []\n expected = [opts['rows'] for lbl, opts in self.form._fieldsets]\n for ea in collected:\n expect = [] if ea['type'] == 'as_table' else expected\n message = f\"Mismatch for {ea['type']} html_output. \"\n self.assertEqual(expect, ea['calls'], message)\n\n self.form.determine_label_width = original_label_method\n self.form.adjust_label_width = original_adjust_label_width\n del self.label_calls",
"def width(self):\n\t\tpass",
"def get_allowed_width_fields(self, fields=None):\n fields = fields or self.form.fields\n allowed_fields = {}\n for name, field in fields.items():\n if isinstance(field.widget, self.form.label_width_widgets):\n if not isinstance(field.widget, self.form.label_exclude_widgets):\n allowed_fields[name] = field\n return allowed_fields",
"def _width(self, array):\n return max([len(self._render(c)) for c in array ])",
"def pixwidth(self):\n return self._labelWidth * self.transform.scale[0]",
"def widths(self):\n return self._widths",
"def getWidth(self):\n return len(self._data[0])",
"def get_width(self):\n return max(map(len, self.get_lines()))",
"def width(self) -> \"EffectiveWidth\":\n if len(self.widths) == 0:\n return None\n potential_width = self.widths[0]\n for width in self.widths[1:]:\n if potential_width != width:\n return None\n return potential_width",
"def getWidth(self) -> int:\n ...",
"def width(self) -> int:",
"def width(self) -> int:",
"def calc_width(self):\n current_longest = 0\n\n for i in range(len(self.list_of_motif_objects)):\n current_object = self.list_of_motif_objects[i]\n if(len(current_object.sequence) > current_longest):\n current_longest = len(current_object.sequence)\n \n width_for_drawing = current_longest + 50 + 15 \n\n self.width = width_for_drawing + self.width_of_legend",
"def format_fields(field_data, include_empty=True):\n max_label = 0\n for (label, value) in field_data:\n label_length = len(label)\n if label_length > max_label:\n max_label = label_length\n\n fields = []\n for (label, value) in field_data:\n empty = str(value).strip() in ['', 'None']\n if not empty or include_empty:\n label_length = len(label.strip())\n extra_spaces = ' ' * (max_label - label_length)\n label_sep = ':' + extra_spaces + ' '\n joined_field = label_sep.join([label, str(value)])\n fields.append(joined_field)\n\n return '\\n'.join(fields)",
"def estimate_width(self, start, end, numlabels=None, char_width=None,\n fill_ratio = 0.2, ticker=None):\n if numlabels == 0 or char_width == 0:\n return 0, 0\n\n if ticker is None or not hasattr(ticker, \"unit\"):\n raise ValueError(\"TimeFormatter requires a scale.\")\n\n if not numlabels:\n numlabels = ticker.num_ticks(start, end)\n\n span = abs(end - start)\n if ticker:\n r = ticker.resolution\n else:\n r = span / numlabels\n unit = self._get_resolution(r, span)\n\n if unit == \"milliseconds\":\n return numlabels, numlabels * 6\n\n widths, strings = self.formats[unit]\n\n if char_width:\n # Find an appropriate resolution in self.formats and pick between\n # the various format strings\n good_widths = widths[widths * numlabels < fill_ratio * char_width]\n if len(good_widths) == 0:\n # All too big, pick the first label\n width = widths[0]\n else:\n # Pick the largest label that fits\n width = good_widths[-1]\n width *= numlabels\n else:\n # Just pick the middle of the pack of format widths\n width = widths[ int(len(widths) / 2) ] * numlabels\n\n return numlabels, width",
"def __len__(self):\r\n return len(self.labels_df)"
] | [
"0.7584676",
"0.7144227",
"0.69959676",
"0.6753862",
"0.6716436",
"0.6588278",
"0.62719077",
"0.59885305",
"0.59496754",
"0.59277505",
"0.590034",
"0.58805966",
"0.5765796",
"0.5680677",
"0.56574476",
"0.5654118",
"0.56539017",
"0.5639267",
"0.5634049",
"0.55727243",
"0.5571966",
"0.5478218",
"0.547817",
"0.5459075",
"0.5450059",
"0.5450059",
"0.5436044",
"0.54345775",
"0.542691",
"0.54081666"
] | 0.76836616 | 0 |
Returns a dict of fields that are allowed to have a label_width with the current Form settings. | def get_allowed_width_fields(self, fields=None):
fields = fields or self.form.fields
allowed_fields = {}
for name, field in fields.items():
if isinstance(field.widget, self.form.label_width_widgets):
if not isinstance(field.widget, self.form.label_exclude_widgets):
allowed_fields[name] = field
return allowed_fields | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_determine_label_width(self):\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed_fields = self.get_allowed_width_fields()\n test_fields = allowed_fields.copy() # TODO: ? Try an input with some double and some single column rows?\n labels = [field.label or pretty_name(name) for name, field in test_fields.items()]\n full_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch\n word_width = max(len(word) for label in labels for word in label.split()) // 2\n expected_width = full_width if full_width < self.form.max_label_width else word_width\n expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(expected_width)}\n expected_attrs = {name: expected_attrs for name in list(test_fields.keys())}\n actual_attrs = self.form.determine_label_width(self.form.fields)\n\n self.assertLess(word_width, self.form.max_label_width)\n self.assertEqual(expected_attrs, actual_attrs)\n\n self.form.adjust_label_width = original_setting",
"def test_label_width_not_enough_single_field_rows(self):\n name, *names = list(self.form.fields.keys())\n field_rows = [{name: self.form.fields[name]}]\n if len(names) > 1:\n double_row = {name: self.form.fields[name] for name in names[:2]}\n field_rows.append(double_row)\n expected = {}\n actual = self.form.determine_label_width(field_rows)\n self.assertEqual(expected, actual)",
"def test_only_correct_widget_classes(self):\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed = self.get_allowed_width_fields()\n reject_fields = {name: field for name, field in self.form.fields.items() if name not in allowed}\n expected = {}\n actual = self.form.determine_label_width(reject_fields)\n self.assertEqual(expected, actual)\n self.form.adjust_label_width = original_setting",
"def test_label_width_fits_full_label_if_small_enough(self):\n original_max = self.form.max_label_width\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed_fields = self.get_allowed_width_fields()\n labels = [field.label or pretty_name(name) for name, field in allowed_fields.items()]\n full_label_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch\n expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(full_label_width)}\n expected_attrs = {name: expected_attrs for name in allowed_fields}\n max_width = full_label_width + 5\n self.form.max_label_width = max_width\n actual_attrs = self.form.determine_label_width(self.form.fields)\n\n self.assertGreater(max_width, full_label_width)\n self.assertEqual(expected_attrs, actual_attrs)\n\n self.form.max_label_width = original_max\n self.form.adjust_label_width = original_setting",
"def test_raises_too_wide_label_width(self):\n original_max = self.form.max_label_width\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n max_width = 2\n self.form.max_label_width = max_width\n allowed_fields = self.get_allowed_width_fields()\n group_keys = list(allowed_fields.keys())\n message = \"The max_label_width of {} is not enough for the fields: {} \".format(max_width, group_keys)\n\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.determine_label_width(self.form.fields)\n\n self.form.max_label_width = original_max\n self.form.adjust_label_width = original_setting",
"def test_not_adjust_label_width(self):\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = False\n expected = {}\n actual = self.form.determine_label_width(self.form.fields)\n self.assertFalse(self.form.adjust_label_width)\n self.assertEqual(expected, actual)\n self.form.adjust_label_width = original_setting",
"def test_word_wrap_label_width(self):\n original_max = self.form.max_label_width\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed_fields = self.get_allowed_width_fields()\n labels = [field.label or pretty_name(name) for name, field in allowed_fields.items()]\n full_label_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch\n word_width = max(len(word) for label in labels for word in label.split()) // 2\n expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(word_width)}\n expected_attrs = {name: expected_attrs for name in allowed_fields}\n max_width = word_width + 1\n self.form.max_label_width = max_width\n actual_attrs = self.form.determine_label_width(self.form.fields)\n\n self.assertLess(max_width, full_label_width)\n self.assertEqual(expected_attrs, actual_attrs)\n\n self.form.max_label_width = original_max\n self.form.adjust_label_width = original_setting",
"def conformFormLayoutLabels(self, parentObject, padding=8):\n\t\tlabels = []\n\t\tlabelWidths = []\n\n\t\t# Find all labels in form layouts\n\t\tfor layout in parentObject.findChildren(QtWidgets.QFormLayout):\n\t\t\t# print(layout.objectName())\n\t\t\titems = (layout.itemAt(i) for i in range(layout.count()))\n\t\t\tfor item in items:\n\t\t\t\twidget = item.widget()\n\t\t\t\tif isinstance(widget, QtWidgets.QLabel):\n\t\t\t\t\tlabels.append(widget)\n\n\t\t# Find labels in first column of grid layouts\n\t\tfor layout in parentObject.findChildren(QtWidgets.QGridLayout):\n\t\t\t# print(layout.objectName())\n\t\t\titems = (layout.itemAt(i) for i in range(layout.count()))\n\t\t\tfor item in items:\n\t\t\t\twidget = item.widget()\n\t\t\t\tif isinstance(widget, QtWidgets.QLabel):\n\t\t\t\t\t# Only items in first column (there's probably a neater\n\t\t\t\t\t# way to do this)\n\t\t\t\t\tif layout.getItemPosition(layout.indexOf(widget))[1] == 0:\n\t\t\t\t\t\tlabels.append(widget)\n\n\t\t# Find label widths\n\t\tfor label in labels:\n\t\t\tfontMetrics = QtGui.QFontMetrics(label.font())\n\t\t\twidth = fontMetrics.width(label.text())\n\t\t\t# print('Width of \"%s\": %d px' %(label.text(), width))\n\t\t\tlabelWidths.append(width)\n\n\t\t# Get widest label & set all labels widths to match\n\t\tif labelWidths:\n\t\t\tmaxWidth = max(labelWidths)\n\t\t\t# print(\"Max label width : %d px (%d inc padding)\" %(maxWidth, maxWidth+padding))\n\t\t\tfor label in labels:\n\t\t\t\tlabel.setFixedWidth(maxWidth+padding)\n\t\t\t\tlabel.setAlignment(QtCore.Qt.AlignVCenter|QtCore.Qt.AlignRight)\n\t\t\t\tlabel.setProperty('formLabel', True) # Set custom property for styling",
"def show_fieldsetform(form):\n return {'form': form, 'required_fields': True}",
"def fields(self):\n _fields = {\n i: attrgetter(i) for i in ('pf_type', 'label',)\n }\n _fields['host'] = self.get_safely_instance_partial(Host, 'host')\n return _fields",
"def get_field_name_to_label_map(form, keys_to_remove=[], values_to_remove=[]):\n if not keys_to_remove:\n keys_to_remove = get_ignorable_form_fields([])\n\n if not values_to_remove:\n values_to_remove = get_ignorable_form_values()\n\n field_name_to_label_map = clean_dict(\n map_field_name_to_label(form),\n keys_to_remove,\n values_to_remove\n )\n\n return field_name_to_label_map",
"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 return form",
"def createFormatMap(self, form, renderable, **extras):\n\n fmtmap = renderable.__dict__.copy()\n fmtmap.update(extras)\n\n def replaceVars(match):\n\n try:\n var = match.group()[2:-1]\n if var and var.endswith(\":lexical\"):\n var = var[:-len(\":lexical\")]\n value = form.getFieldValue(var, lexical=True) or ''\n else:\n value = form.getFieldValue(var) or ''\n\n if not isinstance(value, str):\n if not hasattr(value, \"decode\"):\n value = str(value)\n value = value.decode('utf-8')\n return value\n except:\n return match.group()\n\n # process labels and hints\n if 'label' in fmtmap and fmtmap['label'] != None:\n fmtmap['label'] = VAREXP.sub(replaceVars, fmtmap['label'])\n if 'hint' in fmtmap and fmtmap['hint'] != None:\n fmtmap['hint'] = VAREXP.sub(replaceVars, fmtmap['hint'])\n if 'text' in fmtmap and fmtmap['text'] != None:\n fmtmap['text'] = VAREXP.sub(replaceVars, fmtmap['text'])\n if 'placeholder' in fmtmap and fmtmap['placeholder'] != None:\n fmtmap['placeholder'] = VAREXP.sub(replaceVars,\n fmtmap['placeholder'])\n\n # defaults\n extra_classes = {'relevant': True, 'required': False,\n 'readonly': False, 'error': False}\n\n # Let's see whether we got properties here...\n try:\n if hasattr(renderable, 'bind') and renderable.bind:\n # Requiredness\n if form.model.isRequired(renderable.bind, form.data):\n extra_classes[\"required\"] = True\n\n if not form.model.isRelevant(renderable.bind, form.data):\n extra_classes[\"relevant\"] = False\n\n # Read only\n if form.model.isReadonly(renderable.bind, form.data):\n extra_classes[\"readonly\"] = True\n\n elif hasattr(renderable, 'getRenderables') and \\\n callable(renderable.getRenderables):\n\n # Group relevance\n if not form.model.isGroupRelevant(renderable, form.data):\n extra_classes[\"relevant\"] = False\n\n except:\n pass\n\n if extras.get(\"errors\", None) and \\\n hasattr(renderable, 'bind') and renderable.bind and \\\n extras['errors'].get(renderable.bind, None):\n\n extra_classes['error'] = True\n\n if getattr(renderable, 'alert', ''):\n fmtmap['alert'] = renderable.alert\n else:\n fmtmap['alert'] = \"; \".join(extras['errors'][renderable.bind])\n\n else:\n\n fmtmap['alert'] = ''\n\n if \"extra_classes\" in fmtmap:\n fmtmap['extra_classes'] = \" \".join([fmtmap['extra_classes']] + \\\n [key for key in\n list(extra_classes.keys())\n if extra_classes[key]])\n else:\n fmtmap['extra_classes'] = \" \".join([key for key in\n list(extra_classes.keys()) if\n extra_classes[key]])\n\n fmtmap['type'] = self.getType(renderable)\n\n return fmtmap",
"def show_fieldsetform_nrf(form):\n return {'form': form, 'required_fields': False}",
"def make_fields(self):\n #Let's first get fields in material_information printer_information\n metadata = GUI.api.get_metadata()\n field_correct_form = filter(lambda field: field['form_name']=='material_information' or field['form_name'] == 'printer_information', metadata)\n rows_w_fields = []\n for field in field_correct_form:\n #make label\n row = []\n key = field['field_name']\n type = field['field_type']\n row.append(sg.Text(text = field['field_label'], key=key+\"_label\"))#keys for labels are key_label (ex. record_id_label)\n if(type == 'radio' or type == \"dropdown\"):\n options = utils.get_options(field)\n row.append(sg.Combo(options, key=key, disabled= True, metadata=True, enable_events=True))\n elif(type == \"yesno\"):\n options = [\"Yes\", \"No\"]\n row.append(sg.Combo(options, key=key, disabled= True, metadata=True, enable_events=True))\n elif(type == \"text\"):\n row.append(sg.Input(key=key, disabled=True, metadata=True))\n else:#descirptive\n row[0] = sg.Text(text = field['field_label'], key=key, metadata=True)#we only need text in this case\n rows_w_fields.append(row)\n return rows_w_fields",
"def label_width(self):\n return self._label_width",
"def _generate_form_fields(self):\n params = list(filter(lambda x: (x.precedence is None or x.precedence >= 0) and not x.constant,\n self.param.params().values()))\n for p in sorted(params, key=lambda p: p.precedence or 9999):\n # TODO: Pass p.__dict__ as second argument instead of arbitrary\n p_name = p.name\n\n # Preserve param tuple type.\n if self.data:\n if isinstance(getattr(self.param, p.name), tuple):\n p.default = tuple(self.data.getlist(p.name))\n\n # Preserve initial options for Selector\n if isinstance(self.param.params()[p_name], (param.FileSelector, param.MultiFileSelector)):\n p.default = \"\"\n\n self.fields[p_name] = self.widget_map[type(p)](self.param, p, p.name)\n self.fields[p_name].label = p.name.replace(\"_\", \" \").title()\n if self.read_only is None:\n widget_attribute = {'class': 'form-control'}\n else:\n # TODO: Should this be readonly instead of disable?\n widget_attribute = {'class': 'form-control', 'disabled': self.read_only}\n self.fields[p_name].widget.attrs.update(widget_attribute)\n self.fields[p_name].required = not self.param.params()[p_name].allow_None\n self.fields[p_name].disabled = self.param.params()[p_name].constant\n self.fields[p_name].help_text = self.param.params()[p_name].doc\n # self.fields = self.base_fields",
"def render_custom_fields(form):\n return {\n 'form': form,\n }",
"def get_field_weights(self):\n weights = {}\n for field_name, field in self.fields.items():\n if field.boost:\n weights[field_name] = field.boost\n return weights",
"def fields(self, required=False):\n form = h.simplsale_form(self._index_xml)\n if required:\n required = '.required'\n else:\n required = ''\n elements = CSSSelector('input[type!=\"submit\"]%s, select%s'\n % (required, required))(form)\n names = []\n for e in elements:\n name = e.attrib.get('name', None)\n if name is not None:\n names.append(name)\n if 'billing_amount' in names and not required:\n names.extend(['billing_amount_price', 'billing_amount_name'])\n d = dict((key, '') for key in names)\n return d",
"def test_html_output_label_attrs_table(self):\n self.label_calls = []\n def fake_label_width(rows): self.label_calls.append(rows); return {}\n original_adjust_label_width = self.form.adjust_label_width\n self.form.adjust_label_width = True\n original_label_method = self.form.determine_label_width\n self.form.determine_label_width = fake_label_width\n collected = []\n for as_type in ('as_p', 'as_ul', 'as_table', 'as_fieldset'):\n collected.append({'type': as_type, 'html': getattr(self.form, as_type)(), 'calls': self.label_calls})\n self.label_calls = []\n expected = [opts['rows'] for lbl, opts in self.form._fieldsets]\n for ea in collected:\n expect = [] if ea['type'] == 'as_table' else expected\n message = f\"Mismatch for {ea['type']} html_output. \"\n self.assertEqual(expect, ea['calls'], message)\n\n self.form.determine_label_width = original_label_method\n self.form.adjust_label_width = original_adjust_label_width\n del self.label_calls",
"def get_under_18_fields():\n under_18_fields = [\n 'B01001_003E', # Male:!!Under 5 years\n 'B01001_004E', # Male:!!5 to 9 years\n 'B01001_005E', # Male:!!10 to 14 years\n 'B01001_006E', # Male:!!15 to 17 years\n 'B01001_027E', # Female:!!Under 5 years\n 'B01001_028E', # Female:!!5 to 9 years\n 'B01001_029E', # Female:!!10 to 14 years\n 'B01001_030E' # Female:!!15 to 17 years\n ]\n \n under_18_fields = { 'label': 'Over 18', 'fields': under_18_fields }\n\n return under_18_fields",
"def checkFieldMappings(self, param):\n field_mappings = param.value\n over_fields = []\n fields_warning = ('The following visible field name(s) are' +\n ' over 10 characters and will be shortened' +\n ' automatically by ArcGIS: ')\n for idx, val in enumerate(range(field_mappings.count)):\n if field_mappings.getVisible(idx) == 'VISIBLE':\n field = field_mappings.getNewName(idx)\n if len(field) > 10:\n over_fields.append(field)\n if over_fields:\n param.setWarningMessage(fields_warning + \", \".join(over_fields))\n else:\n param.clearMessage()",
"def get_connection_form_widgets() -> dict[str, Any]:\n from flask_appbuilder.fieldwidgets import BS3TextFieldWidget\n from flask_babel import lazy_gettext\n from wtforms import PasswordField, StringField\n\n return {\n \"fully_qualified_namespace\": StringField(\n lazy_gettext(\"Fully Qualified Namespace\"), widget=BS3TextFieldWidget()\n ),\n \"credential\": PasswordField(lazy_gettext(\"Credential\"), widget=BS3TextFieldWidget()),\n }",
"def fieldsToLengthBits(thisPacket):\n for field in thisPacket.iter('field'):\n if fieldLooksLikeBitmask(field):\n reMatch = bitmaskRE.match(field.attrib['showname'])\n field.attrib['lengthBits'] = str(len(reMatch.group(1).replace(' ','').replace('.','')))\n elif 'size' in field.attrib:\n field.attrib['lengthBits'] = str(8*int(field.attrib['size']))\n else:\n raise AssertionError(\"Missing size on non-bitmask field \"+field.attrib['name'])",
"def get_all_fields(context):\n\n schema = zope.component.getUtility(\n IDexterityFTI, name=context.portal_type).lookupSchema()\n fields = dict((fieldname, schema[fieldname]) for fieldname in schema)\n\n assignable = IBehaviorAssignable(context)\n for behavior in assignable.enumerateBehaviors():\n behavior_schema = behavior.interface\n fields.update((name, behavior_schema[name])\n for name in behavior_schema)\n\n return fields",
"def fields(self):\n return {k:getattr(self, k, None) for k in self.schema.fields}",
"def field_labels(label_row, datum_row):\n return dict(zip(label_row, datum_row))",
"def field_names(self):\n\n entry_time_name = forms_builder.forms.models.FormEntry._meta.get_field('entry_time').verbose_name.title()\n document_title_name = Document._meta.get_field('name').verbose_name.title()\n document_url_name = Document._meta.get_field('url').verbose_name.title()\n\n form = self.form.all()[0]\n return ['user'] \\\n + [document_title_name, document_url_name] \\\n + [f.label\n for f in form.fields.all()] \\\n + [entry_time_name]",
"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 }"
] | [
"0.6926243",
"0.67922205",
"0.65030986",
"0.6348227",
"0.62569344",
"0.62152576",
"0.60450655",
"0.5798008",
"0.5680771",
"0.56420004",
"0.5495756",
"0.54944915",
"0.5481224",
"0.5414982",
"0.53760886",
"0.5371737",
"0.53142047",
"0.5259465",
"0.5247573",
"0.5178113",
"0.51749796",
"0.51492906",
"0.5132101",
"0.51258403",
"0.5081769",
"0.5077647",
"0.5076754",
"0.50624704",
"0.50540334",
"0.50476736"
] | 0.8165431 | 0 |
If all excluded based on accepted & rejected widgets, determine_label_width method returns empty values. | def test_only_correct_widget_classes(self):
original_setting = self.form.adjust_label_width
self.form.adjust_label_width = True
allowed = self.get_allowed_width_fields()
reject_fields = {name: field for name, field in self.form.fields.items() if name not in allowed}
expected = {}
actual = self.form.determine_label_width(reject_fields)
self.assertEqual(expected, actual)
self.form.adjust_label_width = original_setting | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_determine_label_width(self):\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed_fields = self.get_allowed_width_fields()\n test_fields = allowed_fields.copy() # TODO: ? Try an input with some double and some single column rows?\n labels = [field.label or pretty_name(name) for name, field in test_fields.items()]\n full_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch\n word_width = max(len(word) for label in labels for word in label.split()) // 2\n expected_width = full_width if full_width < self.form.max_label_width else word_width\n expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(expected_width)}\n expected_attrs = {name: expected_attrs for name in list(test_fields.keys())}\n actual_attrs = self.form.determine_label_width(self.form.fields)\n\n self.assertLess(word_width, self.form.max_label_width)\n self.assertEqual(expected_attrs, actual_attrs)\n\n self.form.adjust_label_width = original_setting",
"def test_not_adjust_label_width(self):\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = False\n expected = {}\n actual = self.form.determine_label_width(self.form.fields)\n self.assertFalse(self.form.adjust_label_width)\n self.assertEqual(expected, actual)\n self.form.adjust_label_width = original_setting",
"def test_label_width_fits_full_label_if_small_enough(self):\n original_max = self.form.max_label_width\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed_fields = self.get_allowed_width_fields()\n labels = [field.label or pretty_name(name) for name, field in allowed_fields.items()]\n full_label_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch\n expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(full_label_width)}\n expected_attrs = {name: expected_attrs for name in allowed_fields}\n max_width = full_label_width + 5\n self.form.max_label_width = max_width\n actual_attrs = self.form.determine_label_width(self.form.fields)\n\n self.assertGreater(max_width, full_label_width)\n self.assertEqual(expected_attrs, actual_attrs)\n\n self.form.max_label_width = original_max\n self.form.adjust_label_width = original_setting",
"def test_raises_too_wide_label_width(self):\n original_max = self.form.max_label_width\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n max_width = 2\n self.form.max_label_width = max_width\n allowed_fields = self.get_allowed_width_fields()\n group_keys = list(allowed_fields.keys())\n message = \"The max_label_width of {} is not enough for the fields: {} \".format(max_width, group_keys)\n\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.determine_label_width(self.form.fields)\n\n self.form.max_label_width = original_max\n self.form.adjust_label_width = original_setting",
"def test_word_wrap_label_width(self):\n original_max = self.form.max_label_width\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed_fields = self.get_allowed_width_fields()\n labels = [field.label or pretty_name(name) for name, field in allowed_fields.items()]\n full_label_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch\n word_width = max(len(word) for label in labels for word in label.split()) // 2\n expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(word_width)}\n expected_attrs = {name: expected_attrs for name in allowed_fields}\n max_width = word_width + 1\n self.form.max_label_width = max_width\n actual_attrs = self.form.determine_label_width(self.form.fields)\n\n self.assertLess(max_width, full_label_width)\n self.assertEqual(expected_attrs, actual_attrs)\n\n self.form.max_label_width = original_max\n self.form.adjust_label_width = original_setting",
"def get_allowed_width_fields(self, fields=None):\n fields = fields or self.form.fields\n allowed_fields = {}\n for name, field in fields.items():\n if isinstance(field.widget, self.form.label_width_widgets):\n if not isinstance(field.widget, self.form.label_exclude_widgets):\n allowed_fields[name] = field\n return allowed_fields",
"def test_label_width_not_enough_single_field_rows(self):\n name, *names = list(self.form.fields.keys())\n field_rows = [{name: self.form.fields[name]}]\n if len(names) > 1:\n double_row = {name: self.form.fields[name] for name in names[:2]}\n field_rows.append(double_row)\n expected = {}\n actual = self.form.determine_label_width(field_rows)\n self.assertEqual(expected, actual)",
"def label_width(self):\n return self._label_width",
"def conformFormLayoutLabels(self, parentObject, padding=8):\n\t\tlabels = []\n\t\tlabelWidths = []\n\n\t\t# Find all labels in form layouts\n\t\tfor layout in parentObject.findChildren(QtWidgets.QFormLayout):\n\t\t\t# print(layout.objectName())\n\t\t\titems = (layout.itemAt(i) for i in range(layout.count()))\n\t\t\tfor item in items:\n\t\t\t\twidget = item.widget()\n\t\t\t\tif isinstance(widget, QtWidgets.QLabel):\n\t\t\t\t\tlabels.append(widget)\n\n\t\t# Find labels in first column of grid layouts\n\t\tfor layout in parentObject.findChildren(QtWidgets.QGridLayout):\n\t\t\t# print(layout.objectName())\n\t\t\titems = (layout.itemAt(i) for i in range(layout.count()))\n\t\t\tfor item in items:\n\t\t\t\twidget = item.widget()\n\t\t\t\tif isinstance(widget, QtWidgets.QLabel):\n\t\t\t\t\t# Only items in first column (there's probably a neater\n\t\t\t\t\t# way to do this)\n\t\t\t\t\tif layout.getItemPosition(layout.indexOf(widget))[1] == 0:\n\t\t\t\t\t\tlabels.append(widget)\n\n\t\t# Find label widths\n\t\tfor label in labels:\n\t\t\tfontMetrics = QtGui.QFontMetrics(label.font())\n\t\t\twidth = fontMetrics.width(label.text())\n\t\t\t# print('Width of \"%s\": %d px' %(label.text(), width))\n\t\t\tlabelWidths.append(width)\n\n\t\t# Get widest label & set all labels widths to match\n\t\tif labelWidths:\n\t\t\tmaxWidth = max(labelWidths)\n\t\t\t# print(\"Max label width : %d px (%d inc padding)\" %(maxWidth, maxWidth+padding))\n\t\t\tfor label in labels:\n\t\t\t\tlabel.setFixedWidth(maxWidth+padding)\n\t\t\t\tlabel.setAlignment(QtCore.Qt.AlignVCenter|QtCore.Qt.AlignRight)\n\t\t\t\tlabel.setProperty('formLabel', True) # Set custom property for styling",
"def test_empty_widget_width(layout):\n l = layout()\n assert l.get_content_width(Widget(), Size(80, 24), Size(80, 24)) == 0",
"def updateWidthFromLabel(self):\n prevWidth = self.rect().width()\n width = self.text.boundingRect().width() + \\\n CurrentTheme.VERSION_LABEL_MARGIN[0] - 4\n r = self.rect()\n r.setX(r.x()+(prevWidth-width)/2.0)\n r.setWidth(width)\n self.setRect(r)\n self.update()",
"def DoGetBestSize(self):\n\n w, h, useMin = self._GetLabelSize()\n if self.style & wx.BU_EXACTFIT:\n width = w + 2 + 2 * self.bezelWidth + 4 * int(self.useFocusInd)\n height = h + 2 + 2 * self.bezelWidth + 4 * int(self.useFocusInd)\n else:\n defSize = wx.Button.GetDefaultSize()\n width = 12 + w\n if useMin and width < defSize.width:\n width = defSize.width\n height = 11 + h\n if useMin and height < defSize.height:\n height = defSize.height\n width = width + self.bezelWidth - 1\n height = height + self.bezelWidth - 1\n\n return wx.Size(width, height)",
"def _label_width(text):\n width = 0\n for lineno, line in enumerate(text.split(u'\\n')):\n size = [_BIG_FONT, _SMALL_FONT][lineno > 0] # Cool idiom, huh?\n width = max(width, size * len(line))\n return width",
"def estimate_width(start, end, numlabels=None, char_width=None):\n return 0, 0",
"def _extra_width(self) -> int:\n width = 0\n if self.box and self.show_edge:\n width += 2\n if self.box:\n width += len(self.columns) - 1\n return width",
"def width(self) -> \"EffectiveWidth\":\n if len(self.widths) == 0:\n return None\n potential_width = self.widths[0]\n for width in self.widths[1:]:\n if potential_width != width:\n return None\n return potential_width",
"def label_width(self, start, end, numlabels=None, char_width=None):\n return self.formatter.estimate_width(start, end, numlabels, char_width,\n ticker=self)",
"def __len__(self):\n return len(self.label)",
"def get_trimmed_label_widget(text, position, font_size, max_width):\n \n text_changed = False\n label_obj = MTLabel(label = text,\n pos = position,\n font_size = font_size,\n autowidth = True)\n \n while label_obj.width > max_width:\n \n text = text[:-1]\n \n text_changed = True\n label_obj = MTLabel(label = \"%s...\" % text,\n pos = position,\n font_size = font_size,\n autowidth = True)\n \n if text_changed:\n text = \"%s...\" % text\n \n return (label_obj, text)",
"def min_width(self):\n ...",
"def GetLabelSize(self, dc, wnd, item):\r\n\r\n dc.SetFont(self._font)\r\n label_size = GetLabelSize(dc, item.GetLabel(), self._orientation != AUI_TBTOOL_HORIZONTAL)\r\n\r\n return wx.Size(item.GetMinSize().GetWidth(), label_size.GetHeight())",
"def size(self):\n\t\treturn len(self.lables)",
"def widget_width(self) -> Tuple[int, int]:\n return self.widget_size[0]",
"def GetLabelSize(self, label):\r\n\r\n dc = wx.ClientDC(self)\r\n dc.SetFont(self._font)\r\n\r\n return GetLabelSize(dc, label, self._tool_orientation != AUI_TBTOOL_HORIZONTAL)",
"def get_tightbbox(self, renderer, *args, **kwargs):\n self._hide_labels()\n self._altx_overrides()\n self._alty_overrides()\n self._dualx_overrides()\n self._dualy_overrides()\n self._datex_rotate()\n if self._inset_parent is not None and self._inset_zoom:\n self.indicate_inset_zoom()\n return super().get_tightbbox(renderer, *args, **kwargs)",
"def widths(self):\n return self._widths",
"def complete_opt_width(self, *_):\n return [\"auto\"]",
"def find_empty(self):\n min_num_choices = 10\n ret_x, ret_y = (-1, -1)\n\n for x in range(0, 9):\n for y in range(0, 9):\n if self.field[x][y] != -1:\n continue\n\n if (min_num_choices > len(self.choices[x][y])):\n min_num_choices = len(self.choices[x][y])\n ret_x = x\n ret_y = y\n\n return (ret_x, ret_y)",
"def number_syllables(self):\n return len(self.array_form)",
"def calc_width(self):\n current_longest = 0\n\n for i in range(len(self.list_of_motif_objects)):\n current_object = self.list_of_motif_objects[i]\n if(len(current_object.sequence) > current_longest):\n current_longest = len(current_object.sequence)\n \n width_for_drawing = current_longest + 50 + 15 \n\n self.width = width_for_drawing + self.width_of_legend"
] | [
"0.6900942",
"0.6662642",
"0.6632147",
"0.65091807",
"0.63519573",
"0.6130144",
"0.59320104",
"0.5691575",
"0.56476486",
"0.5532103",
"0.5417186",
"0.53969026",
"0.5254832",
"0.5161755",
"0.51483375",
"0.51461124",
"0.51221085",
"0.5091557",
"0.5088456",
"0.5035986",
"0.50245595",
"0.50167155",
"0.5013616",
"0.496529",
"0.4872425",
"0.48611358",
"0.48583767",
"0.4824418",
"0.47951466",
"0.47771895"
] | 0.74192923 | 0 |
The determine_label_width method raises ImproperlyConfigured if the computed width is greater than max. | def test_raises_too_wide_label_width(self):
original_max = self.form.max_label_width
original_setting = self.form.adjust_label_width
self.form.adjust_label_width = True
max_width = 2
self.form.max_label_width = max_width
allowed_fields = self.get_allowed_width_fields()
group_keys = list(allowed_fields.keys())
message = "The max_label_width of {} is not enough for the fields: {} ".format(max_width, group_keys)
with self.assertRaisesMessage(ImproperlyConfigured, message):
self.form.determine_label_width(self.form.fields)
self.form.max_label_width = original_max
self.form.adjust_label_width = original_setting | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_determine_label_width(self):\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed_fields = self.get_allowed_width_fields()\n test_fields = allowed_fields.copy() # TODO: ? Try an input with some double and some single column rows?\n labels = [field.label or pretty_name(name) for name, field in test_fields.items()]\n full_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch\n word_width = max(len(word) for label in labels for word in label.split()) // 2\n expected_width = full_width if full_width < self.form.max_label_width else word_width\n expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(expected_width)}\n expected_attrs = {name: expected_attrs for name in list(test_fields.keys())}\n actual_attrs = self.form.determine_label_width(self.form.fields)\n\n self.assertLess(word_width, self.form.max_label_width)\n self.assertEqual(expected_attrs, actual_attrs)\n\n self.form.adjust_label_width = original_setting",
"def test_label_width_fits_full_label_if_small_enough(self):\n original_max = self.form.max_label_width\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed_fields = self.get_allowed_width_fields()\n labels = [field.label or pretty_name(name) for name, field in allowed_fields.items()]\n full_label_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch\n expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(full_label_width)}\n expected_attrs = {name: expected_attrs for name in allowed_fields}\n max_width = full_label_width + 5\n self.form.max_label_width = max_width\n actual_attrs = self.form.determine_label_width(self.form.fields)\n\n self.assertGreater(max_width, full_label_width)\n self.assertEqual(expected_attrs, actual_attrs)\n\n self.form.max_label_width = original_max\n self.form.adjust_label_width = original_setting",
"def test_word_wrap_label_width(self):\n original_max = self.form.max_label_width\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed_fields = self.get_allowed_width_fields()\n labels = [field.label or pretty_name(name) for name, field in allowed_fields.items()]\n full_label_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch\n word_width = max(len(word) for label in labels for word in label.split()) // 2\n expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(word_width)}\n expected_attrs = {name: expected_attrs for name in allowed_fields}\n max_width = word_width + 1\n self.form.max_label_width = max_width\n actual_attrs = self.form.determine_label_width(self.form.fields)\n\n self.assertLess(max_width, full_label_width)\n self.assertEqual(expected_attrs, actual_attrs)\n\n self.form.max_label_width = original_max\n self.form.adjust_label_width = original_setting",
"def label_width(self):\n return self._label_width",
"def max_width(self):\n ...",
"def _label_width(text):\n width = 0\n for lineno, line in enumerate(text.split(u'\\n')):\n size = [_BIG_FONT, _SMALL_FONT][lineno > 0] # Cool idiom, huh?\n width = max(width, size * len(line))\n return width",
"def label_width(self, start, end, numlabels=None, char_width=None):\n return self.formatter.estimate_width(start, end, numlabels, char_width,\n ticker=self)",
"def estimate_width(start, end, numlabels=None, char_width=None):\n return 0, 0",
"def min_width(self):\n ...",
"def test_only_correct_widget_classes(self):\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed = self.get_allowed_width_fields()\n reject_fields = {name: field for name, field in self.form.fields.items() if name not in allowed}\n expected = {}\n actual = self.form.determine_label_width(reject_fields)\n self.assertEqual(expected, actual)\n self.form.adjust_label_width = original_setting",
"def test_not_adjust_label_width(self):\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = False\n expected = {}\n actual = self.form.determine_label_width(self.form.fields)\n self.assertFalse(self.form.adjust_label_width)\n self.assertEqual(expected, actual)\n self.form.adjust_label_width = original_setting",
"def pixwidth(self):\n return self._labelWidth * self.transform.scale[0]",
"def max_width(self) -> int:\n return UIMetric.parse(self.props.max_width).to_pixels(self.parent.width)",
"def updateWidthFromLabel(self):\n prevWidth = self.rect().width()\n width = self.text.boundingRect().width() + \\\n CurrentTheme.VERSION_LABEL_MARGIN[0] - 4\n r = self.rect()\n r.setX(r.x()+(prevWidth-width)/2.0)\n r.setWidth(width)\n self.setRect(r)\n self.update()",
"def width(self):\n\t\tpass",
"def innerWidth(self):\n raise NotImplementedError",
"def getWidth(self) -> int:\n ...",
"def get_width(self):\n return max(map(len, self.get_lines()))",
"def test_label_width_not_enough_single_field_rows(self):\n name, *names = list(self.form.fields.keys())\n field_rows = [{name: self.form.fields[name]}]\n if len(names) > 1:\n double_row = {name: self.form.fields[name] for name in names[:2]}\n field_rows.append(double_row)\n expected = {}\n actual = self.form.determine_label_width(field_rows)\n self.assertEqual(expected, actual)",
"def width(self) -> int:\n if self.props.max_width:\n max_width = UIMetric.parse(self.props.max_width).to_pixels(self.parent.width)\n return min(self.isize[0].to_pixels(self.parent.width), max_width)\n else:\n return self.isize[0].to_pixels(self.parent.width)",
"def width(self) -> int:",
"def width(self) -> int:",
"def set_width( self, width ):\n # label seems to be the controlling thing\n self.label_widget.configure( width = width )",
"def calc_width(self):\n current_longest = 0\n\n for i in range(len(self.list_of_motif_objects)):\n current_object = self.list_of_motif_objects[i]\n if(len(current_object.sequence) > current_longest):\n current_longest = len(current_object.sequence)\n \n width_for_drawing = current_longest + 50 + 15 \n\n self.width = width_for_drawing + self.width_of_legend",
"def get_dimension_width(self):\n pass",
"def width(self, value):\n self.data_validator(\"width\", value)\n self.__width = value",
"def getWidth(self):\n return DEFAULT_WIDTH",
"def __len__(self):\n return len(self.label)",
"def getWidth(self, l):\n\n return max(len(repr(s)) for s in l)",
"def get_default_item_label_maxlength(self):\n return 15"
] | [
"0.73650086",
"0.7321378",
"0.7114164",
"0.70857173",
"0.69556487",
"0.6784753",
"0.6699411",
"0.6364969",
"0.6299058",
"0.6297865",
"0.62883717",
"0.6205101",
"0.61536425",
"0.6092609",
"0.6080728",
"0.6022229",
"0.6009686",
"0.5990843",
"0.5984443",
"0.5941904",
"0.5913759",
"0.5913759",
"0.58910817",
"0.58730674",
"0.5864147",
"0.5838438",
"0.58042127",
"0.5803509",
"0.58021",
"0.5758853"
] | 0.8070989 | 0 |
The determine_label_width method sets width based on word length if full label would exceed the max. | def test_word_wrap_label_width(self):
original_max = self.form.max_label_width
original_setting = self.form.adjust_label_width
self.form.adjust_label_width = True
allowed_fields = self.get_allowed_width_fields()
labels = [field.label or pretty_name(name) for name, field in allowed_fields.items()]
full_label_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch
word_width = max(len(word) for label in labels for word in label.split()) // 2
expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(word_width)}
expected_attrs = {name: expected_attrs for name in allowed_fields}
max_width = word_width + 1
self.form.max_label_width = max_width
actual_attrs = self.form.determine_label_width(self.form.fields)
self.assertLess(max_width, full_label_width)
self.assertEqual(expected_attrs, actual_attrs)
self.form.max_label_width = original_max
self.form.adjust_label_width = original_setting | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_label_width_fits_full_label_if_small_enough(self):\n original_max = self.form.max_label_width\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed_fields = self.get_allowed_width_fields()\n labels = [field.label or pretty_name(name) for name, field in allowed_fields.items()]\n full_label_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch\n expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(full_label_width)}\n expected_attrs = {name: expected_attrs for name in allowed_fields}\n max_width = full_label_width + 5\n self.form.max_label_width = max_width\n actual_attrs = self.form.determine_label_width(self.form.fields)\n\n self.assertGreater(max_width, full_label_width)\n self.assertEqual(expected_attrs, actual_attrs)\n\n self.form.max_label_width = original_max\n self.form.adjust_label_width = original_setting",
"def _label_width(text):\n width = 0\n for lineno, line in enumerate(text.split(u'\\n')):\n size = [_BIG_FONT, _SMALL_FONT][lineno > 0] # Cool idiom, huh?\n width = max(width, size * len(line))\n return width",
"def test_determine_label_width(self):\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed_fields = self.get_allowed_width_fields()\n test_fields = allowed_fields.copy() # TODO: ? Try an input with some double and some single column rows?\n labels = [field.label or pretty_name(name) for name, field in test_fields.items()]\n full_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch\n word_width = max(len(word) for label in labels for word in label.split()) // 2\n expected_width = full_width if full_width < self.form.max_label_width else word_width\n expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(expected_width)}\n expected_attrs = {name: expected_attrs for name in list(test_fields.keys())}\n actual_attrs = self.form.determine_label_width(self.form.fields)\n\n self.assertLess(word_width, self.form.max_label_width)\n self.assertEqual(expected_attrs, actual_attrs)\n\n self.form.adjust_label_width = original_setting",
"def test_raises_too_wide_label_width(self):\n original_max = self.form.max_label_width\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n max_width = 2\n self.form.max_label_width = max_width\n allowed_fields = self.get_allowed_width_fields()\n group_keys = list(allowed_fields.keys())\n message = \"The max_label_width of {} is not enough for the fields: {} \".format(max_width, group_keys)\n\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.determine_label_width(self.form.fields)\n\n self.form.max_label_width = original_max\n self.form.adjust_label_width = original_setting",
"def label_width(self):\n return self._label_width",
"def label_width(self, start, end, numlabels=None, char_width=None):\n return self.formatter.estimate_width(start, end, numlabels, char_width,\n ticker=self)",
"def updateWidthFromLabel(self):\n prevWidth = self.rect().width()\n width = self.text.boundingRect().width() + \\\n CurrentTheme.VERSION_LABEL_MARGIN[0] - 4\n r = self.rect()\n r.setX(r.x()+(prevWidth-width)/2.0)\n r.setWidth(width)\n self.setRect(r)\n self.update()",
"def estimate_width(start, end, numlabels=None, char_width=None):\n return 0, 0",
"def align_labels(labels):\n # get longest label width\n max_width = -1\n for label in labels:\n width = label.GetSize().width\n max_width = max(max_width, width)\n \n # resize all labels to the longest width\n for label in labels:\n label.SetSize((max_width,-1))",
"def get_trimmed_label_widget(text, position, font_size, max_width):\n \n text_changed = False\n label_obj = MTLabel(label = text,\n pos = position,\n font_size = font_size,\n autowidth = True)\n \n while label_obj.width > max_width:\n \n text = text[:-1]\n \n text_changed = True\n label_obj = MTLabel(label = \"%s...\" % text,\n pos = position,\n font_size = font_size,\n autowidth = True)\n \n if text_changed:\n text = \"%s...\" % text\n \n return (label_obj, text)",
"def pixwidth(self):\n return self._labelWidth * self.transform.scale[0]",
"def calc_width(self):\n current_longest = 0\n\n for i in range(len(self.list_of_motif_objects)):\n current_object = self.list_of_motif_objects[i]\n if(len(current_object.sequence) > current_longest):\n current_longest = len(current_object.sequence)\n \n width_for_drawing = current_longest + 50 + 15 \n\n self.width = width_for_drawing + self.width_of_legend",
"def max_width(self):\n ...",
"def inner_size_from_label_size(self, label_size: int) -> int:\n return 4 + math.ceil((label_size - 2) / (2 ** self.n_folds))",
"def get_default_item_label_maxlength(self):\n return 15",
"def set_width( self, width ):\n # label seems to be the controlling thing\n self.label_widget.configure( width = width )",
"def __len__(self):\n return len(self.label)",
"def GetLabelSize(self, label):\r\n\r\n dc = wx.ClientDC(self)\r\n dc.SetFont(self._font)\r\n\r\n return GetLabelSize(dc, label, self._tool_orientation != AUI_TBTOOL_HORIZONTAL)",
"def getWidth(self, l):\n\n return max(len(repr(s)) for s in l)",
"def test_not_adjust_label_width(self):\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = False\n expected = {}\n actual = self.form.determine_label_width(self.form.fields)\n self.assertFalse(self.form.adjust_label_width)\n self.assertEqual(expected, actual)\n self.form.adjust_label_width = original_setting",
"def _label_height(text):\n return _BIG_FONT + _SMALL_LINE * text.count(u'\\n')",
"def GetLabelSize(dc, label, vertical):\r\n\r\n text_width = text_height = 0\r\n\r\n # get the text height\r\n dummy, text_height = dc.GetTextExtent(\"ABCDHgj\")\r\n # get the text width\r\n if label.strip():\r\n text_width, dummy = dc.GetTextExtent(label)\r\n\r\n if vertical:\r\n tmp = text_height\r\n text_height = text_width\r\n text_width = tmp\r\n\r\n return wx.Size(text_width, text_height)",
"def reformat_labels(label, bin_limits=[2]):\n# num_labels = y_batch.max() + 1\n label = np.array([label], dtype=np.float32)\n num_labels = 2\n label = np.digitize(label, bins=[2])\n label = (np.arange(num_labels) == label[:, None]).astype(np.float32)[0]\n return label",
"def get_width(self):\n return max(map(len, self.get_lines()))",
"def resize_label(label):\n # If current ratio greater than given ratio\n if label[HEIGHT_INDEX] / label[WIDTH_INDEX] > 1.5:\n previous = label[WIDTH_INDEX]\n label[WIDTH_INDEX] = label[HEIGHT_INDEX] / 1.5\n label[J_INDEX] -= (label[WIDTH_INDEX] - previous) / 2\n # If current ratio smaller than given ratio\n else:\n previous = label[HEIGHT_INDEX]\n label[HEIGHT_INDEX] = label[WIDTH_INDEX] * 1.5\n label[I_INDEX] -= (label[HEIGHT_INDEX] - previous) / 2\n return label",
"def size(self):\n\t\treturn len(self.lables)",
"def _model_string_maxlen():\n # hardcoded for convenience. Could be dynamically set in future.\n # the current longest is: BLOSUM62+I+G+X, i.e. 14 chars.\n # so we just over double it, for safety\n\n return 30",
"def num_labels(self) -> int:\n raise NotImplementedError",
"def user_labels_size(*args):\n return _ida_hexrays.user_labels_size(*args)",
"def width(self, value):\n self.data_validator(\"width\", value)\n self.__width = value"
] | [
"0.76109344",
"0.74859214",
"0.7330534",
"0.7205037",
"0.714588",
"0.7096384",
"0.6610137",
"0.64905024",
"0.6397106",
"0.6115807",
"0.60559005",
"0.6041587",
"0.5970336",
"0.57739186",
"0.5753549",
"0.57334375",
"0.5718662",
"0.57057786",
"0.56782657",
"0.56764853",
"0.5651406",
"0.55982405",
"0.5565961",
"0.5561431",
"0.5542835",
"0.5538673",
"0.5531241",
"0.5488423",
"0.5487836",
"0.5448148"
] | 0.7630568 | 0 |
Happy path for determine_label_width method returns inline style attribute and list of field names. | def test_determine_label_width(self):
original_setting = self.form.adjust_label_width
self.form.adjust_label_width = True
allowed_fields = self.get_allowed_width_fields()
test_fields = allowed_fields.copy() # TODO: ? Try an input with some double and some single column rows?
labels = [field.label or pretty_name(name) for name, field in test_fields.items()]
full_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch
word_width = max(len(word) for label in labels for word in label.split()) // 2
expected_width = full_width if full_width < self.form.max_label_width else word_width
expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(expected_width)}
expected_attrs = {name: expected_attrs for name in list(test_fields.keys())}
actual_attrs = self.form.determine_label_width(self.form.fields)
self.assertLess(word_width, self.form.max_label_width)
self.assertEqual(expected_attrs, actual_attrs)
self.form.adjust_label_width = original_setting | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def label_width(self):\n return self._label_width",
"def test_word_wrap_label_width(self):\n original_max = self.form.max_label_width\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed_fields = self.get_allowed_width_fields()\n labels = [field.label or pretty_name(name) for name, field in allowed_fields.items()]\n full_label_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch\n word_width = max(len(word) for label in labels for word in label.split()) // 2\n expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(word_width)}\n expected_attrs = {name: expected_attrs for name in allowed_fields}\n max_width = word_width + 1\n self.form.max_label_width = max_width\n actual_attrs = self.form.determine_label_width(self.form.fields)\n\n self.assertLess(max_width, full_label_width)\n self.assertEqual(expected_attrs, actual_attrs)\n\n self.form.max_label_width = original_max\n self.form.adjust_label_width = original_setting",
"def _label_width(text):\n width = 0\n for lineno, line in enumerate(text.split(u'\\n')):\n size = [_BIG_FONT, _SMALL_FONT][lineno > 0] # Cool idiom, huh?\n width = max(width, size * len(line))\n return width",
"def test_label_width_not_enough_single_field_rows(self):\n name, *names = list(self.form.fields.keys())\n field_rows = [{name: self.form.fields[name]}]\n if len(names) > 1:\n double_row = {name: self.form.fields[name] for name in names[:2]}\n field_rows.append(double_row)\n expected = {}\n actual = self.form.determine_label_width(field_rows)\n self.assertEqual(expected, actual)",
"def label_width(self, start, end, numlabels=None, char_width=None):\n return self.formatter.estimate_width(start, end, numlabels, char_width,\n ticker=self)",
"def test_label_width_fits_full_label_if_small_enough(self):\n original_max = self.form.max_label_width\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed_fields = self.get_allowed_width_fields()\n labels = [field.label or pretty_name(name) for name, field in allowed_fields.items()]\n full_label_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch\n expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(full_label_width)}\n expected_attrs = {name: expected_attrs for name in allowed_fields}\n max_width = full_label_width + 5\n self.form.max_label_width = max_width\n actual_attrs = self.form.determine_label_width(self.form.fields)\n\n self.assertGreater(max_width, full_label_width)\n self.assertEqual(expected_attrs, actual_attrs)\n\n self.form.max_label_width = original_max\n self.form.adjust_label_width = original_setting",
"def test_html_output_label_attrs_table(self):\n self.label_calls = []\n def fake_label_width(rows): self.label_calls.append(rows); return {}\n original_adjust_label_width = self.form.adjust_label_width\n self.form.adjust_label_width = True\n original_label_method = self.form.determine_label_width\n self.form.determine_label_width = fake_label_width\n collected = []\n for as_type in ('as_p', 'as_ul', 'as_table', 'as_fieldset'):\n collected.append({'type': as_type, 'html': getattr(self.form, as_type)(), 'calls': self.label_calls})\n self.label_calls = []\n expected = [opts['rows'] for lbl, opts in self.form._fieldsets]\n for ea in collected:\n expect = [] if ea['type'] == 'as_table' else expected\n message = f\"Mismatch for {ea['type']} html_output. \"\n self.assertEqual(expect, ea['calls'], message)\n\n self.form.determine_label_width = original_label_method\n self.form.adjust_label_width = original_adjust_label_width\n del self.label_calls",
"def conformFormLayoutLabels(self, parentObject, padding=8):\n\t\tlabels = []\n\t\tlabelWidths = []\n\n\t\t# Find all labels in form layouts\n\t\tfor layout in parentObject.findChildren(QtWidgets.QFormLayout):\n\t\t\t# print(layout.objectName())\n\t\t\titems = (layout.itemAt(i) for i in range(layout.count()))\n\t\t\tfor item in items:\n\t\t\t\twidget = item.widget()\n\t\t\t\tif isinstance(widget, QtWidgets.QLabel):\n\t\t\t\t\tlabels.append(widget)\n\n\t\t# Find labels in first column of grid layouts\n\t\tfor layout in parentObject.findChildren(QtWidgets.QGridLayout):\n\t\t\t# print(layout.objectName())\n\t\t\titems = (layout.itemAt(i) for i in range(layout.count()))\n\t\t\tfor item in items:\n\t\t\t\twidget = item.widget()\n\t\t\t\tif isinstance(widget, QtWidgets.QLabel):\n\t\t\t\t\t# Only items in first column (there's probably a neater\n\t\t\t\t\t# way to do this)\n\t\t\t\t\tif layout.getItemPosition(layout.indexOf(widget))[1] == 0:\n\t\t\t\t\t\tlabels.append(widget)\n\n\t\t# Find label widths\n\t\tfor label in labels:\n\t\t\tfontMetrics = QtGui.QFontMetrics(label.font())\n\t\t\twidth = fontMetrics.width(label.text())\n\t\t\t# print('Width of \"%s\": %d px' %(label.text(), width))\n\t\t\tlabelWidths.append(width)\n\n\t\t# Get widest label & set all labels widths to match\n\t\tif labelWidths:\n\t\t\tmaxWidth = max(labelWidths)\n\t\t\t# print(\"Max label width : %d px (%d inc padding)\" %(maxWidth, maxWidth+padding))\n\t\t\tfor label in labels:\n\t\t\t\tlabel.setFixedWidth(maxWidth+padding)\n\t\t\t\tlabel.setAlignment(QtCore.Qt.AlignVCenter|QtCore.Qt.AlignRight)\n\t\t\t\tlabel.setProperty('formLabel', True) # Set custom property for styling",
"def test_col_data_label_with_attrs(self):\n help_tag = 'span'\n help_text_br = False\n names = ('first', 'billing_address_1')\n attrs = {'style': 'width: 10rem; display: inline-block'}\n label_attrs = {name: attrs for name in names}\n txt = '{}=\"{}\"'.format(*list(attrs.items())[0])\n expected = ['<label for=\"id_first\" {}>First:</label>'.format(txt)]\n expected.append('<label for=\"id_billing_address_1\" {}>street address (line 1):</label>'.format(txt))\n actual = []\n for name in names:\n field = self.form.fields[name]\n response = self.form.collect_col_data(name, field, help_tag, help_text_br, label_attrs)\n actual.append(response.get('label'))\n\n for expect, got in zip(expected, actual):\n self.assertEqual(expect, got)",
"def updateWidthFromLabel(self):\n prevWidth = self.rect().width()\n width = self.text.boundingRect().width() + \\\n CurrentTheme.VERSION_LABEL_MARGIN[0] - 4\n r = self.rect()\n r.setX(r.x()+(prevWidth-width)/2.0)\n r.setWidth(width)\n self.setRect(r)\n self.update()",
"def widths(self):\n return self._widths",
"def GetLabelSize(self, label):\r\n\r\n dc = wx.ClientDC(self)\r\n dc.SetFont(self._font)\r\n\r\n return GetLabelSize(dc, label, self._tool_orientation != AUI_TBTOOL_HORIZONTAL)",
"def calc_width(self):\n current_longest = 0\n\n for i in range(len(self.list_of_motif_objects)):\n current_object = self.list_of_motif_objects[i]\n if(len(current_object.sequence) > current_longest):\n current_longest = len(current_object.sequence)\n \n width_for_drawing = current_longest + 50 + 15 \n\n self.width = width_for_drawing + self.width_of_legend",
"def GetLabelSize(dc, label, vertical):\r\n\r\n text_width = text_height = 0\r\n\r\n # get the text height\r\n dummy, text_height = dc.GetTextExtent(\"ABCDHgj\")\r\n # get the text width\r\n if label.strip():\r\n text_width, dummy = dc.GetTextExtent(label)\r\n\r\n if vertical:\r\n tmp = text_height\r\n text_height = text_width\r\n text_width = tmp\r\n\r\n return wx.Size(text_width, text_height)",
"def get_allowed_width_fields(self, fields=None):\n fields = fields or self.form.fields\n allowed_fields = {}\n for name, field in fields.items():\n if isinstance(field.widget, self.form.label_width_widgets):\n if not isinstance(field.widget, self.form.label_exclude_widgets):\n allowed_fields[name] = field\n return allowed_fields",
"def pixwidth(self):\n return self._labelWidth * self.transform.scale[0]",
"def getWidth(self) -> int:\n ...",
"def get_width(self):\n return \"%s\" % self.width",
"def test_raises_too_wide_label_width(self):\n original_max = self.form.max_label_width\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n max_width = 2\n self.form.max_label_width = max_width\n allowed_fields = self.get_allowed_width_fields()\n group_keys = list(allowed_fields.keys())\n message = \"The max_label_width of {} is not enough for the fields: {} \".format(max_width, group_keys)\n\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.determine_label_width(self.form.fields)\n\n self.form.max_label_width = original_max\n self.form.adjust_label_width = original_setting",
"def getWidth(self, l):\n\n return max(len(repr(s)) for s in l)",
"def test_only_correct_widget_classes(self):\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed = self.get_allowed_width_fields()\n reject_fields = {name: field for name, field in self.form.fields.items() if name not in allowed}\n expected = {}\n actual = self.form.determine_label_width(reject_fields)\n self.assertEqual(expected, actual)\n self.form.adjust_label_width = original_setting",
"def getWidth(*args):",
"def getWidth(*args):",
"def getWidth(*args):",
"def getWidth(*args):",
"def getWidth(*args):",
"def getWidth(*args):",
"def getWidth(*args):",
"def getWidth(*args):",
"def getWidth(*args):"
] | [
"0.66162574",
"0.63157785",
"0.62884843",
"0.6097747",
"0.6095963",
"0.609009",
"0.599724",
"0.5800857",
"0.5790533",
"0.5693854",
"0.5683141",
"0.5627819",
"0.5627223",
"0.5559427",
"0.5513676",
"0.54520077",
"0.54327476",
"0.53836983",
"0.5382971",
"0.53284246",
"0.53239447",
"0.5318346",
"0.5318346",
"0.5318346",
"0.5318346",
"0.5318346",
"0.5318346",
"0.5318346",
"0.5318346",
"0.5318346"
] | 0.71076655 | 0 |
The make_fieldsets method calls the prep_fields method (usually from FormOverrideMixIn) if it is present. | def test_make_fieldsets_uses_prep_fields(self):
original_called_prep_fields = self.form.called_prep_fields = False
full_fieldsets = self.form.make_fieldsets()
self.assertFalse(original_called_prep_fields)
self.assertIsInstance(full_fieldsets, (list, tuple))
self.assertIsNotNone(getattr(self.form, '_fieldsets', None))
self.assertTrue(self.form.called_prep_fields)
self.form.called_prep_fields = original_called_prep_fields | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_overall_make_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_make_fieldsets_uses_handle_modifiers(self):\n original_called_handle_modifiers = self.form.called_handle_modifiers = False\n full_fieldsets = self.form.make_fieldsets()\n\n self.assertFalse(original_called_handle_modifiers)\n self.assertIsInstance(full_fieldsets, (list, tuple))\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n self.assertTrue(self.form.called_handle_modifiers)\n\n self.form.called_handle_modifiers = original_called_handle_modifiers",
"def test_missing_initial_fieldsets(self):\n original_initial_fieldsets = self.form.fieldsets\n print(\"========================= TEST UNABLE TO DELETE THE PROPERTY FOR TESTING ========================\")\n print(original_initial_fieldsets)\n print(\"--------------------------------------\")\n delattr(self.form, 'fieldsets')\n response_fieldsets = self.form.make_fieldsets()\n print(response_fieldsets)\n\n setattr(self.form, 'fieldsets', original_initial_fieldsets)",
"def test_make_fieldsets_outcome_order(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'position': None,\n 'fields': [\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n fieldsets[0], fieldsets[1] = fieldsets[1], fieldsets[0]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_make_fieldsets_saves_results(self):\n original_initial_fieldsets = getattr(self.form, 'fieldsets', None)\n initial_fieldsets = deepcopy(original_initial_fieldsets)\n original_computed_fieldsets = getattr(self.form, '_fieldsets', None)\n original_summary = getattr(self.form, '_fs_summary', None)\n self.assertIsNotNone(original_initial_fieldsets)\n self.assertIsNone(original_computed_fieldsets)\n self.assertIsNone(original_summary)\n response_fieldsets = self.form.make_fieldsets()\n label, summary = response_fieldsets.pop()\n self.assertIsNotNone(self.form._fieldsets)\n self.assertIsNotNone(self.form._fs_summary)\n self.assertEqual('summary', label)\n self.assertEqual(summary, self.form._fs_summary)\n self.assertEqual(response_fieldsets, self.form._fieldsets)\n self.assertEqual(initial_fieldsets, self.form.fieldsets)\n\n self.form.fieldsets = original_initial_fieldsets\n self.form._fieldsets = original_computed_fieldsets\n self.form._fs_summary = original_summary\n if original_computed_fieldsets is None:\n del self.form._fieldsets\n if original_summary is None:\n del self.form._fs_summary",
"def test_computed_fieldsets_structure(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n self.form.make_fieldsets()\n fieldsets = self.form._fieldsets\n each_are_tuples = (isinstance(ea, tuple) for ea in fieldsets)\n correct_fieldset_labels = (isinstance(label, (str, type(None))) for label, opts in fieldsets)\n opts_are_dictionaries = (isinstance(opts, dict) for label, opts in fieldsets)\n required_keys = {'position', 'fields', 'field_names', 'rows', 'column_count', }\n optional_keys = {'classes', 'modifiers', 'row_data', }\n allowed_keys = required_keys | optional_keys\n opt_keys = set(flatten([list(opts.keys()) for lbl, opts, in fieldsets]))\n unaccepted_keys = [key for key in opt_keys if key not in allowed_keys]\n has_required = (all(key in opts for key in required_keys) for lbl, opts in fieldsets)\n self.assertIsInstance(fieldsets, list)\n self.assertTrue(all(each_are_tuples))\n self.assertTrue(all(correct_fieldset_labels))\n self.assertTrue(all(opts_are_dictionaries))\n self.assertEqual(len(unaccepted_keys), 0)\n self.assertFalse(unaccepted_keys)\n self.assertTrue(all(has_required))\n\n self.form.fieldsets = original_fieldsets",
"def test_no_empty_sets_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n ('Non_Fields', {\n 'position': 2,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 2)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def make_fields(self):\n for name, prop in self.edit:\n instance_value = self.model.get(name)\n post_value = self.data[name] if (self.data and self.data.has_key(name)) else instance_value\n form_field_class = self.get_field_type(prop)\n form_field = form_field_class(model=self.model, property=prop, name=name, instance_value=instance_value, post_value=post_value)\n self.add(form_field)",
"def test_no_empty_rows_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_a_field',\n ('last_name', 'another_field', ),\n ('first_name', 'non-field_name', ),\n 'generic_field',\n 'last',\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: remaining_fields.pop(name) for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 3)\n self.assertEqual(len(fieldsets[1][1]['rows']), 4)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_raises_if_initial_fieldsets_error(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }), )\n position_missing_fieldsets = deepcopy(test_fieldsets)\n del position_missing_fieldsets[1][1]['position']\n fields_missing_fieldsets = deepcopy(test_fieldsets)\n del fields_missing_fieldsets[0][1]['fields']\n message = \"There must be 'fields' and 'position' in each fieldset. \"\n self.form.fieldsets = position_missing_fieldsets\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets()\n self.form.fieldsets = fields_missing_fieldsets\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets()\n\n self.form.fieldsets = original_fieldsets",
"def _create_and_initialise_fields(self):\n for team in self.category.breaking_teams.all():\n self.fields[self._fieldname_remark(team)] = OptionalChoiceField(choices=BreakingTeam.REMARK_CHOICES, required=False)\n try:\n self.initial[self._fieldname_remark(team)] = self._bt(team).remark\n except KeyError:\n self.initial[self._fieldname_remark(team)] = None",
"def __createFields(self):\n fields = self.updateFields\n for field in fields:\n self.__createField(field)",
"def add_base_fields(self) -> None:\n for field in get_model_fields(self.model, foreign=False, m2m=False):\n if hasattr(self.factory, field.name) or field.has_default() or field.blank:\n continue\n setattr(\n self.factory, field.name, self._get_decl_for_model_field(field)\n )",
"def prepare(self, form):\n \n return form",
"def test_prep_fields(self):\n pass",
"def get_fieldsets(self, request, obj=None):\n if obj:\n return (('Corporate Burn Attribute Summary', {\n \"fields\": ('name', 'description', ('financial_year', 'planned_season'),\n ('last_year', 'last_season',\n 'last_year_unknown', 'last_season_unknown'),\n 'region', 'district', 'location',\n 'forest_blocks',\n ('priority', 'rationale'),\n ('contentious', 'contentious_rationale'),\n 'aircraft_burn',\n # TODO: PBS-1551 # 'allocation',\n 'remote_sensing_priority', 'purposes',\n ('area', 'perimeter', 'treatment_percentage'),\n ('non_calm_tenure','non_calm_tenure_approved','non_calm_tenure_included','non_calm_tenure_value','non_calm_tenure_complete','non_calm_tenure_risks')\n )\n }), ('Other Attributes', {\n \"fields\": ('tenures', 'fuel_types', 'shires',\n 'bushfire_act_zone', 'prohibited_period',\n 'forecast_areas', 'prescribing_officer',\n 'short_code')\n }))\n else:\n return super(PrescriptionAdmin, self).get_fieldsets(request, obj)",
"def extend_or_add_fields(cls, subfields, dbmanager, flag_mixin_atroot, propname, proplabel):\n import mdbmodel_fieldset\n if (flag_mixin_atroot):\n # prepare extra fields that will be added at root; this doesnt actually create any prerequisites\n cls.extend_fields(subfields)\n else:\n # add a special sub table that will contain some fields, using a helper class object attached to us\n # create (AND REGISTER) the new helper object\n backrefname = cls.get_dbtablename_pure()\n mdbmodel_fieldset.MewloDbFieldset.make_fieldset_dbobjectclass(cls, propname, proplabel, backrefname, dbmanager, subfields)",
"def bind_formset(formset):\n if formset.is_bound:\n # do nothing if the formset is already bound\n return formset\n \n bindData={}\n # the formset.get_default_prefix() and form.add_prefix() methods add in the \n # dict keys that uniquely identify the various form fields with the individual \n # instance data\n \n # add formset management form data\n bindData[formset.get_default_prefix()+\"-TOTAL_FORMS\"]=str(formset.management_form['TOTAL_FORMS'].value())\n bindData[formset.get_default_prefix()+\"-INITIAL_FORMS\"]=str(formset.management_form['INITIAL_FORMS'].value())\n bindData[formset.get_default_prefix()+\"-MIN_NUM_FORMS\"]=str(formset.management_form['MIN_NUM_FORMS'].value())\n bindData[formset.get_default_prefix()+\"-MAX_NUM_FORMS\"]=str(formset.management_form['MAX_NUM_FORMS'].value())\n for form in formset:\n if form.instance:\n # field data, get these values from the instance\n for fieldName,fieldValue in form.fields.iteritems():\n try:\n bindData[form.add_prefix(fieldName)]=getattr(form.instance,\n fieldName)\n except AttributeError:\n # this is an added field (i.e. DELETE), not derived from the\n # model, do nothing with it, since we are only binding instance\n # data to the form\n pass\n # hidden field data, get these from the field initial values set\n # when the form was created\n for field in form.hidden_fields():\n bindData[form.add_prefix(field.name)]=field.field.initial\n # create a new bound formset by passing in the bindData dict, this looks\n # to the formset constructor like a request.POST dict \n newFormset=formset.__class__(bindData,instance=formset.instance,\n error_class=formset.error_class)\n return newFormset",
"def get_fieldsets(self, request, obj=None):\n if not obj:\n return self.fieldsets_without_readonly\n return super().get_fieldsets(request, obj=obj)",
"def set_fields(self, fields: FieldDict):\n super().set_fields(fields)\n nested_field: NestedField = self.fields[self.nested]\n if not isinstance(nested_field, NestedField):\n raise TypeError(\n f'The field \"{self.nested}\" must be a NestedField instance, not \"{nested_field}\".')\n if nested_field.many:\n raise ValueError(f'The field \"{self.nested}\" can not be set as \"many=True\".')\n self.nested_field = nested_field\n # create partial methods\n self._do_dump = partial(\n getattr(self, self.dump_method),\n target=nested_field.dump_target,\n method=nested_field.dump,\n )\n self._do_load = partial(\n getattr(self, self.load_method),\n target=nested_field.load_target,\n method=nested_field.load,\n )",
"def _initFields(self):\n pass",
"def _replace_fields(self):\n for name, value in self._cleaned_data.items():\n setattr(self, name, value)",
"def get_fieldsets(self, request, obj=None):\n if obj:\n return self._change_fieldsets\n return self._add_fieldsets",
"def initial_formset_data(self, request, step, formset):\n return None",
"def change_form_fieldsets(admin_form):\n form = admin_form.form\n readonly_fields = admin_form.readonly_fields\n model_admin = admin_form.model_admin\n\n for name, options in admin_form.fieldsets:\n yield ChangeFormFieldset(form=form,\n name=name,\n readonly_fields=readonly_fields,\n model_admin=model_admin,\n **options)",
"def presets (self):\n assert False, \"To be implemented by child\"",
"def populate_form(self, **kwargs):\n for name, value in kwargs.items():\n self.populate_field(name, value)",
"def test_make_fieldsets_names_can_be_coded(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n (None, {\n 'position': 1,\n 'fields': [\n ('first', 'second', ),\n ('_name_for_coded', 'last', ),\n ],\n }),\n ('Your Name', {\n 'position': 2,\n 'fields': [('first_name', 'last_name', )],\n }), )\n self.form.fieldsets = test_fieldsets\n expected_name = self.form.name_for_coded\n self.form.make_fieldsets()\n computed_fieldsets = self.form._fieldsets\n opts = computed_fieldsets[0][1]\n target = opts['rows'][1]\n self.assertIn(expected_name, target.keys())\n self.assertEqual(self.form.fields.get(expected_name), target.get(expected_name, ''))\n self.assertIn('_name_for_coded', opts['field_names'])\n\n self.form.fieldsets = original_fieldsets",
"def get_fieldsets(self, request, obj=None):\n return (\n ('Name', {\n 'fields': (\n ('first_name', 'last_name'),)\n }),\n ('IPI', {\n 'fields': (\n ('ipi_name', 'ipi_base'),),\n }),\n ('Societies', {\n 'fields': (\n self.get_society_list(),),\n }),\n ('General agreement', {\n 'fields': (\n ('generally_controlled',\n ('saan', 'publisher_fee'))\n ),\n }),\n )",
"def intialize_from_fields(self):\n raise NotImplementedError"
] | [
"0.7192431",
"0.67726475",
"0.6687887",
"0.6674191",
"0.64705116",
"0.64192563",
"0.6232401",
"0.5865996",
"0.581735",
"0.5797246",
"0.5771073",
"0.5763768",
"0.5759727",
"0.56897867",
"0.5605286",
"0.5578745",
"0.555899",
"0.55580986",
"0.55485183",
"0.5542049",
"0.553905",
"0.5523417",
"0.5522756",
"0.5495507",
"0.5492785",
"0.54862946",
"0.54705685",
"0.5452675",
"0.54199314",
"0.5418762"
] | 0.79475874 | 0 |
The make_fieldsets method raises ImproperlyConfigured if initial fieldset is missing fields or position. | def test_raises_if_initial_fieldsets_error(self):
original_fieldsets = self.form.fieldsets
test_fieldsets = (
('Your Name', {
'position': 1,
'fields': [('first_name', 'last_name', )],
}),
(None, {
'classes': ('counting', ),
'position': 2,
'fields': [
('first', 'second', ),
'last',
],
}), )
position_missing_fieldsets = deepcopy(test_fieldsets)
del position_missing_fieldsets[1][1]['position']
fields_missing_fieldsets = deepcopy(test_fieldsets)
del fields_missing_fieldsets[0][1]['fields']
message = "There must be 'fields' and 'position' in each fieldset. "
self.form.fieldsets = position_missing_fieldsets
with self.assertRaisesMessage(ImproperlyConfigured, message):
self.form.make_fieldsets()
self.form.fieldsets = fields_missing_fieldsets
with self.assertRaisesMessage(ImproperlyConfigured, message):
self.form.make_fieldsets()
self.form.fieldsets = original_fieldsets | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_missing_initial_fieldsets(self):\n original_initial_fieldsets = self.form.fieldsets\n print(\"========================= TEST UNABLE TO DELETE THE PROPERTY FOR TESTING ========================\")\n print(original_initial_fieldsets)\n print(\"--------------------------------------\")\n delattr(self.form, 'fieldsets')\n response_fieldsets = self.form.make_fieldsets()\n print(response_fieldsets)\n\n setattr(self.form, 'fieldsets', original_initial_fieldsets)",
"def test_overall_make_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_make_fieldsets_uses_prep_fields(self):\n original_called_prep_fields = self.form.called_prep_fields = False\n full_fieldsets = self.form.make_fieldsets()\n\n self.assertFalse(original_called_prep_fields)\n self.assertIsInstance(full_fieldsets, (list, tuple))\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n self.assertTrue(self.form.called_prep_fields)\n\n self.form.called_prep_fields = original_called_prep_fields",
"def test_no_empty_sets_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n ('Non_Fields', {\n 'position': 2,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 2)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_computed_fieldsets_structure(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n self.form.make_fieldsets()\n fieldsets = self.form._fieldsets\n each_are_tuples = (isinstance(ea, tuple) for ea in fieldsets)\n correct_fieldset_labels = (isinstance(label, (str, type(None))) for label, opts in fieldsets)\n opts_are_dictionaries = (isinstance(opts, dict) for label, opts in fieldsets)\n required_keys = {'position', 'fields', 'field_names', 'rows', 'column_count', }\n optional_keys = {'classes', 'modifiers', 'row_data', }\n allowed_keys = required_keys | optional_keys\n opt_keys = set(flatten([list(opts.keys()) for lbl, opts, in fieldsets]))\n unaccepted_keys = [key for key in opt_keys if key not in allowed_keys]\n has_required = (all(key in opts for key in required_keys) for lbl, opts in fieldsets)\n self.assertIsInstance(fieldsets, list)\n self.assertTrue(all(each_are_tuples))\n self.assertTrue(all(correct_fieldset_labels))\n self.assertTrue(all(opts_are_dictionaries))\n self.assertEqual(len(unaccepted_keys), 0)\n self.assertFalse(unaccepted_keys)\n self.assertTrue(all(has_required))\n\n self.form.fieldsets = original_fieldsets",
"def test_make_fieldsets_outcome_order(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'position': None,\n 'fields': [\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n fieldsets[0], fieldsets[1] = fieldsets[1], fieldsets[0]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_make_fieldsets_saves_results(self):\n original_initial_fieldsets = getattr(self.form, 'fieldsets', None)\n initial_fieldsets = deepcopy(original_initial_fieldsets)\n original_computed_fieldsets = getattr(self.form, '_fieldsets', None)\n original_summary = getattr(self.form, '_fs_summary', None)\n self.assertIsNotNone(original_initial_fieldsets)\n self.assertIsNone(original_computed_fieldsets)\n self.assertIsNone(original_summary)\n response_fieldsets = self.form.make_fieldsets()\n label, summary = response_fieldsets.pop()\n self.assertIsNotNone(self.form._fieldsets)\n self.assertIsNotNone(self.form._fs_summary)\n self.assertEqual('summary', label)\n self.assertEqual(summary, self.form._fs_summary)\n self.assertEqual(response_fieldsets, self.form._fieldsets)\n self.assertEqual(initial_fieldsets, self.form.fieldsets)\n\n self.form.fieldsets = original_initial_fieldsets\n self.form._fieldsets = original_computed_fieldsets\n self.form._fs_summary = original_summary\n if original_computed_fieldsets is None:\n del self.form._fieldsets\n if original_summary is None:\n del self.form._fs_summary",
"def test_no_empty_rows_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_a_field',\n ('last_name', 'another_field', ),\n ('first_name', 'non-field_name', ),\n 'generic_field',\n 'last',\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: remaining_fields.pop(name) for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 3)\n self.assertEqual(len(fieldsets[1][1]['rows']), 4)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_make_fieldsets_uses_handle_modifiers(self):\n original_called_handle_modifiers = self.form.called_handle_modifiers = False\n full_fieldsets = self.form.make_fieldsets()\n\n self.assertFalse(original_called_handle_modifiers)\n self.assertIsInstance(full_fieldsets, (list, tuple))\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n self.assertTrue(self.form.called_handle_modifiers)\n\n self.form.called_handle_modifiers = original_called_handle_modifiers",
"def test_view_initializes_formset_with_audit_initial_data(self):\n audit = AuditFactory(num_doctypes=3) # fixture\n\n formset = DocumentFormSet(audit_pk=audit.pk)\n\n expected_labels = {dt.name for dt in audit.required_doctypes.all()}\n forms_labels = {form.fields['file'].label for form in formset}\n self.assertSetEqual(expected_labels, forms_labels)\n\n expected_doctype_pks = {dt.pk for dt in audit.required_doctypes.all()}\n forms_pks = {form.initial['doctype'] for form in formset}\n self.assertSetEqual(expected_doctype_pks, forms_pks)",
"def test_construct_fieldset_tag(attributes):\n fset = FieldSet(**attributes)\n assert fset.construct() == fieldset.render(attributes)",
"def test_no_duplicate_fields_in_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n ('Confused', {\n 'position': 3,\n 'fields': [\n ('first_name', 'generic_field', ),\n 'first',\n 'last',\n ],\n }), )\n duplicates = set(('first_name', 'first', 'last', ))\n expected = []\n for names in test_fieldsets[2][1]['fields']:\n if isinstance(names, str):\n names = (names, )\n names = [name for name in names if name not in duplicates]\n if names:\n expected.append({name: self.form.fields[name] for name in names})\n self.form.fieldsets = deepcopy(test_fieldsets)\n self.form.make_fieldsets()\n computed_fieldsets = self.form._fieldsets\n opts = computed_fieldsets[2][1]\n actual = opts['rows']\n\n self.assertEqual(1, len(actual), \"Rows of already used fields were added. \")\n self.assertEqual(1, len(actual[0]), \"Columns of already used fields were added. \")\n self.assertEqual(expected, actual)\n for lbl, opts in computed_fieldsets[:2]:\n row_names = flatten([list(row.keys()) for row in opts['rows']])\n self.assertEqual(opts['field_names'], row_names, \"Field missing from its expected first fieldset. \")\n\n self.form.fieldsets = original_fieldsets",
"def _create_and_initialise_fields(self):\n for team in self.category.breaking_teams.all():\n self.fields[self._fieldname_remark(team)] = OptionalChoiceField(choices=BreakingTeam.REMARK_CHOICES, required=False)\n try:\n self.initial[self._fieldname_remark(team)] = self._bt(team).remark\n except KeyError:\n self.initial[self._fieldname_remark(team)] = None",
"def test_raises_if_missed_fields(self):\n name = 'second'\n self.form.called_handle_modifiers = False\n remove = {'remove_field': name}\n self.form.handle_modifiers({}, [], **remove)\n self.assertNotIn(name, self.form.fields)\n self.assertIn(name, self.form.hold_field)\n message = \"Some unassigned fields, perhaps some added during handle_modifiers. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets(add_field=name)\n self.form.called_handle_modifiers = False",
"def get_fieldsets(model):\n fieldsets = getattr(model, 'report_builder_fieldsets', None)\n if fieldsets:\n for fieldset_name, fieldset_dict in model.report_builder_fieldsets:\n fieldset_string_to_field(fieldset_dict, model)\n return fieldsets",
"def test_raises_on_constructor_fields_error(self):\n self.form.constructor_fields = None\n message = \"Expected a list of field name strings for constructor_fields. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.confirm_required_fields()",
"def test_make_fieldsets_names_can_be_coded(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n (None, {\n 'position': 1,\n 'fields': [\n ('first', 'second', ),\n ('_name_for_coded', 'last', ),\n ],\n }),\n ('Your Name', {\n 'position': 2,\n 'fields': [('first_name', 'last_name', )],\n }), )\n self.form.fieldsets = test_fieldsets\n expected_name = self.form.name_for_coded\n self.form.make_fieldsets()\n computed_fieldsets = self.form._fieldsets\n opts = computed_fieldsets[0][1]\n target = opts['rows'][1]\n self.assertIn(expected_name, target.keys())\n self.assertEqual(self.form.fields.get(expected_name), target.get(expected_name, ''))\n self.assertIn('_name_for_coded', opts['field_names'])\n\n self.form.fieldsets = original_fieldsets",
"def test_form_main_rows_all_fieldsets_has_container(self):\n # form.form_main_rows(self, html_args, fieldsets, form_col_count)\n # html_args = (row_tag, col_head_tag, col_tag, single_col_tag, as_type, all_fieldsets)\n pass",
"def add_base_fields(self) -> None:\n for field in get_model_fields(self.model, foreign=False, m2m=False):\n if hasattr(self.factory, field.name) or field.has_default() or field.blank:\n continue\n setattr(\n self.factory, field.name, self._get_decl_for_model_field(field)\n )",
"def get_fieldsets(self, request, obj=None):\n base_fields = (\n None, {\n 'fields': ASCreationForm.Meta.fields\n }\n )\n host_ip_fields = (\n 'Host IPs', {\n 'fields': ('internal_ip', 'public_ip', 'bind_ip', )\n }\n )\n key_fields = (\n 'Keys & Certificates', {\n 'classes': ('collapse',),\n 'fields': (\n 'master_as_key',\n )\n }\n )\n if not obj:\n return (base_fields, host_ip_fields)\n return (base_fields, key_fields)",
"def test_as_fieldset(self):\n # form._html_output(self, row_tag, col_head_tag, col_tag, single_col_tag, col_head_data, col_data,\n # help_text_br, errors_on_separate_row, as_type=None, strict_columns=False)\n pass",
"def get_fieldsets(self, request, obj=None):\n return (\n ('Name', {\n 'fields': (\n ('first_name', 'last_name'),)\n }),\n ('IPI', {\n 'fields': (\n ('ipi_name', 'ipi_base'),),\n }),\n ('Societies', {\n 'fields': (\n self.get_society_list(),),\n }),\n ('General agreement', {\n 'fields': (\n ('generally_controlled',\n ('saan', 'publisher_fee'))\n ),\n }),\n )",
"def _initFields(self):\n pass",
"def get_fieldsets(self, request, obj=None):\n if not obj:\n return self.fieldsets_without_readonly\n return super().get_fieldsets(request, obj=obj)",
"def _generate_formset_class(\n request, model, modelfield, baseformclass, formsetfieldelement\n):\n\n formfieldelements = _get_form_fields_from_layout(\n _layout.BaseElement(*formsetfieldelement)\n ) # make sure the _layout.form.FormSetField does not be considered recursively\n\n formclass = breadmodelform_factory(\n request=request,\n model=modelfield.related_model,\n layout=formfieldelements,\n instance=None,\n baseformclass=baseformclass,\n )\n\n base_formset_kwargs = {\n \"fields\": [\n formfieldelement.fieldname for formfieldelement in formfieldelements\n ],\n \"form\": formclass,\n \"extra\": 0,\n \"can_delete\": True,\n }\n base_formset_kwargs.update(formsetfieldelement.formsetfactory_kwargs)\n if isinstance(modelfield, GenericRelation):\n return generic_inlineformset_factory(\n modelfield.related_model,\n ct_field=modelfield.content_type_field_name,\n fk_field=modelfield.object_id_field_name,\n formset=InlineFormSetWithLimits,\n formfield_callback=lambda field: _formfield_callback_with_request(\n field, request, modelfield.related_model\n ),\n **base_formset_kwargs,\n )\n else:\n return forms.models.inlineformset_factory(\n model,\n modelfield.related_model,\n formset=InlineFormSetWithLimits,\n formfield_callback=lambda field: _formfield_callback_with_request(\n field, request, model\n ),\n **base_formset_kwargs,\n )",
"def extend_or_add_fields(cls, subfields, dbmanager, flag_mixin_atroot, propname, proplabel):\n import mdbmodel_fieldset\n if (flag_mixin_atroot):\n # prepare extra fields that will be added at root; this doesnt actually create any prerequisites\n cls.extend_fields(subfields)\n else:\n # add a special sub table that will contain some fields, using a helper class object attached to us\n # create (AND REGISTER) the new helper object\n backrefname = cls.get_dbtablename_pure()\n mdbmodel_fieldset.MewloDbFieldset.make_fieldset_dbobjectclass(cls, propname, proplabel, backrefname, dbmanager, subfields)",
"def get_fieldsets(self, default):\n default = default + ['-']\n\n last = None\n fields = []\n for perm in self.__permissions_to_manage():\n if last != perm.content_type:\n if fields:\n default = default + ['h3:'+last.model_class()._meta.verbose_name_plural, segment(chunks(fields, 4))]\n last = perm.content_type\n fields = []\n\n fields = fields + [perm.codename]\n\n default = default + ['h3:'+last.model_class()._meta.verbose_name_plural, segment(chunks(fields, 4))]\n return default",
"def formset_factory(form, formset=BaseFormSet, extra=1, can_order=False,\n can_delete=False, max_num=None, validate_max=False,\n min_num=None, validate_min=False, absolute_max=None,\n can_delete_extra=True):\n if min_num is None:\n min_num = DEFAULT_MIN_NUM\n if max_num is None:\n max_num = DEFAULT_MAX_NUM\n # absolute_max is a hard limit on forms instantiated, to prevent\n # memory-exhaustion attacks. Default to max_num + DEFAULT_MAX_NUM\n # (which is 2 * DEFAULT_MAX_NUM if max_num is None in the first place).\n if absolute_max is None:\n absolute_max = max_num + DEFAULT_MAX_NUM\n if max_num > absolute_max:\n raise ValueError(\n \"'absolute_max' must be greater or equal to 'max_num'.\"\n )\n attrs = {\n 'form': form,\n 'extra': extra,\n 'can_order': can_order,\n 'can_delete': can_delete,\n 'can_delete_extra': can_delete_extra,\n 'min_num': min_num,\n 'max_num': max_num,\n 'absolute_max': absolute_max,\n 'validate_min': validate_min,\n 'validate_max': validate_max,\n }\n return type(form.__name__ + 'FormSet', (formset,), attrs)",
"def grouped_formset_factory(leafpack=None, taxon_forms=None):\n groupedform_list = []\n groupRS= LeafPackSensitivityGroup.objects.all()\n\n for gr in groupRS:\n\n groupRS = Macroinvertebrate.objects.filter(displayflag= True, sens_group=gr).order_by('display_order')\n bug_forms=[]\n for taxon in groupRS:\n if leafpack is not None:\n try:\n lpg = LeafPackBug.objects.get(bug=taxon.id, leaf_pack=leafpack.id)\n except ObjectDoesNotExist:\n lpg = LeafPackBug(bug=taxon, leaf_pack=leafpack)\n lpg.save()\n else:\n lpg = LeafPackBug(bug=taxon)\n \n bug_form = LeafPackBugForm(instance=lpg)\n bug_forms.append(bug_form)\n \n group ={}\n group['name']= 'Group {0}: {1}'.format(str(gr.id), gr.name)\n group['list']= bug_forms\n groupedform_list.append(group)\n\n # If taxon_forms is not None, plug bug_count values into new formset\n if taxon_forms is not None:\n\n def get_taxon_count(taxon_):\n for tf in taxon_forms:\n if tf.instance.bug == taxon_:\n return tf.instance.bug_count\n return 0\n\n for forms_ in taxon_forms:\n forms_[0].initial['bug_count'] = get_taxon_count(forms_[0].instance.bug)\n\n for form in forms_[1]:\n form.initial['bug_count'] = get_taxon_count(form.instance.bug)\n\n return groupedform_list",
"def get_fieldsets(self, request, obj=None):\n if obj:\n return self._change_fieldsets\n return self._add_fieldsets"
] | [
"0.7113292",
"0.7038173",
"0.6950497",
"0.6687227",
"0.6648511",
"0.6438534",
"0.62719536",
"0.62524635",
"0.62194395",
"0.57437134",
"0.5563694",
"0.55427533",
"0.54819524",
"0.54546463",
"0.54445684",
"0.5434063",
"0.5427221",
"0.54245543",
"0.53959405",
"0.5385944",
"0.5359692",
"0.53549904",
"0.5352696",
"0.5313337",
"0.5278145",
"0.524726",
"0.52402693",
"0.5230775",
"0.5224938",
"0.51986784"
] | 0.77119344 | 0 |
The make_fieldsets method recognizes field name in opts['fields'] if coded with leading underscore. | def test_make_fieldsets_names_can_be_coded(self):
original_fieldsets = self.form.fieldsets
test_fieldsets = (
(None, {
'position': 1,
'fields': [
('first', 'second', ),
('_name_for_coded', 'last', ),
],
}),
('Your Name', {
'position': 2,
'fields': [('first_name', 'last_name', )],
}), )
self.form.fieldsets = test_fieldsets
expected_name = self.form.name_for_coded
self.form.make_fieldsets()
computed_fieldsets = self.form._fieldsets
opts = computed_fieldsets[0][1]
target = opts['rows'][1]
self.assertIn(expected_name, target.keys())
self.assertEqual(self.form.fields.get(expected_name), target.get(expected_name, ''))
self.assertIn('_name_for_coded', opts['field_names'])
self.form.fieldsets = original_fieldsets | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_overall_make_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_make_fieldsets_uses_prep_fields(self):\n original_called_prep_fields = self.form.called_prep_fields = False\n full_fieldsets = self.form.make_fieldsets()\n\n self.assertFalse(original_called_prep_fields)\n self.assertIsInstance(full_fieldsets, (list, tuple))\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n self.assertTrue(self.form.called_prep_fields)\n\n self.form.called_prep_fields = original_called_prep_fields",
"def test_computed_fieldsets_structure(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n self.form.make_fieldsets()\n fieldsets = self.form._fieldsets\n each_are_tuples = (isinstance(ea, tuple) for ea in fieldsets)\n correct_fieldset_labels = (isinstance(label, (str, type(None))) for label, opts in fieldsets)\n opts_are_dictionaries = (isinstance(opts, dict) for label, opts in fieldsets)\n required_keys = {'position', 'fields', 'field_names', 'rows', 'column_count', }\n optional_keys = {'classes', 'modifiers', 'row_data', }\n allowed_keys = required_keys | optional_keys\n opt_keys = set(flatten([list(opts.keys()) for lbl, opts, in fieldsets]))\n unaccepted_keys = [key for key in opt_keys if key not in allowed_keys]\n has_required = (all(key in opts for key in required_keys) for lbl, opts in fieldsets)\n self.assertIsInstance(fieldsets, list)\n self.assertTrue(all(each_are_tuples))\n self.assertTrue(all(correct_fieldset_labels))\n self.assertTrue(all(opts_are_dictionaries))\n self.assertEqual(len(unaccepted_keys), 0)\n self.assertFalse(unaccepted_keys)\n self.assertTrue(all(has_required))\n\n self.form.fieldsets = original_fieldsets",
"def test_make_fieldsets_outcome_order(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'position': None,\n 'fields': [\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n fieldsets[0], fieldsets[1] = fieldsets[1], fieldsets[0]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def convert_fields(fields, _fields):\n mapper = {\n \"id\": \"local_id\",\n \"local_id\": \"id\"\n }\n fields = deepcopy(fields)\n for field in fields:\n if field['name'] in _fields:\n field['name'] = mapper[field['name']]\n return fields",
"def test_make_fieldsets_uses_handle_modifiers(self):\n original_called_handle_modifiers = self.form.called_handle_modifiers = False\n full_fieldsets = self.form.make_fieldsets()\n\n self.assertFalse(original_called_handle_modifiers)\n self.assertIsInstance(full_fieldsets, (list, tuple))\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n self.assertTrue(self.form.called_handle_modifiers)\n\n self.form.called_handle_modifiers = original_called_handle_modifiers",
"def test_no_empty_sets_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n ('Non_Fields', {\n 'position': 2,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 2)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def _init_fields(self):\n if self._fields is None:\n M.mset('U', \"^\") # DBS Calls Require this\n f = self._fields = {}\n attrs = self.fieldnames = {}\n fieldid = \"0\"\n while 1:\n # Subscript 0 is field description, .1 is the title, 3 is help\n fieldid, info, title, fieldhelp = M.ddwalk(self._fileid, fieldid)\n #fieldid, info, title, fieldhelp = M.mexec(\n # \"\"\"set s0=$order(^DD(s2,s0)) Q:s0'=+s0 s s1=$G(^DD(s2,s0,0)),s3=$G(^DD(s2,s0,.1)),s4=$G(^DD(s2,s0,3))\"\"\",\n # M.INOUT(str(fieldid)), M.INOUT(\"\"), str(self._fileid), M.INOUT(\"\"), M.INOUT(\"\"))\n if fieldid == \"\" or fieldid[0] not in \"0123456789.\":\n break\n\n info = info.split(\"^\", 4) \n label = self._clean_label(info[0])\n try:\n ftype = info[1]\n except:\n ftype = None\n if ftype:\n finst = None\n for klass in FIELD_TYPES:\n if klass.isa(ftype):\n finst = f[fieldid] = klass(fieldid, label, info)\n finst.fileid = self.fileid\n finst.ownerdd = self\n attrs[label] = fieldid\n break\n if finst is None:\n print finst, \"FIELD [%s], spec [%s] was not identified\" % (label, ftype)\n continue\n finst.title = title\n finst.fieldhelp = fieldhelp\n else:\n assert finst, \"FIELD [%s] %s has no fieldspec\" % (label, info)\n\n return self._fields",
"def make_fields_unique(self, fields):\n ...",
"def fill_by_name(self, fields, prefix=\"\"):\n self.fill({'[name=\"%s%s\"]' % (prefix, k): v for k, v in fields.items()})",
"def _field_name_flag(field: _d.Field):\r\n return f\"--{field.name.rstrip('_').replace('_', '-')}\"",
"def make_select_fields(self, product, field_names, custom_offsets):\n\n assert product and field_names\n\n dataset_fields = product.metadata_type.dataset_fields\n dataset_section = product.metadata_type.definition['dataset']\n\n select_fields = []\n for field_name in field_names:\n if dataset_fields.get(field_name):\n select_fields.append(dataset_fields[field_name])\n else:\n # try to construct the field\n if field_name in {'transform', 'extent', 'crs', 'bounds'}:\n grid_spatial = dataset_section.get('grid_spatial')\n if grid_spatial:\n select_fields.append(SimpleDocField(\n 'grid_spatial', 'grid_spatial', DATASET.c.metadata,\n False,\n offset=grid_spatial\n ))\n elif custom_offsets and field_name in custom_offsets:\n select_fields.append(SimpleDocField(\n field_name, field_name, DATASET.c.metadata,\n False,\n offset=custom_offsets[field_name]\n ))\n elif field_name == 'uris':\n select_fields.append(Field('uris', 'uris'))\n\n return select_fields",
"def namehack(field):\n if field.endswith((\"attribute\", \"views\")):\n return field + \"__name\"\n else:\n return field",
"def test_no_duplicate_fields_in_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n ('Confused', {\n 'position': 3,\n 'fields': [\n ('first_name', 'generic_field', ),\n 'first',\n 'last',\n ],\n }), )\n duplicates = set(('first_name', 'first', 'last', ))\n expected = []\n for names in test_fieldsets[2][1]['fields']:\n if isinstance(names, str):\n names = (names, )\n names = [name for name in names if name not in duplicates]\n if names:\n expected.append({name: self.form.fields[name] for name in names})\n self.form.fieldsets = deepcopy(test_fieldsets)\n self.form.make_fieldsets()\n computed_fieldsets = self.form._fieldsets\n opts = computed_fieldsets[2][1]\n actual = opts['rows']\n\n self.assertEqual(1, len(actual), \"Rows of already used fields were added. \")\n self.assertEqual(1, len(actual[0]), \"Columns of already used fields were added. \")\n self.assertEqual(expected, actual)\n for lbl, opts in computed_fieldsets[:2]:\n row_names = flatten([list(row.keys()) for row in opts['rows']])\n self.assertEqual(opts['field_names'], row_names, \"Field missing from its expected first fieldset. \")\n\n self.form.fieldsets = original_fieldsets",
"def generate_field_name(container, field):\n if \"standard_name\" in container.fields[field]:\n field_name = container.fields[field][\"standard_name\"]\n elif \"long_name\" in container.fields[field]:\n field_name = container.fields[field][\"long_name\"]\n else:\n field_name = str(field)\n field_name = field_name.replace(\"_\", \" \")\n field_name = field_name[0].upper() + field_name[1:]\n return field_name",
"def undo_format_field_names(obj):\n if json_api_settings.FORMAT_FIELD_NAMES:\n return format_field_names(obj, \"underscore\")\n\n return obj",
"def setup_known_fields(self):\n\n kfields = dict(self.known_fields)\n freg = re.compile(r\"(^.+)_\\d+$\")\n for field in self:\n if self[field].get(\"units\") is not None:\n continue\n\n if field in kfields:\n self[field][\"units\"] = kfields[field]\n continue\n\n fs = freg.search(field)\n if fs and fs.groups()[0] in kfields:\n self[field][\"units\"] = kfields[fs.groups()[0]]",
"def add_fields(self, field_names, allow_m2m=True):\n alias = self.get_initial_alias()\n opts = self.get_meta()\n\n try:\n for name in field_names:\n field, target, u2, joins, u3, u4 = self.setup_joins(\n name.split(LOOKUP_SEP), opts, alias, False, allow_m2m,\n True)\n final_alias = joins[-1]\n col = target.column\n cols = [] if hasattr(col, \"columns\") else [col]\n for col in cols:\n if len(joins) > 1:\n join = self.alias_map[final_alias]\n if col == join.rhs_join_col:\n self.unref_alias(final_alias)\n final_alias = join.lhs_alias\n col = join.lhs_join_col\n joins = joins[:-1]\n self.promote_joins(joins[1:])\n self.select.append((final_alias, col))\n self.select_fields.append(field)\n except MultiJoin:\n raise FieldError(\"Invalid field name: '%s'\" % name)\n except FieldError:\n if LOOKUP_SEP in name:\n # For lookups spanning over relationships, show the error\n # from the model on which the lookup failed.\n raise\n else:\n names = sorted(opts.get_all_field_names() + list(self.extra)\n + list(self.aggregate_select))\n raise FieldError(\"Cannot resolve keyword %r into field. \"\n \"Choices are: %s\" % (name, \", \".join(names)))\n self.remove_inherited_models()",
"def get_fieldsets(self, request, obj=None):\n return (\n ('Name', {\n 'fields': (\n ('first_name', 'last_name'),)\n }),\n ('IPI', {\n 'fields': (\n ('ipi_name', 'ipi_base'),),\n }),\n ('Societies', {\n 'fields': (\n self.get_society_list(),),\n }),\n ('General agreement', {\n 'fields': (\n ('generally_controlled',\n ('saan', 'publisher_fee'))\n ),\n }),\n )",
"def test_prep_fields(self):\n pass",
"def __init__(self, field_names=..., **kwargs) -> None:\n ...",
"def _init_run_records_field(self, run_idx, run_record_key,\n field_name, field_shape, field_dtype):\n\n record_grp = self.run(run_idx)[run_record_key]\n\n # check if it is variable length\n if field_shape is Ellipsis:\n # make a special dtype that allows it to be\n # variable length\n vlen_dt = h5py.special_dtype(vlen=field_dtype)\n\n # this is only allowed to be a single dimension\n # since no real shape was given\n dset = record_grp.create_dataset(field_name, (0,), dtype=vlen_dt,\n maxshape=(None,))\n\n # its not just make it normally\n else:\n # create the group\n dset = record_grp.create_dataset(field_name, (0, *field_shape), dtype=field_dtype,\n maxshape=(None, *field_shape))\n\n return dset",
"def test_construct_fieldset_tag(attributes):\n fset = FieldSet(**attributes)\n assert fset.construct() == fieldset.render(attributes)",
"def namespaced_fields(self):\n ...",
"def init_record_fields(self, run_record_key, record_fields):\n\n record_fields_grp = self.settings_grp[RECORD_FIELDS]\n\n # make a dataset for the sparse fields allowed. this requires\n # a 'special' datatype for variable length strings. This is\n # supported by HDF5 but not numpy.\n vlen_str_dt = h5py.special_dtype(vlen=str)\n\n # create the dataset with the strings of the fields which are records\n record_group_fields_ds = record_fields_grp.create_dataset(run_record_key,\n (len(record_fields),),\n dtype=vlen_str_dt,\n maxshape=(None,))\n\n # set the flags\n for i, record_field in enumerate(record_fields):\n record_group_fields_ds[i] = record_field",
"def _field_prefix(self):\n if self.layer_name == 'geninfo':\n return ''\n return self.layer_name + '.'",
"def add_fields(self, fields):\n for label, data in fields.items():\n self[label] = data",
"def get_fieldsets(model):\n fieldsets = getattr(model, 'report_builder_fieldsets', None)\n if fieldsets:\n for fieldset_name, fieldset_dict in model.report_builder_fieldsets:\n fieldset_string_to_field(fieldset_dict, model)\n return fieldsets",
"def get_fieldsets(self, request, obj=None):\n base_fields = (\n None, {\n 'fields': ASCreationForm.Meta.fields\n }\n )\n host_ip_fields = (\n 'Host IPs', {\n 'fields': ('internal_ip', 'public_ip', 'bind_ip', )\n }\n )\n key_fields = (\n 'Keys & Certificates', {\n 'classes': ('collapse',),\n 'fields': (\n 'master_as_key',\n )\n }\n )\n if not obj:\n return (base_fields, host_ip_fields)\n return (base_fields, key_fields)",
"def field_names(self):\n ..."
] | [
"0.5953393",
"0.5751381",
"0.54727715",
"0.5424251",
"0.53929144",
"0.5327848",
"0.5306404",
"0.5271056",
"0.52634686",
"0.5145739",
"0.5141719",
"0.5112773",
"0.5019852",
"0.49609268",
"0.49462354",
"0.49419573",
"0.49116835",
"0.48910275",
"0.48370573",
"0.4824321",
"0.48100206",
"0.47849464",
"0.4747091",
"0.47399014",
"0.47205016",
"0.47064626",
"0.47063035",
"0.47020817",
"0.46900618",
"0.46784317"
] | 0.6066722 | 0 |
The make_fieldsets appends the top_errors with any errors found for hidden fields. | def test_top_errors_has_hidden_field_errors(self):
original_errors = getattr(self.form, '_errors', None)
original_cleaned_data = getattr(self.form, 'cleaned_data', None)
self.form._errors = ErrorDict()
self.form.cleaned_data = {}
name = 'hide_field'
test_error = "This is a test error. "
expected = self.form.error_class(error_class='nonfield')
expected.append(f'(Hidden field {name}) {test_error}')
self.form.add_error(name, test_error)
self.form.make_fieldsets()
top_errors = self.form._fs_summary['top_errors']
self.assertIn(name, self.form._errors)
self.assertEqual(expected, top_errors)
self.assertIsNotNone(getattr(self.form, '_fieldsets', None))
self.form.cleaned_data = original_cleaned_data
self.form._errors = original_errors
if original_errors is None:
del self.form._errors
if original_cleaned_data is None:
del self.form.cleaned_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_top_errors_at_top_html(self):\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form._errors = ErrorDict()\n self.form.cleaned_data = {}\n test_error = \"This non-field error is placed here just to pick on you. \"\n self.form.add_error(None, test_error)\n self.form.make_fieldsets()\n row_tag = 'p'\n html_output = self.form._html_output_new( # replicates as_p()\n row_tag=row_tag,\n col_head_tag=None,\n col_tag='span',\n single_col_tag='',\n col_head_data='',\n col_data='%(label)s %(field)s%(help_text)s',\n help_text_br=False,\n errors_on_separate_row=True,\n as_type='p'\n )\n html_rows = html_output.split('\\n')\n actual_top_html = html_rows[0]\n expected_top_html = self.form._html_tag(row_tag, test_error, ' id=\"top_errors\"')\n\n self.assertIn(NON_FIELD_ERRORS, self.form._errors)\n self.assertEqual(expected_top_html, actual_top_html)\n\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def test_make_fieldsets_outcome_order(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'position': None,\n 'fields': [\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n fieldsets[0], fieldsets[1] = fieldsets[1], fieldsets[0]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_overall_make_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_make_fieldsets_saves_results(self):\n original_initial_fieldsets = getattr(self.form, 'fieldsets', None)\n initial_fieldsets = deepcopy(original_initial_fieldsets)\n original_computed_fieldsets = getattr(self.form, '_fieldsets', None)\n original_summary = getattr(self.form, '_fs_summary', None)\n self.assertIsNotNone(original_initial_fieldsets)\n self.assertIsNone(original_computed_fieldsets)\n self.assertIsNone(original_summary)\n response_fieldsets = self.form.make_fieldsets()\n label, summary = response_fieldsets.pop()\n self.assertIsNotNone(self.form._fieldsets)\n self.assertIsNotNone(self.form._fs_summary)\n self.assertEqual('summary', label)\n self.assertEqual(summary, self.form._fs_summary)\n self.assertEqual(response_fieldsets, self.form._fieldsets)\n self.assertEqual(initial_fieldsets, self.form.fieldsets)\n\n self.form.fieldsets = original_initial_fieldsets\n self.form._fieldsets = original_computed_fieldsets\n self.form._fs_summary = original_summary\n if original_computed_fieldsets is None:\n del self.form._fieldsets\n if original_summary is None:\n del self.form._fs_summary",
"def test_raises_if_initial_fieldsets_error(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }), )\n position_missing_fieldsets = deepcopy(test_fieldsets)\n del position_missing_fieldsets[1][1]['position']\n fields_missing_fieldsets = deepcopy(test_fieldsets)\n del fields_missing_fieldsets[0][1]['fields']\n message = \"There must be 'fields' and 'position' in each fieldset. \"\n self.form.fieldsets = position_missing_fieldsets\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets()\n self.form.fieldsets = fields_missing_fieldsets\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets()\n\n self.form.fieldsets = original_fieldsets",
"def test_no_empty_sets_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n ('Non_Fields', {\n 'position': 2,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 2)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_no_empty_rows_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_a_field',\n ('last_name', 'another_field', ),\n ('first_name', 'non-field_name', ),\n 'generic_field',\n 'last',\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: remaining_fields.pop(name) for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 3)\n self.assertEqual(len(fieldsets[1][1]['rows']), 4)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_missing_initial_fieldsets(self):\n original_initial_fieldsets = self.form.fieldsets\n print(\"========================= TEST UNABLE TO DELETE THE PROPERTY FOR TESTING ========================\")\n print(original_initial_fieldsets)\n print(\"--------------------------------------\")\n delattr(self.form, 'fieldsets')\n response_fieldsets = self.form.make_fieldsets()\n print(response_fieldsets)\n\n setattr(self.form, 'fieldsets', original_initial_fieldsets)",
"def test_when_only_hidden_fields(self):\n original_fields = self.form.fields\n test_fields = deepcopy(original_fields)\n test_fields = {name: field for name, field in test_fields.items() if isinstance(field, CharField)}\n for name, field in test_fields.items():\n widget = field.hidden_widget\n widget = widget()\n if field.localize:\n widget.is_localized = True\n widget.is_required = field.required\n extra_attrs = field.widget_attrs(widget)\n if extra_attrs:\n widget.attrs.update(extra_attrs)\n field.widget = widget\n self.form.fields = test_fields\n self.form.make_fieldsets()\n expected = ''.join(self.form._fs_summary['hidden_fields'])\n self.assertEqual([], self.form._fieldsets)\n for as_type in ('as_p', 'as_ul', 'as_table', 'as_fieldset'):\n output = getattr(self.form, as_type)()\n message = \"Hidden fields not found in output {}: \\n\\n{} \\n\\n{}\".format(as_type.upper(), expected, output)\n self.assertIn(expected, output, message)\n\n self.form.fields = original_fields",
"def test_form_main_rows_all_fieldsets(self):\n # form.form_main_rows(self, html_args, fieldsets, form_col_count)\n # html_args = (row_tag, col_head_tag, col_tag, single_col_tag, as_type, all_fieldsets)\n pass",
"def test_computed_fieldsets_structure(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n self.form.make_fieldsets()\n fieldsets = self.form._fieldsets\n each_are_tuples = (isinstance(ea, tuple) for ea in fieldsets)\n correct_fieldset_labels = (isinstance(label, (str, type(None))) for label, opts in fieldsets)\n opts_are_dictionaries = (isinstance(opts, dict) for label, opts in fieldsets)\n required_keys = {'position', 'fields', 'field_names', 'rows', 'column_count', }\n optional_keys = {'classes', 'modifiers', 'row_data', }\n allowed_keys = required_keys | optional_keys\n opt_keys = set(flatten([list(opts.keys()) for lbl, opts, in fieldsets]))\n unaccepted_keys = [key for key in opt_keys if key not in allowed_keys]\n has_required = (all(key in opts for key in required_keys) for lbl, opts in fieldsets)\n self.assertIsInstance(fieldsets, list)\n self.assertTrue(all(each_are_tuples))\n self.assertTrue(all(correct_fieldset_labels))\n self.assertTrue(all(opts_are_dictionaries))\n self.assertEqual(len(unaccepted_keys), 0)\n self.assertFalse(unaccepted_keys)\n self.assertTrue(all(has_required))\n\n self.form.fieldsets = original_fieldsets",
"def setup_error_data(self, field_setup, error_names, is_table=False, col_tag='span', single_col_tag=''):\n backup_fieldset_fields = [\n ('first', 'second'),\n 'billing_address_1',\n ('billing_city', 'billing_country_area', 'billing_postcode'),\n 'last',\n ]\n field_setup = field_setup or backup_fieldset_fields\n error_names = set(error_names or flatten(field_setup))\n col_count = max([1 if isinstance(ea, str) else len(ea) for ea in field_setup])\n error_txt = \"This is a {} test error. \"\n row_info = []\n for row in field_setup:\n if isinstance(row, str):\n row = [row]\n multi_col_row = len(row) > 1\n if is_table:\n cur_tag = 'td'\n error_settings = (cur_tag, multi_col_row, col_count, True, True)\n attr = ' colspan=\"{}\"'.format(2 if multi_col_row else 2 * col_count)\n else:\n cur_tag = col_tag if multi_col_row else single_col_tag\n error_settings = (cur_tag, multi_col_row, col_count, False, False)\n attr = ''\n error_list = [error_txt.format(name) if name in error_names else '' for name in row]\n columns = [{'errors': ea} for ea in error_list]\n expected = [err if not cur_tag else self.form._html_tag(cur_tag, err, attr) for err in error_list]\n if all(ea == '' for ea in error_list):\n expected = []\n actual = self.form.get_error_data(columns, error_settings)\n row_summary = {'expected': expected, 'actual': actual, 'field_names': row, 'settings': error_settings}\n row_summary['columns'] = columns\n row_info.append(row_summary)\n return row_info",
"def test_hidden_fields_at_bottom(self):\n hidden_fields = self.form.hidden_fields() # The boundfield objects for all hidden fields.\n str_hidden = ''.join(str(bf) for bf in hidden_fields)\n self.assertTrue(str_hidden, \"There are no hidden fields to confirm they were included correctly. \")\n for as_type in ('as_p', 'as_ul', 'as_table', 'as_fieldset'):\n output = getattr(self.form, as_type)()\n last_row = output.split('\\n')[-1]\n message = \"Hidden fields not found in final HTML row for {}\".format(as_type.upper())\n self.assertIn(str_hidden, last_row, message)",
"def test_form_main_rows_simple(self):\n # TODO: Better Test for this. After a lot of setup, the following is nearly a copy of tested code.\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n self.form.make_fieldsets()\n fieldsets = deepcopy(self.form._fieldsets)\n for as_type in ('p', 'ul', 'fieldset', 'table'):\n all_fieldsets = True if as_type == 'fieldset' else False\n form_col_count = 1 if all_fieldsets else self.form._fs_summary['columns']\n errors_on_separate_row = False\n help_tag, help_text_br = 'span', as_type == 'table'\n if as_type == 'table':\n row_tag, col_tag, single_col_tag, col_head_tag = 'tr', 'td', 'td', 'th'\n col_double, allow_colspan, attr_on_lonely_col = True, True, True\n col_head_data = '%(label)s'\n col_data = '%(errors)s%(field)s%(help_text)s'\n else:\n row_tag = 'li' if as_type == 'ul' else 'p'\n col_tag, single_col_tag, col_head_tag = 'span', '', None\n col_double, allow_colspan, attr_on_lonely_col = False, False, False\n col_head_data = ''\n col_data = '%(errors)s%(label)s %(field)s%(help_text)s'\n if as_type == 'p':\n col_data = '%(label)s %(field)s%(help_text)s'\n errors_on_separate_row = True\n html_col_tags = (col_head_tag, col_tag, single_col_tag)\n col_format, single_col_format = self.form.column_formats(*html_col_tags, col_head_data, col_data)\n for fieldset_label, opts in fieldsets:\n col_count = opts['column_count'] if fieldset_label else form_col_count\n format_tags = (col_format, single_col_format, row_tag, col_tag, single_col_tag, help_tag, help_text_br)\n settings = (errors_on_separate_row, {}, col_count, allow_colspan, col_double, attr_on_lonely_col)\n opts['row_data'] = self.form.collect_row_data(opts, settings, format_tags)\n html_args = (row_tag, *html_col_tags, as_type, all_fieldsets)\n actual = self.form.form_main_rows(html_args, fieldsets, form_col_count)\n expected = []\n for fieldset_label, opts in fieldsets:\n row_data = opts['row_data']\n if all_fieldsets or fieldset_label is not None:\n fieldset_classes = list(opts.get('classes', []))\n if not fieldset_label and self.form.untitled_fieldset_class:\n fieldset_classes.append(self.form.untitled_fieldset_class)\n fieldset_attr = ' class=\"%s\"' % ' '.join(fieldset_classes) if fieldset_classes else ''\n container = None if as_type in ('p', 'fieldset') else as_type\n data = '\\n'.join(row_data)\n if container:\n container_attr = f' class=\"fieldset_{as_type}\"'\n data = self.form._html_tag(container, data, container_attr) + '\\n'\n legend = self.form._html_tag('legend', fieldset_label) + '\\n' if fieldset_label else ''\n fieldset_el = self.form._html_tag('fieldset', legend + data, fieldset_attr)\n if container:\n row_attr = ' class=\"fieldset_row\"'\n fieldset_el = self.form.make_headless_row(html_args, fieldset_el, form_col_count, '', row_attr)\n expected.append(fieldset_el)\n else:\n expected.extend(row_data)\n self.assertEqual(len(expected), len(actual))\n for expect, got in zip(expected, actual):\n if expect != got:\n print(f\"======================== TEST MAIN ROWS as type: {as_type} ==========================\")\n print(expect)\n print(\"*****************\")\n print(got)\n print(\"-----------------------------------\")\n self.assertEqual(expect, got)\n\n self.form.fieldsets = original_fieldsets",
"def errors(self):\r\n if not hasattr(self, '_errors_cache'):\r\n self._errors_cache = self.form.get_field_errors(self)\r\n return self._errors_cache",
"def test_make_fieldsets_uses_prep_fields(self):\n original_called_prep_fields = self.form.called_prep_fields = False\n full_fieldsets = self.form.make_fieldsets()\n\n self.assertFalse(original_called_prep_fields)\n self.assertIsInstance(full_fieldsets, (list, tuple))\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n self.assertTrue(self.form.called_prep_fields)\n\n self.form.called_prep_fields = original_called_prep_fields",
"def set_form_hidden_fields(formset, fields_to_show):\n for form in formset:\n for field in form.fields:\n if not any(field in s for s in fields_to_show):\n form.fields[field].widget = forms.HiddenInput()",
"def set_form_hidden_fields_hidden_fields(formset, fields_to_hide):\n for form in formset:\n for field in form.fields:\n if field in fields_to_hide:\n form.fields[field].widget = forms.HiddenInput()",
"def as_bootstrap(self):\n top_errors = self.non_field_errors() # Errors that should be displayed above all fields.\n output, hidden_fields = [], []\n normal_row = u'<div%(html_class_attr)s>%(label)s<div class=\"controls\">%(field)s%(help_text)s</div>%(errors)s</div>'\n boolean_row = u'<div%(html_class_attr)s><div class=\"controls\">%(label_and_field)s%(help_text)s</div>%(errors)s</div>'\n error_row = u'<div class=\"alert alert-error\">%s</div>'\n row_ender = u'</div>'\n help_text_html = u'<span class=\"help-inline\">%s</span>'\n errors_on_separate_row = False\n\n for name, field in self.fields.items():\n html_class_attr = ''\n bf = self[name]\n is_boolean = isinstance(field, forms.fields.BooleanField)\n bf_errors = self.error_class([conditional_escape(error) for error in bf.errors]) # Escape and cache in local variable.\n if bf.is_hidden:\n if bf_errors:\n top_errors.extend([u'(Hidden field %s) %s' % (name, force_unicode(e)) for e in bf_errors])\n hidden_fields.append(unicode(bf))\n else:\n # Create a 'class=\"...\"' atribute if the row should have any\n # CSS classes applied.\n css_classes = bf.css_classes(extra_classes='control-group')\n if css_classes:\n html_class_attr = ' class=\"%s\"' % css_classes\n\n if errors_on_separate_row and bf_errors:\n output.append(error_row % force_unicode(bf_errors))\n\n if bf.label:\n label = conditional_escape(force_unicode(bf.label))\n if is_boolean:\n label = bf.label_tag(unicode(bf) + label,\n attrs={'class': 'checkbox'}) or ''\n else:\n # Only add the suffix if the label does not end in\n # punctuation.\n if self.label_suffix:\n if label[-1] not in ':?.!':\n label += self.label_suffix\n\n label = bf.label_tag(label,\n attrs={'class': 'control-label'}) or ''\n else:\n label = ''\n\n if field.help_text:\n help_text = help_text_html % force_unicode(field.help_text)\n else:\n help_text = u''\n\n if bf_errors:\n errors = u' '.join([error_row % force_unicode(error)\n for error in bf_errors])\n else:\n errors = u''\n\n if is_boolean:\n output.append(boolean_row % {\n 'errors': errors,\n 'label_and_field': force_unicode(label),\n 'help_text': help_text,\n 'html_class_attr': html_class_attr\n })\n else:\n output.append(normal_row % {\n 'errors': errors,\n 'label': force_unicode(label),\n 'field': unicode(bf),\n 'help_text': help_text,\n 'html_class_attr': html_class_attr\n })\n\n if top_errors:\n output.insert(0, error_row % force_unicode(top_errors))\n\n if hidden_fields: # Insert any hidden fields in the last row.\n str_hidden = u''.join(hidden_fields)\n if output:\n last_row = output[-1]\n # Chop off the trailing row_ender (e.g. '</td></tr>') and\n # insert the hidden fields.\n if not last_row.endswith(row_ender):\n # This can happen in the as_p() case (and possibly others\n # that users write): if there are only top errors, we may\n # not be able to conscript the last row for our purposes,\n # so insert a new, empty row.\n last_row = (normal_row % {'errors': '', 'label': '',\n 'field': '', 'help_text': '',\n 'html_class_attr': html_class_attr})\n output.append(last_row)\n output[-1] = last_row[:-len(row_ender)] + str_hidden + row_ender\n else:\n # If there aren't any rows in the output, just append the\n # hidden fields.\n output.append(str_hidden)\n return mark_safe(u'\\n'.join(output))",
"def test_no_duplicate_fields_in_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n ('Confused', {\n 'position': 3,\n 'fields': [\n ('first_name', 'generic_field', ),\n 'first',\n 'last',\n ],\n }), )\n duplicates = set(('first_name', 'first', 'last', ))\n expected = []\n for names in test_fieldsets[2][1]['fields']:\n if isinstance(names, str):\n names = (names, )\n names = [name for name in names if name not in duplicates]\n if names:\n expected.append({name: self.form.fields[name] for name in names})\n self.form.fieldsets = deepcopy(test_fieldsets)\n self.form.make_fieldsets()\n computed_fieldsets = self.form._fieldsets\n opts = computed_fieldsets[2][1]\n actual = opts['rows']\n\n self.assertEqual(1, len(actual), \"Rows of already used fields were added. \")\n self.assertEqual(1, len(actual[0]), \"Columns of already used fields were added. \")\n self.assertEqual(expected, actual)\n for lbl, opts in computed_fieldsets[:2]:\n row_names = flatten([list(row.keys()) for row in opts['rows']])\n self.assertEqual(opts['field_names'], row_names, \"Field missing from its expected first fieldset. \")\n\n self.form.fieldsets = original_fieldsets",
"def test_form_main_rows_all_fieldsets_has_container(self):\n # form.form_main_rows(self, html_args, fieldsets, form_col_count)\n # html_args = (row_tag, col_head_tag, col_tag, single_col_tag, as_type, all_fieldsets)\n pass",
"def add_errors(self, errors):\n self.errors = merge_errors(self.errors, errors)",
"def _find_errors(self, new_response: response_domain_model.Response):\n self._reset_child_state()\n for response in self._responses_to_replay:\n for question_code, conditional in self.requirements.items():\n uncaught_errors = conditional.get_errors(response, question_code=question_code)\n if uncaught_errors:\n # Should not be able to get errors on previously passed responses\n # (invalid answers should be ignored when checking conditionals)\n raise Exception('Invalid answers found in previously checked responses')\n\n new_errors = []\n for question_code, conditional in self.requirements.items():\n new_errors.extend(conditional.get_errors(new_response, question_code=question_code))\n\n if new_errors:\n # Recurse again until there are no new errors found\n new_errors.extend(self._find_errors(new_response))\n\n return new_errors",
"def errors(self, errors):\n \n self._errors = errors",
"def validation_errors(self, validation_errors):\n self._validation_errors = validation_errors",
"def errors(self, errors):\n\n self._errors = errors",
"def test_html_output_formfieldset_use_focus_if_present(self):\n original_focus_called = self.form.called_assign_focus_field\n for as_type in ('as_p', 'as_ul', 'as_table', 'as_fieldset'):\n self.form.called_assign_focus_field = False\n html_output = getattr(self.form, as_type)()\n message = \"The FormFieldsetMixIn new _html_output failed on {}\".format(as_type)\n self.assertTrue(self.form.called_assign_focus_field, message)\n self.assertIsNotNone(html_output)\n\n self.form.called_assign_focus_field = original_focus_called",
"def get_wtf_errors(self, wtf_errors):\n\t\tmessages = []\n\t\tmessages.append('<ol class=\"wtf-errors\">')\n\t\tfor field, errors in wtf_errors.iteritems():\n\t\t\tmessages.append(\"<li>\"+field+\": <br />\")\n\t\t\tfor error in errors:\n\t\t\t\tmessages.append(\"— \"+error+ \"<br />\")\n\t\t\tmessages.append(\"</li>\")\n\t\tmessages.append(\"</ol>\")\n\t\treturn \"\".join(messages)",
"def field_errors(bound_field):\n seen = []\n errors = {}\n if hasattr(bound_field.field, \"fields\"):\n for idx, subfield in enumerate(bound_field.field.fields):\n key = \"%s_%d\" % (bound_field.auto_id, idx)\n subfield_errors = getattr(subfield.widget, \"errors\", [])\n errors[key] = subfield_errors\n seen.extend(subfield_errors)\n for error in bound_field.errors:\n if error not in seen:\n errors.setdefault(bound_field.auto_id, [])\n errors[bound_field.auto_id].append(error)\n return errors.items()",
"def validation_errors(self):\n return self._validation_errors"
] | [
"0.6465135",
"0.6115833",
"0.59661514",
"0.5934159",
"0.58572865",
"0.58312654",
"0.566221",
"0.558073",
"0.5526183",
"0.5521391",
"0.54735476",
"0.54313666",
"0.54068094",
"0.540523",
"0.53880537",
"0.53808004",
"0.5351047",
"0.5336266",
"0.5306288",
"0.530005",
"0.52970535",
"0.52127385",
"0.5139974",
"0.51088923",
"0.5070558",
"0.5039584",
"0.50196236",
"0.50020784",
"0.49641675",
"0.49534312"
] | 0.75544244 | 0 |
The make_fieldsets method calls the handle_modifiers method (from FormOverrideMixIn) if it is present. | def test_make_fieldsets_uses_handle_modifiers(self):
original_called_handle_modifiers = self.form.called_handle_modifiers = False
full_fieldsets = self.form.make_fieldsets()
self.assertFalse(original_called_handle_modifiers)
self.assertIsInstance(full_fieldsets, (list, tuple))
self.assertIsNotNone(getattr(self.form, '_fieldsets', None))
self.assertTrue(self.form.called_handle_modifiers)
self.form.called_handle_modifiers = original_called_handle_modifiers | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_handle_modifiers(self):\n # FormOverrideMixIn.handle_modifiers\n pass",
"def test_overall_make_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_make_fieldsets_uses_prep_fields(self):\n original_called_prep_fields = self.form.called_prep_fields = False\n full_fieldsets = self.form.make_fieldsets()\n\n self.assertFalse(original_called_prep_fields)\n self.assertIsInstance(full_fieldsets, (list, tuple))\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n self.assertTrue(self.form.called_prep_fields)\n\n self.form.called_prep_fields = original_called_prep_fields",
"def test_computed_fieldsets_structure(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n self.form.make_fieldsets()\n fieldsets = self.form._fieldsets\n each_are_tuples = (isinstance(ea, tuple) for ea in fieldsets)\n correct_fieldset_labels = (isinstance(label, (str, type(None))) for label, opts in fieldsets)\n opts_are_dictionaries = (isinstance(opts, dict) for label, opts in fieldsets)\n required_keys = {'position', 'fields', 'field_names', 'rows', 'column_count', }\n optional_keys = {'classes', 'modifiers', 'row_data', }\n allowed_keys = required_keys | optional_keys\n opt_keys = set(flatten([list(opts.keys()) for lbl, opts, in fieldsets]))\n unaccepted_keys = [key for key in opt_keys if key not in allowed_keys]\n has_required = (all(key in opts for key in required_keys) for lbl, opts in fieldsets)\n self.assertIsInstance(fieldsets, list)\n self.assertTrue(all(each_are_tuples))\n self.assertTrue(all(correct_fieldset_labels))\n self.assertTrue(all(opts_are_dictionaries))\n self.assertEqual(len(unaccepted_keys), 0)\n self.assertFalse(unaccepted_keys)\n self.assertTrue(all(has_required))\n\n self.form.fieldsets = original_fieldsets",
"def test_make_fieldsets_outcome_order(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'position': None,\n 'fields': [\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n fieldsets[0], fieldsets[1] = fieldsets[1], fieldsets[0]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def change_form_fieldsets(admin_form):\n form = admin_form.form\n readonly_fields = admin_form.readonly_fields\n model_admin = admin_form.model_admin\n\n for name, options in admin_form.fieldsets:\n yield ChangeFormFieldset(form=form,\n name=name,\n readonly_fields=readonly_fields,\n model_admin=model_admin,\n **options)",
"def get_fieldsets(self, request, obj=None):\n if not obj:\n return self.fieldsets_without_readonly\n return super().get_fieldsets(request, obj=obj)",
"def get_fieldsets(self, request, obj=None):\n if obj:\n return self._change_fieldsets\n return self._add_fieldsets",
"def test_missing_initial_fieldsets(self):\n original_initial_fieldsets = self.form.fieldsets\n print(\"========================= TEST UNABLE TO DELETE THE PROPERTY FOR TESTING ========================\")\n print(original_initial_fieldsets)\n print(\"--------------------------------------\")\n delattr(self.form, 'fieldsets')\n response_fieldsets = self.form.make_fieldsets()\n print(response_fieldsets)\n\n setattr(self.form, 'fieldsets', original_initial_fieldsets)",
"def test_make_fieldsets_saves_results(self):\n original_initial_fieldsets = getattr(self.form, 'fieldsets', None)\n initial_fieldsets = deepcopy(original_initial_fieldsets)\n original_computed_fieldsets = getattr(self.form, '_fieldsets', None)\n original_summary = getattr(self.form, '_fs_summary', None)\n self.assertIsNotNone(original_initial_fieldsets)\n self.assertIsNone(original_computed_fieldsets)\n self.assertIsNone(original_summary)\n response_fieldsets = self.form.make_fieldsets()\n label, summary = response_fieldsets.pop()\n self.assertIsNotNone(self.form._fieldsets)\n self.assertIsNotNone(self.form._fs_summary)\n self.assertEqual('summary', label)\n self.assertEqual(summary, self.form._fs_summary)\n self.assertEqual(response_fieldsets, self.form._fieldsets)\n self.assertEqual(initial_fieldsets, self.form.fieldsets)\n\n self.form.fieldsets = original_initial_fieldsets\n self.form._fieldsets = original_computed_fieldsets\n self.form._fs_summary = original_summary\n if original_computed_fieldsets is None:\n del self.form._fieldsets\n if original_summary is None:\n del self.form._fs_summary",
"def test_raises_if_missed_fields(self):\n name = 'second'\n self.form.called_handle_modifiers = False\n remove = {'remove_field': name}\n self.form.handle_modifiers({}, [], **remove)\n self.assertNotIn(name, self.form.fields)\n self.assertIn(name, self.form.hold_field)\n message = \"Some unassigned fields, perhaps some added during handle_modifiers. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets(add_field=name)\n self.form.called_handle_modifiers = False",
"def test_html_output_formfieldset_use_focus_if_present(self):\n original_focus_called = self.form.called_assign_focus_field\n for as_type in ('as_p', 'as_ul', 'as_table', 'as_fieldset'):\n self.form.called_assign_focus_field = False\n html_output = getattr(self.form, as_type)()\n message = \"The FormFieldsetMixIn new _html_output failed on {}\".format(as_type)\n self.assertTrue(self.form.called_assign_focus_field, message)\n self.assertIsNotNone(html_output)\n\n self.form.called_assign_focus_field = original_focus_called",
"def get_form_class(self):\n\t\treturn formset_factory(super(FormsetMixin, self).get_form_class(), **self.get_formset_kwargs())",
"def get_formset(self, **kwargs):\n return self.formsets[kwargs.get('prefix')](\n data=self.get_form_kwargs().get('data'),\n **kwargs\n )",
"def test_no_empty_sets_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n ('Non_Fields', {\n 'position': 2,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 2)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def get_fieldsets(self, request, obj=None):\n if request.user.user_type == User.ADMIN_CEA:\n return self.cea_fieldsets\n elif request.user.user_type == User.ADMIN_CRC:\n return self.crc_fieldsets\n elif request.user.user_type == User.EXPRESS_USER:\n return self.exp_fieldsets\n return self.fieldsets",
"def form_tweaks(self):\n pass",
"def formset_factory(form, params=[], equip_types=[], up=[], down=[], front_or_back=[],\n formset=BaseFormSet, extra=1, can_order=False, can_delete=False, max_num=None):\n attrs = {'form': form, 'extra': extra, 'max_num': max_num, 'can_order': can_order, 'can_delete': can_delete,\n 'params': params, 'equip_types': equip_types, 'up': up, 'down': down, 'front_or_back': front_or_back}\n\n return type(form.__name__ + 'Set', (formset,), attrs)",
"def make_fields(self):\n for name, prop in self.edit:\n instance_value = self.model.get(name)\n post_value = self.data[name] if (self.data and self.data.has_key(name)) else instance_value\n form_field_class = self.get_field_type(prop)\n form_field = form_field_class(model=self.model, property=prop, name=name, instance_value=instance_value, post_value=post_value)\n self.add(form_field)",
"def extend_or_add_fields(cls, subfields, dbmanager, flag_mixin_atroot, propname, proplabel):\n import mdbmodel_fieldset\n if (flag_mixin_atroot):\n # prepare extra fields that will be added at root; this doesnt actually create any prerequisites\n cls.extend_fields(subfields)\n else:\n # add a special sub table that will contain some fields, using a helper class object attached to us\n # create (AND REGISTER) the new helper object\n backrefname = cls.get_dbtablename_pure()\n mdbmodel_fieldset.MewloDbFieldset.make_fieldset_dbobjectclass(cls, propname, proplabel, backrefname, dbmanager, subfields)",
"def get_fieldsets(self, default):\n default = default + ['-']\n\n last = None\n fields = []\n for perm in self.__permissions_to_manage():\n if last != perm.content_type:\n if fields:\n default = default + ['h3:'+last.model_class()._meta.verbose_name_plural, segment(chunks(fields, 4))]\n last = perm.content_type\n fields = []\n\n fields = fields + [perm.codename]\n\n default = default + ['h3:'+last.model_class()._meta.verbose_name_plural, segment(chunks(fields, 4))]\n return default",
"def formset_factory(form, formset=BaseFormSet, extra=1, can_order=False,\n can_delete=False, max_num=None, validate_max=False,\n min_num=None, validate_min=False, absolute_max=None,\n can_delete_extra=True):\n if min_num is None:\n min_num = DEFAULT_MIN_NUM\n if max_num is None:\n max_num = DEFAULT_MAX_NUM\n # absolute_max is a hard limit on forms instantiated, to prevent\n # memory-exhaustion attacks. Default to max_num + DEFAULT_MAX_NUM\n # (which is 2 * DEFAULT_MAX_NUM if max_num is None in the first place).\n if absolute_max is None:\n absolute_max = max_num + DEFAULT_MAX_NUM\n if max_num > absolute_max:\n raise ValueError(\n \"'absolute_max' must be greater or equal to 'max_num'.\"\n )\n attrs = {\n 'form': form,\n 'extra': extra,\n 'can_order': can_order,\n 'can_delete': can_delete,\n 'can_delete_extra': can_delete_extra,\n 'min_num': min_num,\n 'max_num': max_num,\n 'absolute_max': absolute_max,\n 'validate_min': validate_min,\n 'validate_max': validate_max,\n }\n return type(form.__name__ + 'FormSet', (formset,), attrs)",
"def get_formset_kwargs(self):\n return {\n 'can_order':self.can_order,\n 'can_delete':self.can_delete,\n 'extra':self.extra,\n 'max_num' : self.max_num,\n 'validate_max' : self.validate_max,\n 'min_num' : self.min_num,\n 'validate_min' : self.validate_min,\n }",
"def _generate_formset_class(\n request, model, modelfield, baseformclass, formsetfieldelement\n):\n\n formfieldelements = _get_form_fields_from_layout(\n _layout.BaseElement(*formsetfieldelement)\n ) # make sure the _layout.form.FormSetField does not be considered recursively\n\n formclass = breadmodelform_factory(\n request=request,\n model=modelfield.related_model,\n layout=formfieldelements,\n instance=None,\n baseformclass=baseformclass,\n )\n\n base_formset_kwargs = {\n \"fields\": [\n formfieldelement.fieldname for formfieldelement in formfieldelements\n ],\n \"form\": formclass,\n \"extra\": 0,\n \"can_delete\": True,\n }\n base_formset_kwargs.update(formsetfieldelement.formsetfactory_kwargs)\n if isinstance(modelfield, GenericRelation):\n return generic_inlineformset_factory(\n modelfield.related_model,\n ct_field=modelfield.content_type_field_name,\n fk_field=modelfield.object_id_field_name,\n formset=InlineFormSetWithLimits,\n formfield_callback=lambda field: _formfield_callback_with_request(\n field, request, modelfield.related_model\n ),\n **base_formset_kwargs,\n )\n else:\n return forms.models.inlineformset_factory(\n model,\n modelfield.related_model,\n formset=InlineFormSetWithLimits,\n formfield_callback=lambda field: _formfield_callback_with_request(\n field, request, model\n ),\n **base_formset_kwargs,\n )",
"def process_show_formset(self, request, step, formset):\n pass",
"def get_formset(self, request, obj=None, **kwargs):\n\n kwargs['formfield_callback'] = partial(\n self.formfield_for_dbfield, request=request, obj=obj)\n return super(ObjectInlineMixin, self) \\\n .get_formset(request, obj, **kwargs)",
"def test_raises_if_initial_fieldsets_error(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }), )\n position_missing_fieldsets = deepcopy(test_fieldsets)\n del position_missing_fieldsets[1][1]['position']\n fields_missing_fieldsets = deepcopy(test_fieldsets)\n del fields_missing_fieldsets[0][1]['fields']\n message = \"There must be 'fields' and 'position' in each fieldset. \"\n self.form.fieldsets = position_missing_fieldsets\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets()\n self.form.fieldsets = fields_missing_fieldsets\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets()\n\n self.form.fieldsets = original_fieldsets",
"def get_formset_kwargs(self):\n\t\treturn {\n\t\t\t'extra': self.extra,\n\t\t\t'can_order': self.can_order,\n\t\t\t'can_delete': self.can_delete,\n\t\t\t'max_num': self.max_num,\t\t\n\t\t}",
"def getFormFields(self, request, fieldSet = None):\n fields = []\n if fieldSet is None:\n fieldSet = self.formFields\n if not self.shouldProcess(request):\n return fieldSet\n\n for field in fieldSet:\n if len(field)==5:\n inputType, displayName, inputName, inputValue, description = field\n else:\n inputType, displayName, inputName, inputValue = field\n description = \"\"\n\n if inputType == 'checkbox':\n if request.args.has_key('__checkboxes__'):\n if inputName in request.args['__checkboxes__']:\n inputValue = 1\n else:\n inputValue = 0\n else:\n inputValue = 0\n elif inputType in ('checkgroup', 'radio'):\n if request.args.has_key(inputName):\n keys = request.args[inputName]\n else:\n keys = []\n iv = inputValue\n inputValue = []\n for optionName, optionDisplayName, checked in iv:\n checked = optionName in keys\n inputValue.append([optionName, optionDisplayName, checked])\n elif request.args.has_key(inputName):\n iv = request.args[inputName][0]\n if inputType in ['menu', 'multimenu']:\n if iv in inputValue:\n inputValue.remove(iv)\n inputValue.insert(0, iv)\n else:\n inputValue = iv\n fields.append([inputType, displayName, inputName, inputValue, description])\n return fields",
"def test_make_fieldsets_names_can_be_coded(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n (None, {\n 'position': 1,\n 'fields': [\n ('first', 'second', ),\n ('_name_for_coded', 'last', ),\n ],\n }),\n ('Your Name', {\n 'position': 2,\n 'fields': [('first_name', 'last_name', )],\n }), )\n self.form.fieldsets = test_fieldsets\n expected_name = self.form.name_for_coded\n self.form.make_fieldsets()\n computed_fieldsets = self.form._fieldsets\n opts = computed_fieldsets[0][1]\n target = opts['rows'][1]\n self.assertIn(expected_name, target.keys())\n self.assertEqual(self.form.fields.get(expected_name), target.get(expected_name, ''))\n self.assertIn('_name_for_coded', opts['field_names'])\n\n self.form.fieldsets = original_fieldsets"
] | [
"0.64318436",
"0.63963795",
"0.6121364",
"0.60134304",
"0.5967845",
"0.58336",
"0.57580954",
"0.57000554",
"0.5655005",
"0.55753636",
"0.55143034",
"0.5351658",
"0.53252023",
"0.5285269",
"0.52683055",
"0.5224833",
"0.5220986",
"0.5168513",
"0.51611114",
"0.5140313",
"0.51210254",
"0.5115722",
"0.5093927",
"0.5090956",
"0.5077081",
"0.50763357",
"0.504736",
"0.5027652",
"0.5022057",
"0.50041497"
] | 0.8040682 | 0 |
The make_fieldsets method saves the computed fieldsets to form._fieldsets, and saves a form._fs_summary. | def test_make_fieldsets_saves_results(self):
original_initial_fieldsets = getattr(self.form, 'fieldsets', None)
initial_fieldsets = deepcopy(original_initial_fieldsets)
original_computed_fieldsets = getattr(self.form, '_fieldsets', None)
original_summary = getattr(self.form, '_fs_summary', None)
self.assertIsNotNone(original_initial_fieldsets)
self.assertIsNone(original_computed_fieldsets)
self.assertIsNone(original_summary)
response_fieldsets = self.form.make_fieldsets()
label, summary = response_fieldsets.pop()
self.assertIsNotNone(self.form._fieldsets)
self.assertIsNotNone(self.form._fs_summary)
self.assertEqual('summary', label)
self.assertEqual(summary, self.form._fs_summary)
self.assertEqual(response_fieldsets, self.form._fieldsets)
self.assertEqual(initial_fieldsets, self.form.fieldsets)
self.form.fieldsets = original_initial_fieldsets
self.form._fieldsets = original_computed_fieldsets
self.form._fs_summary = original_summary
if original_computed_fieldsets is None:
del self.form._fieldsets
if original_summary is None:
del self.form._fs_summary | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_overall_make_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_make_fieldsets_uses_prep_fields(self):\n original_called_prep_fields = self.form.called_prep_fields = False\n full_fieldsets = self.form.make_fieldsets()\n\n self.assertFalse(original_called_prep_fields)\n self.assertIsInstance(full_fieldsets, (list, tuple))\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n self.assertTrue(self.form.called_prep_fields)\n\n self.form.called_prep_fields = original_called_prep_fields",
"def test_make_fieldsets_outcome_order(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'position': None,\n 'fields': [\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n fieldsets[0], fieldsets[1] = fieldsets[1], fieldsets[0]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def get_fieldsets(model):\n fieldsets = getattr(model, 'report_builder_fieldsets', None)\n if fieldsets:\n for fieldset_name, fieldset_dict in model.report_builder_fieldsets:\n fieldset_string_to_field(fieldset_dict, model)\n return fieldsets",
"def test_computed_fieldsets_structure(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n self.form.make_fieldsets()\n fieldsets = self.form._fieldsets\n each_are_tuples = (isinstance(ea, tuple) for ea in fieldsets)\n correct_fieldset_labels = (isinstance(label, (str, type(None))) for label, opts in fieldsets)\n opts_are_dictionaries = (isinstance(opts, dict) for label, opts in fieldsets)\n required_keys = {'position', 'fields', 'field_names', 'rows', 'column_count', }\n optional_keys = {'classes', 'modifiers', 'row_data', }\n allowed_keys = required_keys | optional_keys\n opt_keys = set(flatten([list(opts.keys()) for lbl, opts, in fieldsets]))\n unaccepted_keys = [key for key in opt_keys if key not in allowed_keys]\n has_required = (all(key in opts for key in required_keys) for lbl, opts in fieldsets)\n self.assertIsInstance(fieldsets, list)\n self.assertTrue(all(each_are_tuples))\n self.assertTrue(all(correct_fieldset_labels))\n self.assertTrue(all(opts_are_dictionaries))\n self.assertEqual(len(unaccepted_keys), 0)\n self.assertFalse(unaccepted_keys)\n self.assertTrue(all(has_required))\n\n self.form.fieldsets = original_fieldsets",
"def test_no_empty_sets_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n ('Non_Fields', {\n 'position': 2,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 2)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def get_fieldsets(self, request, obj=None):\n if obj:\n return (('Corporate Burn Attribute Summary', {\n \"fields\": ('name', 'description', ('financial_year', 'planned_season'),\n ('last_year', 'last_season',\n 'last_year_unknown', 'last_season_unknown'),\n 'region', 'district', 'location',\n 'forest_blocks',\n ('priority', 'rationale'),\n ('contentious', 'contentious_rationale'),\n 'aircraft_burn',\n # TODO: PBS-1551 # 'allocation',\n 'remote_sensing_priority', 'purposes',\n ('area', 'perimeter', 'treatment_percentage'),\n ('non_calm_tenure','non_calm_tenure_approved','non_calm_tenure_included','non_calm_tenure_value','non_calm_tenure_complete','non_calm_tenure_risks')\n )\n }), ('Other Attributes', {\n \"fields\": ('tenures', 'fuel_types', 'shires',\n 'bushfire_act_zone', 'prohibited_period',\n 'forecast_areas', 'prescribing_officer',\n 'short_code')\n }))\n else:\n return super(PrescriptionAdmin, self).get_fieldsets(request, obj)",
"def grouped_formset_factory(leafpack=None, taxon_forms=None):\n groupedform_list = []\n groupRS= LeafPackSensitivityGroup.objects.all()\n\n for gr in groupRS:\n\n groupRS = Macroinvertebrate.objects.filter(displayflag= True, sens_group=gr).order_by('display_order')\n bug_forms=[]\n for taxon in groupRS:\n if leafpack is not None:\n try:\n lpg = LeafPackBug.objects.get(bug=taxon.id, leaf_pack=leafpack.id)\n except ObjectDoesNotExist:\n lpg = LeafPackBug(bug=taxon, leaf_pack=leafpack)\n lpg.save()\n else:\n lpg = LeafPackBug(bug=taxon)\n \n bug_form = LeafPackBugForm(instance=lpg)\n bug_forms.append(bug_form)\n \n group ={}\n group['name']= 'Group {0}: {1}'.format(str(gr.id), gr.name)\n group['list']= bug_forms\n groupedform_list.append(group)\n\n # If taxon_forms is not None, plug bug_count values into new formset\n if taxon_forms is not None:\n\n def get_taxon_count(taxon_):\n for tf in taxon_forms:\n if tf.instance.bug == taxon_:\n return tf.instance.bug_count\n return 0\n\n for forms_ in taxon_forms:\n forms_[0].initial['bug_count'] = get_taxon_count(forms_[0].instance.bug)\n\n for form in forms_[1]:\n form.initial['bug_count'] = get_taxon_count(form.instance.bug)\n\n return groupedform_list",
"def get_fieldsets(self, request, obj=None):\n return (\n ('Name', {\n 'fields': (\n ('first_name', 'last_name'),)\n }),\n ('IPI', {\n 'fields': (\n ('ipi_name', 'ipi_base'),),\n }),\n ('Societies', {\n 'fields': (\n self.get_society_list(),),\n }),\n ('General agreement', {\n 'fields': (\n ('generally_controlled',\n ('saan', 'publisher_fee'))\n ),\n }),\n )",
"def save_formset( self, request, form, formset, change ):\n formset.save()",
"def get_fieldsets(self, request, obj=None):\n if obj:\n return self._change_fieldsets\n return self._add_fieldsets",
"def test_make_fieldsets_uses_handle_modifiers(self):\n original_called_handle_modifiers = self.form.called_handle_modifiers = False\n full_fieldsets = self.form.make_fieldsets()\n\n self.assertFalse(original_called_handle_modifiers)\n self.assertIsInstance(full_fieldsets, (list, tuple))\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n self.assertTrue(self.form.called_handle_modifiers)\n\n self.form.called_handle_modifiers = original_called_handle_modifiers",
"def save_all(self, commit=True):\n\n # Save without committing (so self.saved_forms is populated)\n # - We need self.saved_forms so we can go back and access\n # the nested formsets\n objects = self.save(commit=False)\n\n # Save each instance if commit=True\n if commit:\n for o in objects:\n o.save()\n\n # save many to many fields if needed\n if not commit:\n self.save_m2m()\n \n # save the nested formsets\n for form in set(self.initial_forms + self.saved_forms):\n if self.should_delete(form): continue\n\n for nested in form.nested:\n nested.save(commit=commit)",
"def change_form_fieldsets(admin_form):\n form = admin_form.form\n readonly_fields = admin_form.readonly_fields\n model_admin = admin_form.model_admin\n\n for name, options in admin_form.fieldsets:\n yield ChangeFormFieldset(form=form,\n name=name,\n readonly_fields=readonly_fields,\n model_admin=model_admin,\n **options)",
"def test_no_empty_rows_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_a_field',\n ('last_name', 'another_field', ),\n ('first_name', 'non-field_name', ),\n 'generic_field',\n 'last',\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: remaining_fields.pop(name) for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 3)\n self.assertEqual(len(fieldsets[1][1]['rows']), 4)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def create_sets(self,FD_SET=['FinalD'],VA_SET=['VA']):\n \n self.m.S = Set(initialize=self.sectors, doc='sectors')\n self.m.P = Set(initialize=self.products, doc='sectors')\n self.m.row = Set(initialize=self.products, doc='products')\n self.m.col = Set(initialize=self.sectors+['FinalD'], doc='sectors and final demand')\n \n self.m.rROW = Set(initialize=self.countries,ordered=True, doc='regions including export')\n self.m.R = Set(initialize=self.countries,ordered=True, doc='regions')\n\n self.m.fdemand = Set(initialize=FD_SET, doc='Final Demand')\n\n self.m.VA = Set(initialize=VA_SET, doc='value added')",
"def process_show_formset(self, request, step, formset):\n pass",
"def formset_factory(leafpack=None, taxon_forms=None): # type: (LeafPack, [LeafPackBugForm]) -> list\n form_list = []\n\n queryset = Macroinvertebrate.objects.filter(family_of=None).order_by('sort_priority')\n\n for taxon in queryset:\n if leafpack is not None:\n try:\n lpg = LeafPackBug.objects.get(bug=taxon.id, leaf_pack=leafpack.id)\n except ObjectDoesNotExist:\n lpg = LeafPackBug(bug=taxon, leaf_pack=leafpack)\n lpg.save()\n else:\n lpg = LeafPackBug(bug=taxon)\n\n order_bug_form = LeafPackBugForm(instance=lpg)\n\n families = taxon.families.all().order_by('common_name').order_by('sort_priority')\n family_bug_forms = list()\n if len(families) > 0:\n\n if leafpack is not None:\n\n child_taxons = []\n for child_bug in families:\n\n try:\n child_lpg = LeafPackBug.objects.get(bug=child_bug, leaf_pack=leafpack)\n except ObjectDoesNotExist:\n child_lpg = LeafPackBug(bug=child_bug, leaf_pack=leafpack)\n child_lpg.save()\n\n child_taxons.append(child_lpg)\n\n family_bug_forms = [LeafPackBugForm(instance=taxon) for taxon in child_taxons]\n else:\n family_bug_forms = [LeafPackBugForm(instance=LeafPackBug(bug=bug)) for bug in families]\n\n form_list.append((order_bug_form, family_bug_forms))\n\n # If taxon_forms is not None, plug bug_count values into new formset\n if taxon_forms is not None:\n\n def get_taxon_count(taxon_):\n for tf in taxon_forms:\n if tf.instance.bug == taxon_:\n return tf.instance.bug_count\n return 0\n\n for forms_ in taxon_forms:\n forms_[0].initial['bug_count'] = get_taxon_count(forms_[0].instance.bug)\n\n for form in forms_[1]:\n form.initial['bug_count'] = get_taxon_count(form.instance.bug)\n\n return form_list",
"def _generate_formset_class(\n request, model, modelfield, baseformclass, formsetfieldelement\n):\n\n formfieldelements = _get_form_fields_from_layout(\n _layout.BaseElement(*formsetfieldelement)\n ) # make sure the _layout.form.FormSetField does not be considered recursively\n\n formclass = breadmodelform_factory(\n request=request,\n model=modelfield.related_model,\n layout=formfieldelements,\n instance=None,\n baseformclass=baseformclass,\n )\n\n base_formset_kwargs = {\n \"fields\": [\n formfieldelement.fieldname for formfieldelement in formfieldelements\n ],\n \"form\": formclass,\n \"extra\": 0,\n \"can_delete\": True,\n }\n base_formset_kwargs.update(formsetfieldelement.formsetfactory_kwargs)\n if isinstance(modelfield, GenericRelation):\n return generic_inlineformset_factory(\n modelfield.related_model,\n ct_field=modelfield.content_type_field_name,\n fk_field=modelfield.object_id_field_name,\n formset=InlineFormSetWithLimits,\n formfield_callback=lambda field: _formfield_callback_with_request(\n field, request, modelfield.related_model\n ),\n **base_formset_kwargs,\n )\n else:\n return forms.models.inlineformset_factory(\n model,\n modelfield.related_model,\n formset=InlineFormSetWithLimits,\n formfield_callback=lambda field: _formfield_callback_with_request(\n field, request, model\n ),\n **base_formset_kwargs,\n )",
"def show_fieldsetform(form):\n return {'form': form, 'required_fields': True}",
"def test_missing_initial_fieldsets(self):\n original_initial_fieldsets = self.form.fieldsets\n print(\"========================= TEST UNABLE TO DELETE THE PROPERTY FOR TESTING ========================\")\n print(original_initial_fieldsets)\n print(\"--------------------------------------\")\n delattr(self.form, 'fieldsets')\n response_fieldsets = self.form.make_fieldsets()\n print(response_fieldsets)\n\n setattr(self.form, 'fieldsets', original_initial_fieldsets)",
"def make_fields(self):\n for name, prop in self.edit:\n instance_value = self.model.get(name)\n post_value = self.data[name] if (self.data and self.data.has_key(name)) else instance_value\n form_field_class = self.get_field_type(prop)\n form_field = form_field_class(model=self.model, property=prop, name=name, instance_value=instance_value, post_value=post_value)\n self.add(form_field)",
"def addProductFields(form, forCreation=False, restWriter=None, hasOptions=False):\n form.addField('code', formal.String(required=True, strip=True))\n form.addField('title', formal.String(required=True, strip=True))\n\n images = formal.Group('images')\n form.add( images )\n images.add( formal.Field('mainImage', formal.File(required=forCreation), \n widgetFactory=formal.widgetFactory( formal.FileUploadWidget,\n convertibleFactory=contenttypeutil.KeyToFileConverter,\n originalKeyIsURL=True),description='click to change') )\n images.add( formal.Field('ndgrad', formal.File(), \n widgetFactory=formal.widgetFactory( formal.FileUploadWidget,\n convertibleFactory=contenttypeutil.KeyToFileConverter,\n originalKeyIsURL=True),description='click to change') )\n\n\n availability = formal.Group('availability')\n form.add( availability )\n\n availability.add( formal.Field('show', formal.Boolean()))\n availability.add( formal.Field('available', formal.Boolean()) )\n availability.add( formal.Field('availabilityDescription', formal.String()) )\n\n metadata = formal.Group('metadata')\n form.add( metadata )\n\n metadata.add( formal.Field('date', formal.Date(), formal.widgetFactory(formal.DatePartsInput, dayFirst=True)))\n metadata.add( formal.Field('location', formal.String()) )\n \n lensOptions = [\n \"80mm Schneider Super Symmar XL f/4.5\",\n \"110mm Schneider Super Symmar XL f/5.6\",\n \"150mm Rodenstock Sironar S f/5.6\",\n \"240mm Fujinon A f/9\",\n \"360mm Nikkor T*ED f/8\",\n \"360mm Nikkor T*ED f/11\",\n ]\n metadata.add( formal.Field('lens', formal.String(),formal.widgetFactory(formal.SelectOtherChoice, options=lensOptions) ) )\n \n # this is a redundant field... need to remove if possible\n metadata.add( formal.Field('speedaperture', formal.String()) )\n \n speedOptions = ['1/500', '1/250','1/125','1/60','1/30','1/15','1/8','1/4','1/2','1s','2s','4s','8s','15s','30s','1m','2m']\n metadata.add( formal.Field('speed', formal.String(),formal.widgetFactory(formal.SelectOtherChoice, options=speedOptions),description='If you enter a text value please use the same format as the existing values e.g. 6s, 1/3, 2m' ) )\n \n \n apertureOptions = ['f/5.6','f/6.3','f/8','f/8⅓','f/8½','f/8⅔','f/16','f/16⅓','f/16½','f/16⅔','f/22','f/22⅓','f/22½','f/22⅔','f/32','f/32⅓','f/32½','f/32⅔','f/45','f/45⅓','f/45½','f/45⅔']\n metadata.add( formal.Field('aperture', formal.String(),formal.widgetFactory(formal.SelectOtherChoice, options=apertureOptions) ) ) \n metadata.add( formal.Field('tiltswing', formal.String()) )\n metadata.add( formal.Field('fronttilt', formal.Integer()) )\n metadata.add( formal.Field('reartilt', formal.Integer()) )\n metadata.add( formal.Field('risefall', formal.String()) )\n ndfilters = ['0.3S','0.45S','0.6S','0.75S','0.9S','0.3H','0.45H','0.6H','0.75H','0.9H']\n metadata.add( formal.Field('ndfilters', formal.String(),formal.widgetFactory(formal.SelectOtherChoice, options=ndfilters)) )\n otherfilters=['81A','81B','81C','Polariser']\n metadata.add( formal.Field('otherfilters', formal.String(), formal.widgetFactory(formal.SelectOtherChoice, options=otherfilters)) )\n\n \n \n \n data_strings = [\n (0, '-'),\n (1, '*'),\n (2, '**'),\n (3, '***'),\n (4, '****'),\n (5, '*****'),\n ] \n \n metadata.add( formal.Field('rating', formal.Integer(), formal.widgetFactory(formal.SelectChoice, options=data_strings)) )\n\n\n description = formal.Group('description')\n form.add( description )\n parsers = [('markdown','MarkDown'),('xhtml','XHTML'),('plain','Plain Text')]\n description.add( formal.Field('summary', formal.RichTextType(required=True),\n widgetFactory=formal.widgetFactory(richtextarea.RichTextArea, parsers=parsers),\n cssClass=' '.join(['imagepicker','preview','itemselector']) ) )\n description.add( formal.Field('description', formal.RichTextType(required=True),\n widgetFactory=formal.widgetFactory(richtextarea.RichTextArea, parsers=parsers),\n cssClass=' '.join(['imagepicker','preview','itemselector']) ) )\n description.add( formal.Field('categories', formal.Sequence(formal.String()), \n widgetFactory=categorieswidget.FormalCheckboxTreeMultichoice ) )\n\n\n\n if not hasOptions:\n pricing = formal.Group('pricing')\n form.add( pricing )\n pricing.add( formal.Field('price', formal.Decimal(required=True)) )\n\n\n seo = formal.Group('seo')\n form.add( seo )\n seo.add( formal.Field('titleTag', formal.String()) )\n seo.add( formal.Field('metaDescription', formal.String()) )\n seo.add( formal.Field('metaKeywords', formal.String()) )",
"def get_model_as_formset(self, client_id):\n # Basement\n formset = {\n 'form-TOTAL_FORMS': str(len(self.storage)),\n 'form-INITIAL_FORMS': u'0',\n }\n # Fill the formset\n for record_index, record in enumerate(self.storage):\n prefix = 'form-%i' % record_index\n row = {'%s-client' % prefix: client_id,}\n for model_index, model_row in enumerate(MODEL_MAP_RAW):\n name, delegate, title, action, static = model_row\n key = '%s-%s' % (prefix, name)\n value = record[model_index]\n value_t = type(value)\n\n if value is None: # send None as empty string\n value = str()\n elif value_t is datetime:\n value = dt2str(value)\n elif value_t is date:\n value = date2str(value)\n elif value_t in (int, float):\n value = str(value)\n elif value_t is dict:\n if 'id' in value:\n value = value['id']\n else:\n value = 'no id found'\n\n row.update( {key: value} )\n formset.update( row )\n return formset",
"def get_fieldsets(self, request, obj=None):\n if request.user.user_type == User.ADMIN_CEA:\n return self.cea_fieldsets\n elif request.user.user_type == User.ADMIN_CRC:\n return self.crc_fieldsets\n elif request.user.user_type == User.EXPRESS_USER:\n return self.exp_fieldsets\n return self.fieldsets",
"def create_sets(self,FD_SET=[],VA_SET=[]):\n \n self.m.S = Set(initialize=self.sectors, doc='sectors')\n\n if self.EORA is True:\n self.m.rROW = Set(initialize=self.countries+['ROW'],ordered=True, doc='regions including export')\n self.m.R = Set(initialize=self.countries+['ROW'],ordered=True, doc='regions')\n else:\n self.m.rROW = Set(initialize=self.countries,ordered=True, doc='regions including export')\n self.m.R = Set(initialize=self.countries,ordered=True, doc='regions')\n\n if self.EORA is True:\n self.m.fdemand = Set(initialize=['P3h', 'P3n','P3g', 'P51','P52','P53'], doc='Final Demand')\n else:\n self.m.fdemand = Set(initialize=self.fd_cat, doc='Final Demand')\n\n if self.EORA is True:\n self.m.VA = Set(initialize=['VA'], doc='value added')\n else:\n self.m.VA = Set(initialize=VA_SET, doc='value added')",
"def test_no_duplicate_fields_in_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n ('Confused', {\n 'position': 3,\n 'fields': [\n ('first_name', 'generic_field', ),\n 'first',\n 'last',\n ],\n }), )\n duplicates = set(('first_name', 'first', 'last', ))\n expected = []\n for names in test_fieldsets[2][1]['fields']:\n if isinstance(names, str):\n names = (names, )\n names = [name for name in names if name not in duplicates]\n if names:\n expected.append({name: self.form.fields[name] for name in names})\n self.form.fieldsets = deepcopy(test_fieldsets)\n self.form.make_fieldsets()\n computed_fieldsets = self.form._fieldsets\n opts = computed_fieldsets[2][1]\n actual = opts['rows']\n\n self.assertEqual(1, len(actual), \"Rows of already used fields were added. \")\n self.assertEqual(1, len(actual[0]), \"Columns of already used fields were added. \")\n self.assertEqual(expected, actual)\n for lbl, opts in computed_fieldsets[:2]:\n row_names = flatten([list(row.keys()) for row in opts['rows']])\n self.assertEqual(opts['field_names'], row_names, \"Field missing from its expected first fieldset. \")\n\n self.form.fieldsets = original_fieldsets",
"def get_fieldsets(self, default):\n default = default + ['-']\n\n last = None\n fields = []\n for perm in self.__permissions_to_manage():\n if last != perm.content_type:\n if fields:\n default = default + ['h3:'+last.model_class()._meta.verbose_name_plural, segment(chunks(fields, 4))]\n last = perm.content_type\n fields = []\n\n fields = fields + [perm.codename]\n\n default = default + ['h3:'+last.model_class()._meta.verbose_name_plural, segment(chunks(fields, 4))]\n return default",
"def save_formset(self, request, form, formset, change):\n formset.save()\n if len(formset.cleaned_data) != 0:\n data = formset.cleaned_data\n list_nutri_food = {}\n id_food = data[0]['food_recipe'].id\n for obj in data:\n if bool(obj):\n if obj.get('material',False):\n material = obj['material']\n else:\n material = obj['id'].material\n value = obj['value']\n delete = obj['DELETE']\n if not delete:\n for nutri in material.nutritions.all():\n if nutri.pk in list_nutri_food.keys():\n list_nutri_food[nutri.pk] += nutri.materialnutrition_set.get(material=material).value*value\n else:\n list_nutri_food[nutri.pk] = nutri.materialnutrition_set.get(material=material).value * value\n if bool(list_nutri_food):\n for i in list_nutri_food:\n if not change:\n a = FoodNutrition(nutrition_id=i,foodrecipe_id=id_food,value=list_nutri_food.get(i))\n a.save()\n else:\n try:\n b = FoodNutrition.objects.get(nutrition_id=i,foodrecipe_id=id_food)\n b.value = list_nutri_food.get(i)\n b.save()\n except:\n a = FoodNutrition(nutrition_id=i, foodrecipe_id=id_food, value=list_nutri_food.get(i))\n a.save()\n elif change:\n FoodNutrition.objects.filter(foodrecipe_id=id_food).delete()",
"def test_form_main_rows_all_fieldsets(self):\n # form.form_main_rows(self, html_args, fieldsets, form_col_count)\n # html_args = (row_tag, col_head_tag, col_tag, single_col_tag, as_type, all_fieldsets)\n pass"
] | [
"0.6202503",
"0.5993465",
"0.59412736",
"0.58321846",
"0.5802802",
"0.57773435",
"0.5747591",
"0.5710147",
"0.5673536",
"0.5596267",
"0.5425132",
"0.5367448",
"0.5340725",
"0.5300301",
"0.5291684",
"0.52537316",
"0.5224285",
"0.5199588",
"0.51841486",
"0.5142671",
"0.5112501",
"0.5060178",
"0.5053298",
"0.50356156",
"0.5006555",
"0.49805012",
"0.49595138",
"0.4928235",
"0.49054086",
"0.48396304"
] | 0.7419774 | 0 |
If initial fieldsets is not defined, warning is raised. | def test_missing_initial_fieldsets(self):
original_initial_fieldsets = self.form.fieldsets
print("========================= TEST UNABLE TO DELETE THE PROPERTY FOR TESTING ========================")
print(original_initial_fieldsets)
print("--------------------------------------")
delattr(self.form, 'fieldsets')
response_fieldsets = self.form.make_fieldsets()
print(response_fieldsets)
setattr(self.form, 'fieldsets', original_initial_fieldsets) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_raises_if_initial_fieldsets_error(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }), )\n position_missing_fieldsets = deepcopy(test_fieldsets)\n del position_missing_fieldsets[1][1]['position']\n fields_missing_fieldsets = deepcopy(test_fieldsets)\n del fields_missing_fieldsets[0][1]['fields']\n message = \"There must be 'fields' and 'position' in each fieldset. \"\n self.form.fieldsets = position_missing_fieldsets\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets()\n self.form.fieldsets = fields_missing_fieldsets\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets()\n\n self.form.fieldsets = original_fieldsets",
"def test_no_empty_sets_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n ('Non_Fields', {\n 'position': 2,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 2)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_make_fieldsets_uses_prep_fields(self):\n original_called_prep_fields = self.form.called_prep_fields = False\n full_fieldsets = self.form.make_fieldsets()\n\n self.assertFalse(original_called_prep_fields)\n self.assertIsInstance(full_fieldsets, (list, tuple))\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n self.assertTrue(self.form.called_prep_fields)\n\n self.form.called_prep_fields = original_called_prep_fields",
"def _initFields(self):\n pass",
"def test_computed_fieldsets_structure(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n self.form.make_fieldsets()\n fieldsets = self.form._fieldsets\n each_are_tuples = (isinstance(ea, tuple) for ea in fieldsets)\n correct_fieldset_labels = (isinstance(label, (str, type(None))) for label, opts in fieldsets)\n opts_are_dictionaries = (isinstance(opts, dict) for label, opts in fieldsets)\n required_keys = {'position', 'fields', 'field_names', 'rows', 'column_count', }\n optional_keys = {'classes', 'modifiers', 'row_data', }\n allowed_keys = required_keys | optional_keys\n opt_keys = set(flatten([list(opts.keys()) for lbl, opts, in fieldsets]))\n unaccepted_keys = [key for key in opt_keys if key not in allowed_keys]\n has_required = (all(key in opts for key in required_keys) for lbl, opts in fieldsets)\n self.assertIsInstance(fieldsets, list)\n self.assertTrue(all(each_are_tuples))\n self.assertTrue(all(correct_fieldset_labels))\n self.assertTrue(all(opts_are_dictionaries))\n self.assertEqual(len(unaccepted_keys), 0)\n self.assertFalse(unaccepted_keys)\n self.assertTrue(all(has_required))\n\n self.form.fieldsets = original_fieldsets",
"def test_view_initializes_formset_with_audit_initial_data(self):\n audit = AuditFactory(num_doctypes=3) # fixture\n\n formset = DocumentFormSet(audit_pk=audit.pk)\n\n expected_labels = {dt.name for dt in audit.required_doctypes.all()}\n forms_labels = {form.fields['file'].label for form in formset}\n self.assertSetEqual(expected_labels, forms_labels)\n\n expected_doctype_pks = {dt.pk for dt in audit.required_doctypes.all()}\n forms_pks = {form.initial['doctype'] for form in formset}\n self.assertSetEqual(expected_doctype_pks, forms_pks)",
"def test_no_empty_rows_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_a_field',\n ('last_name', 'another_field', ),\n ('first_name', 'non-field_name', ),\n 'generic_field',\n 'last',\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: remaining_fields.pop(name) for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 3)\n self.assertEqual(len(fieldsets[1][1]['rows']), 4)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_raises_if_missed_fields(self):\n name = 'second'\n self.form.called_handle_modifiers = False\n remove = {'remove_field': name}\n self.form.handle_modifiers({}, [], **remove)\n self.assertNotIn(name, self.form.fields)\n self.assertIn(name, self.form.hold_field)\n message = \"Some unassigned fields, perhaps some added during handle_modifiers. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets(add_field=name)\n self.form.called_handle_modifiers = False",
"def _validate_default_fields() -> None:\n default_fields = [\n field\n for field in fields\n if field[\"name\"] in DEFAULT_PREDICTIONS_TABLE_FIELDS\n ]\n if len(DEFAULT_PREDICTIONS_TABLE_FIELDS) != len(default_fields):\n raise NotFilledDefaultFields",
"def test_raises_on_constructor_fields_error(self):\n self.form.constructor_fields = None\n message = \"Expected a list of field name strings for constructor_fields. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.confirm_required_fields()",
"def test_overall_make_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_make_fieldsets_uses_handle_modifiers(self):\n original_called_handle_modifiers = self.form.called_handle_modifiers = False\n full_fieldsets = self.form.make_fieldsets()\n\n self.assertFalse(original_called_handle_modifiers)\n self.assertIsInstance(full_fieldsets, (list, tuple))\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n self.assertTrue(self.form.called_handle_modifiers)\n\n self.form.called_handle_modifiers = original_called_handle_modifiers",
"def field_initialise_tags(model, field, report=None):\n if not field.tag_options.initial:\n return False\n \n if report:\n report.write(\"Loading initial tags for %s.%s.%s\\n\" % (\n model._meta.app_label,\n model.__name__,\n field.name,\n ))\n \n descriptor = getattr(model, field.name)\n descriptor.load_initial()\n return True",
"def test_raises_on_missing_needed_fields(self):\n test_name = \"impossible_creature_not_present\"\n self.form.constructor_fields = [*self.form.constructor_fields, test_name]\n message = \"The fields for email, username, and constructor must be set in fields. \"\n self.assertNotIn(test_name, self.form.base_fields)\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.confirm_required_fields()",
"def initial_formset_data(self, request, step, formset):\n return None",
"def populate_initial_valid_metadata(self):\n pass",
"def test_no_duplicate_fields_in_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n ('Confused', {\n 'position': 3,\n 'fields': [\n ('first_name', 'generic_field', ),\n 'first',\n 'last',\n ],\n }), )\n duplicates = set(('first_name', 'first', 'last', ))\n expected = []\n for names in test_fieldsets[2][1]['fields']:\n if isinstance(names, str):\n names = (names, )\n names = [name for name in names if name not in duplicates]\n if names:\n expected.append({name: self.form.fields[name] for name in names})\n self.form.fieldsets = deepcopy(test_fieldsets)\n self.form.make_fieldsets()\n computed_fieldsets = self.form._fieldsets\n opts = computed_fieldsets[2][1]\n actual = opts['rows']\n\n self.assertEqual(1, len(actual), \"Rows of already used fields were added. \")\n self.assertEqual(1, len(actual[0]), \"Columns of already used fields were added. \")\n self.assertEqual(expected, actual)\n for lbl, opts in computed_fieldsets[:2]:\n row_names = flatten([list(row.keys()) for row in opts['rows']])\n self.assertEqual(opts['field_names'], row_names, \"Field missing from its expected first fieldset. \")\n\n self.form.fieldsets = original_fieldsets",
"def test_get_flat_fields_setting(self):\n # FormOverrideMixIn.get_flat_fields_setting\n pass",
"def test_make_fieldsets_saves_results(self):\n original_initial_fieldsets = getattr(self.form, 'fieldsets', None)\n initial_fieldsets = deepcopy(original_initial_fieldsets)\n original_computed_fieldsets = getattr(self.form, '_fieldsets', None)\n original_summary = getattr(self.form, '_fs_summary', None)\n self.assertIsNotNone(original_initial_fieldsets)\n self.assertIsNone(original_computed_fieldsets)\n self.assertIsNone(original_summary)\n response_fieldsets = self.form.make_fieldsets()\n label, summary = response_fieldsets.pop()\n self.assertIsNotNone(self.form._fieldsets)\n self.assertIsNotNone(self.form._fs_summary)\n self.assertEqual('summary', label)\n self.assertEqual(summary, self.form._fs_summary)\n self.assertEqual(response_fieldsets, self.form._fieldsets)\n self.assertEqual(initial_fieldsets, self.form.fieldsets)\n\n self.form.fieldsets = original_initial_fieldsets\n self.form._fieldsets = original_computed_fieldsets\n self.form._fs_summary = original_summary\n if original_computed_fieldsets is None:\n del self.form._fieldsets\n if original_summary is None:\n del self.form._fs_summary",
"def test_raise_on_corrupt_computed_fields(self):\n initial = self.form.computed_fields\n self.form.computed_fields = 'This is a broken value'\n with self.assertRaises(ImproperlyConfigured):\n self.form.get_computed_field_names([], self.form.fields)\n self.form.computed_fields = None\n with self.assertRaises(ImproperlyConfigured):\n self.form.get_computed_field_names([], self.form.fields)\n self.form.computed_fields = initial",
"def _check_required_fields(self):\n assert self.volume_title\n super(MultiMonoComposer, self)._check_required_fields()",
"def test_make_fieldsets_outcome_order(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'position': None,\n 'fields': [\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n fieldsets[0], fieldsets[1] = fieldsets[1], fieldsets[0]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_raise_attach_broken(self):\n orig_fields = deepcopy(self.form.fields)\n orig_base_fields = deepcopy(self.form.base_fields)\n self.form.fields = None\n self.form.base_fields = None\n with self.assertRaises(ImproperlyConfigured):\n self.form.attach_critical_validators()\n self.form.fields = orig_fields\n self.form.base_fields = orig_base_fields",
"def set_initial_values(self):\n\n pass",
"def presets (self):\n assert False, \"To be implemented by child\"",
"def _create_and_initialise_fields(self):\n for team in self.category.breaking_teams.all():\n self.fields[self._fieldname_remark(team)] = OptionalChoiceField(choices=BreakingTeam.REMARK_CHOICES, required=False)\n try:\n self.initial[self._fieldname_remark(team)] = self._bt(team).remark\n except KeyError:\n self.initial[self._fieldname_remark(team)] = None",
"def get_fieldsets(self, request, obj=None):\n if not obj:\n return self.fieldsets_without_readonly\n return super().get_fieldsets(request, obj=obj)",
"def test_no_markup_type_field_if_set(self):\r\n self.assertTrue('markdown_field_markup_type' not in\r\n ArticleForm().fields.keys())",
"def _check_required_fields(self):\n assert self.title\n assert self.format",
"def test_set_non_dictionary_based_field(self):\n self.assertRaises(TypeError, self._p.set_fields, '')"
] | [
"0.77882177",
"0.6555793",
"0.6518415",
"0.63593554",
"0.6162676",
"0.6096139",
"0.608212",
"0.59703225",
"0.59213835",
"0.5915669",
"0.5915668",
"0.5871524",
"0.58497983",
"0.578148",
"0.5659497",
"0.56561965",
"0.56023",
"0.55925554",
"0.5584792",
"0.5581815",
"0.55792415",
"0.5562602",
"0.5554003",
"0.5541139",
"0.5533134",
"0.5517409",
"0.5495401",
"0.5457106",
"0.5440904",
"0.5433015"
] | 0.73718363 | 1 |
Any empty rows defined in the initial fieldset settings are removed in the computed fieldset settings. | def test_no_empty_rows_in_computed_fieldsets(self):
original_fieldsets = self.form.fieldsets
self.form.fieldsets = (
('Your Name', {
'position': 1,
'fields': [('first_name', 'last_name', )],
}),
(None, {
'classes': ('counting', ),
'position': 2,
'fields': [
('first', 'second', ),
'not_a_field',
('last_name', 'another_field', ),
('first_name', 'non-field_name', ),
'generic_field',
'last',
],
}), )
fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets]
remaining_fields = self.form.fields.copy()
assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])
unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]
remaining_fields.pop('hide_field')
opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}
fieldsets.append((None, opts))
for fieldset_label, opts in fieldsets:
opts['field_names'] = flatten(opts['fields'])
rows, column_count = [], 0
for names in opts['fields']:
if isinstance(names, str):
names = [names]
columns = {name: remaining_fields.pop(name) for name in names if name in remaining_fields}
# TODO: Remove hidden or otherwise excluded fields.
column_count = max(column_count, len(columns))
if columns:
rows.append(columns)
opts['rows'] = rows
opts['column_count'] = column_count
self.form.make_fieldsets()
actual_fieldsets = self.form._fieldsets
self.assertEqual(len(fieldsets), 3)
self.assertEqual(len(fieldsets[1][1]['rows']), 4)
self.assertEqual(len(fieldsets), len(actual_fieldsets))
count = 0
for expect, got in zip(fieldsets, actual_fieldsets):
labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))
expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])
actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])
row_names = str(expect_row_names) + '\n' + str(actual_row_names)
message = f"Fieldset # {count} named {labels} expected then got: \n{row_names}"
self.assertEqual(expect, got, message)
count += 1
self.assertEqual(fieldsets, actual_fieldsets)
self.form.fieldsets = original_fieldsets | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clear(self):\n\t\tself.beginRemoveRows(QModelIndex(), 0, len(self.fields))\n\t\tself.fields = []\n\t\tself.endRemoveRows()",
"def test_no_empty_sets_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n ('Non_Fields', {\n 'position': 2,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 2)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def clear_rows(self):\n ...",
"def clearRows(self):\n self.data['rows'] = []",
"def reset(self):\n self.rows = deepcopy(self.empty_rows)\n self._update_max_row_info()",
"def clearLayers(self):\n for _ in range(self.jobRow.rowCount()):\n self.jobRow.removeRow(0)",
"def reset(self):\n self._last_item = None\n self._connected_items = []\n\n self._title_label.deleteLater()\n\n for item in self._items:\n item.deleteLater()\n\n for i in range(self._column_span):\n self._grid.setColumnStretch(self._column_id + i, 0)\n\n self._items = []\n self._row_index = 0",
"def clear(self):\n self.gridLayout.setRowStretch(self.gridLayout.rowCount()-1, 0)\n for i in reversed(range(self.gridLayout.count())):\n item = self.gridLayout.itemAt(i)\n axis = item.widget()\n if axis:\n self.gridLayout.removeWidget(axis)\n axis.hide()\n axis.deleteLater()\n else:\n self.gridLayout.removeItem(item)\n \n self.axisWidgets = []\n self.axesNames = []",
"def test_missing_initial_fieldsets(self):\n original_initial_fieldsets = self.form.fieldsets\n print(\"========================= TEST UNABLE TO DELETE THE PROPERTY FOR TESTING ========================\")\n print(original_initial_fieldsets)\n print(\"--------------------------------------\")\n delattr(self.form, 'fieldsets')\n response_fieldsets = self.form.make_fieldsets()\n print(response_fieldsets)\n\n setattr(self.form, 'fieldsets', original_initial_fieldsets)",
"def clear_previous_selections(self):\n self.headers = []\n self.filename = ''\n self.x_axis = ''\n self.y_axis = ''\n self.delim = ''\n self.non_numeric_x_axis = False\n self.count_desired = False",
"def _clean(self):\n map(self.__delitem__, self.keys())\n self._original = []\n self._columns = {}\n self._modified, self._deleted = {}, {}",
"def clear_all_lines(self):\n\n for line in self.full_ed_lines:\n line.setText(\"\")\n self.msg2Statusbar.emit('Произведена полная отчистка полей')",
"def clear(self):\n for i in range(5): #Year, Month and Day\n self.entries[i].delete(0,END)\n for i in range(3, 5): #Week and Extra\n Input.clear_display(self, self.entries[i])\n self.entries[i].configure(state='readonly')",
"def test_form_main_rows_html_fieldset_has_container(self):\n # form.form_main_rows(self, html_args, fieldsets, form_col_count)\n # html_args = (row_tag, col_head_tag, col_tag, single_col_tag, as_type, all_fieldsets)\n pass",
"def remove_all_fields(self):\n self.fields = None",
"def cleanTable(self):\n self.currentGroup = None",
"def clear_fields(self):\n\n if not self.is_root:\n return\n self.field_data.clear()",
"def CleanUp(self):\n blankColumnPattern = re.compile('^-*$')\n blankColumns = []\n for columnIndex in range(self.alignment.get_alignment_length() - 1):\n columnValues = self.alignment[:,columnIndex]\n match = blankColumnPattern.search(columnValues)\n if (match):\n blankColumns.append(str(columnIndex))\n for column in blankColumns[::-1]:\n self.DeleteRange(',' + str(column), True)\n self.Show(self.displayedColumn)\n self.BackupAlignment()",
"def reset_inputs(self):\n for widget in self.frame.winfo_children():\n if isinstance(widget, tkinter.Entry):\n widget.delete(0, tkinter.END)\n widget.insert(0, \"\")\n elif isinstance(widget, tkinter.Checkbutton):\n widget.deselect()",
"def test_form_main_rows_all_fieldsets_has_container(self):\n # form.form_main_rows(self, html_args, fieldsets, form_col_count)\n # html_args = (row_tag, col_head_tag, col_tag, single_col_tag, as_type, all_fieldsets)\n pass",
"def clear(self):\n self.cb_attr.clear()\n self.group_listbox.clear()\n self.data = None\n self.__groups = None\n self.graph.reset()\n self.infoLabel.setText(\"No data on input.\")",
"def exclude_empty_feats(self):\n for dataset in self:\n dataset.dropna(axis=1, how=\"all\", inplace=True)",
"def reset(self):\n super().reset()\n whitelist = []\n for parent in self.cls.mro():\n whitelist.extend(getattr(parent, 'tab_whitelist', []))\n\n if getattr(parent, \"tab_component_names\", False):\n for cpt_name in parent.component_names:\n if getattr(parent, cpt_name).kind != Kind.omitted:\n whitelist.append(cpt_name)\n\n self._includes = set(whitelist)",
"def setNone(self):\n self.setValue([])",
"def reset(self):\n width = len(self.cell)\n height = len(self.cell[0])\n self.cell = [ [EMPTY for r in range(height)] for c in range(width) ]",
"def clearAll(self):\r\n for widgetName, lineWidget in self.lineEditWidgets.items():\r\n if widgetName == \"FECHA\" or widgetName == \"HORA\":\r\n pass\r\n else:\r\n lineWidget.setText(\"\")",
"def blank(self):\n pass",
"def clear(self):\n for key in self.__columns:\n self.__widths[key] = 0\n self.__data = []\n self.__selectedRow = -1\n self.__formatString = \"\"\n self._window.clear()\n self.drawBorder()",
"def resetSelectionArea(self):\n for legend in self._selectionAreas:\n self.plot.remove(legend, kind='item')\n self._selectionAreas = set()",
"def clear(self):\n self.filled = 0\n self.used = 0\n self.table = []\n # Initialize the table to a clean slate of entries.\n for i in range(self.size):\n self.table.append(Entry())"
] | [
"0.66703916",
"0.66108024",
"0.6571478",
"0.65662205",
"0.64384866",
"0.622195",
"0.6153714",
"0.61123395",
"0.6112054",
"0.6008037",
"0.5997267",
"0.5988325",
"0.59726787",
"0.59608305",
"0.59185666",
"0.59006476",
"0.58773136",
"0.5838165",
"0.5829497",
"0.58233345",
"0.58207583",
"0.5807765",
"0.57676184",
"0.57675654",
"0.5754794",
"0.57294333",
"0.5727393",
"0.572582",
"0.5722879",
"0.5720901"
] | 0.69864285 | 0 |
Any empty fieldset defined in initial fieldset settings are removed in the computed fieldset settings. | def test_no_empty_sets_in_computed_fieldsets(self):
original_fieldsets = self.form.fieldsets
self.form.fieldsets = (
('Your Name', {
'position': 1,
'fields': [('first_name', 'last_name', )],
}),
('Non_Fields', {
'position': 2,
'fields': [
'non-field_name',
'not_a_field'
],
}), )
fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']
remaining_fields = self.form.fields.copy()
assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])
unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]
remaining_fields.pop('hide_field')
opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}
fieldsets.append((None, opts))
for fieldset_label, opts in fieldsets:
opts['field_names'] = flatten(opts['fields'])
rows, column_count = [], 0
for names in opts['fields']:
if isinstance(names, str):
names = [names]
columns = {name: self.form.fields[name] for name in names if name in remaining_fields}
# TODO: Remove hidden or otherwise excluded fields.
column_count = max(column_count, len(columns))
if columns:
rows.append(columns)
opts['rows'] = rows
opts['column_count'] = column_count
self.form.make_fieldsets()
actual_fieldsets = self.form._fieldsets
self.assertEqual(len(fieldsets), 2)
self.assertEqual(len(fieldsets), len(actual_fieldsets))
count = 0
for expect, got in zip(fieldsets, actual_fieldsets):
labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))
expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])
actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])
row_names = str(expect_row_names) + '\n' + str(actual_row_names)
message = f"Fieldset # {count} named {labels} expected then got: \n{row_names}"
self.assertEqual(expect, got, message)
count += 1
self.assertEqual(fieldsets, actual_fieldsets)
self.form.fieldsets = original_fieldsets | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_missing_initial_fieldsets(self):\n original_initial_fieldsets = self.form.fieldsets\n print(\"========================= TEST UNABLE TO DELETE THE PROPERTY FOR TESTING ========================\")\n print(original_initial_fieldsets)\n print(\"--------------------------------------\")\n delattr(self.form, 'fieldsets')\n response_fieldsets = self.form.make_fieldsets()\n print(response_fieldsets)\n\n setattr(self.form, 'fieldsets', original_initial_fieldsets)",
"def test_no_empty_rows_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_a_field',\n ('last_name', 'another_field', ),\n ('first_name', 'non-field_name', ),\n 'generic_field',\n 'last',\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: remaining_fields.pop(name) for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 3)\n self.assertEqual(len(fieldsets[1][1]['rows']), 4)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_overall_make_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_computed_fieldsets_structure(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n self.form.make_fieldsets()\n fieldsets = self.form._fieldsets\n each_are_tuples = (isinstance(ea, tuple) for ea in fieldsets)\n correct_fieldset_labels = (isinstance(label, (str, type(None))) for label, opts in fieldsets)\n opts_are_dictionaries = (isinstance(opts, dict) for label, opts in fieldsets)\n required_keys = {'position', 'fields', 'field_names', 'rows', 'column_count', }\n optional_keys = {'classes', 'modifiers', 'row_data', }\n allowed_keys = required_keys | optional_keys\n opt_keys = set(flatten([list(opts.keys()) for lbl, opts, in fieldsets]))\n unaccepted_keys = [key for key in opt_keys if key not in allowed_keys]\n has_required = (all(key in opts for key in required_keys) for lbl, opts in fieldsets)\n self.assertIsInstance(fieldsets, list)\n self.assertTrue(all(each_are_tuples))\n self.assertTrue(all(correct_fieldset_labels))\n self.assertTrue(all(opts_are_dictionaries))\n self.assertEqual(len(unaccepted_keys), 0)\n self.assertFalse(unaccepted_keys)\n self.assertTrue(all(has_required))\n\n self.form.fieldsets = original_fieldsets",
"def remove_all_fields(self):\n self.fields = None",
"def clear_fields(self):\n\n if not self.is_root:\n return\n self.field_data.clear()",
"def test_raises_if_initial_fieldsets_error(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }), )\n position_missing_fieldsets = deepcopy(test_fieldsets)\n del position_missing_fieldsets[1][1]['position']\n fields_missing_fieldsets = deepcopy(test_fieldsets)\n del fields_missing_fieldsets[0][1]['fields']\n message = \"There must be 'fields' and 'position' in each fieldset. \"\n self.form.fieldsets = position_missing_fieldsets\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets()\n self.form.fieldsets = fields_missing_fieldsets\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets()\n\n self.form.fieldsets = original_fieldsets",
"def _reset(self):\n\n # Checking one attribute is enough, becase they are all set together\n # in partial_fit\n if hasattr(self, 'scale_'):\n del self.scale_",
"def _reset(self):\n\n # Checking one attribute is enough, becase they are all set together\n # in partial_fit\n if hasattr(self, 'scale_'):\n del self.scale_",
"def reset(self):\n super().reset()\n whitelist = []\n for parent in self.cls.mro():\n whitelist.extend(getattr(parent, 'tab_whitelist', []))\n\n if getattr(parent, \"tab_component_names\", False):\n for cpt_name in parent.component_names:\n if getattr(parent, cpt_name).kind != Kind.omitted:\n whitelist.append(cpt_name)\n\n self._includes = set(whitelist)",
"def remove_all(self):\n self.initial = None\n self.contour = None\n self.control_points = []",
"def test_make_fieldsets_outcome_order(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'position': None,\n 'fields': [\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n fieldsets[0], fieldsets[1] = fieldsets[1], fieldsets[0]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def reset(self):\n self.dims.clear()\n self.xlabels.clear()\n self.annotators.clear()\n self._figTitle = None\n self.tbmTitle = None\n self._isSubplot = False\n self._universal_xlabel = False\n self._plotter = None\n self.Nsp = 0",
"def test_make_fieldsets_saves_results(self):\n original_initial_fieldsets = getattr(self.form, 'fieldsets', None)\n initial_fieldsets = deepcopy(original_initial_fieldsets)\n original_computed_fieldsets = getattr(self.form, '_fieldsets', None)\n original_summary = getattr(self.form, '_fs_summary', None)\n self.assertIsNotNone(original_initial_fieldsets)\n self.assertIsNone(original_computed_fieldsets)\n self.assertIsNone(original_summary)\n response_fieldsets = self.form.make_fieldsets()\n label, summary = response_fieldsets.pop()\n self.assertIsNotNone(self.form._fieldsets)\n self.assertIsNotNone(self.form._fs_summary)\n self.assertEqual('summary', label)\n self.assertEqual(summary, self.form._fs_summary)\n self.assertEqual(response_fieldsets, self.form._fieldsets)\n self.assertEqual(initial_fieldsets, self.form.fieldsets)\n\n self.form.fieldsets = original_initial_fieldsets\n self.form._fieldsets = original_computed_fieldsets\n self.form._fs_summary = original_summary\n if original_computed_fieldsets is None:\n del self.form._fieldsets\n if original_summary is None:\n del self.form._fs_summary",
"def clear_quantities(shared):\n\n del_list = [i for i, fm in enumerate(shared.field_mappings)\n if fm.extra is not None]\n for index in reversed(del_list):\n del shared.field_mappings[index]\n\n shared.config.remove_section('extra')\n shared.config.add_section('extra')",
"def reset(self):\n self.__sets = []\n self._computed = False",
"def reset(self):\n\n self.fig.clear()\n self.ax = self.fig.add_subplot(111)\n self.hasLegend.set(False)\n self.title(Graph.default_title)\n # Lines is a list of DataSet objects. The user should take care to make\n # DataSet names unique, as there is no error checking done by Graph. \n # If a DataSet line is deleted by its formal name, Graph will delete the\n # first line in the list that matches the name.\n self.lines = {}\n self.line_counter = 1",
"def clear_legends(self):\n self.fig.legends[:] = []\n for ax in self.axes.flat:\n legend = ax.get_legend()\n if legend:\n legend.remove()\n return self",
"def clean(self):\r\n # clean categories\r\n filter_categories = \\\r\n self.categories[self.category_index: self.category_index+2]\r\n self.categories = [\r\n category for category in filter_categories if category != '']\r\n del self.fields[\"categories\"]\r\n self.fields[\"category\"] = self.categories[0]\r\n\r\n try:\r\n self.fields[\"sub_category\"] = self.categories[1]\r\n except IndexError:\r\n self.fields[\"sub_category\"] = None\r\n\r\n # clean stores\r\n filter_stores = self.stores[:2]\r\n self.stores = [store for store in filter_stores]\r\n del self.fields[\"stores\"]\r\n\r\n for n in range(len(self.stores)):\r\n field_name = \"store_\" + str(n)\r\n self.fields[field_name] = self.stores[n]\r\n\r\n # clean brand\r\n self.brand = self.brands[0]\r\n self.fields[\"brand\"] = self.brand\r\n del self.fields[\"brands\"]\r\n\r\n # clean others fields\r\n self.fields[\"name\"] = self.fields.pop(\"product_name_fr\")\r\n self.fields[\"description\"] = self.fields.pop(\"generic_name\")\r\n self.fields[\"nutri_score\"] = self.fields.pop(\"nutrition_grade_fr\")",
"def _reset(self):\n\n # Checking one attribute is enough, becase they are all set together\n # in partial_fit\n if hasattr(self, 'scale_'):\n del self.scale_\n del self.mean_\n del self.var_",
"def _resetFlags(self, field=None):\n\n flags = self._flags\n if flags is None:\n return\n if field:\n labels = FLAG_FIELDS[field]\n else:\n labels = list(FLAG_PLANTERS)\n subsets = self._subsets\n for label in labels:\n flags.pop(label, None)\n subsets.pop(label, None)",
"def clear(self):\n self.cb_attr.clear()\n self.group_listbox.clear()\n self.data = None\n self.__groups = None\n self.graph.reset()\n self.infoLabel.setText(\"No data on input.\")",
"def resetSelectionArea(self):\n for legend in self._selectionAreas:\n self.plot.remove(legend, kind='item')\n self._selectionAreas = set()",
"def onClearButton(self):\n markupsNode = slicer.util.getNode( \"MarkupsFiducial\" ) \n markupsNode.RemoveAllMarkups()",
"def test_make_fieldsets_uses_prep_fields(self):\n original_called_prep_fields = self.form.called_prep_fields = False\n full_fieldsets = self.form.make_fieldsets()\n\n self.assertFalse(original_called_prep_fields)\n self.assertIsInstance(full_fieldsets, (list, tuple))\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n self.assertTrue(self.form.called_prep_fields)\n\n self.form.called_prep_fields = original_called_prep_fields",
"def clear_previous_selections(self):\n self.headers = []\n self.filename = ''\n self.x_axis = ''\n self.y_axis = ''\n self.delim = ''\n self.non_numeric_x_axis = False\n self.count_desired = False",
"def clean(self):\n cleaned_data = super(EnterpriseCustomerAdminForm, self).clean()\n if 'catalog' in cleaned_data and not cleaned_data['catalog']:\n cleaned_data['catalog'] = None\n return cleaned_data",
"def clear_precalc(self):\n self.Dmat_obs = None\n self.Dmat_obs_b = None\n self.dSdqb_mat1 = None\n self.Mmat = None\n self.Mmat_mix = None\n self.mll = None",
"def clear(self):\n self.raster_path_line.clear()\n self.labels_path.clear()\n self.shapefile_path.clear()\n self.costumelabels.clear()\n self.layer_name.clear()\n self.class_name.clear()\n self.idfield.clear()",
"def _reset(self):\n\n # Checking one attribute is enough, because they are all set together\n # in partial_fit\n if hasattr(self, 'scale_'):\n del self.scale_\n del self.n_samples_seen_\n del self.mean_\n del self.var_"
] | [
"0.6889715",
"0.6360244",
"0.6088527",
"0.59613407",
"0.59489715",
"0.59358686",
"0.5868241",
"0.5843636",
"0.5843636",
"0.5824178",
"0.5816966",
"0.57959515",
"0.5762446",
"0.57576734",
"0.57333314",
"0.57224417",
"0.57116276",
"0.5707388",
"0.57031906",
"0.56946254",
"0.5680574",
"0.5660498",
"0.56547314",
"0.5592646",
"0.55847865",
"0.5566906",
"0.55644166",
"0.5555742",
"0.552929",
"0.55247897"
] | 0.67204076 | 1 |
The each fieldset in the computed fieldset settings have all the expected keys in their options. | def test_computed_fieldsets_structure(self):
original_fieldsets = self.form.fieldsets
self.form.fieldsets = (
('Your Name', {
'position': 1,
'fields': [('first_name', 'last_name', )],
}),
(None, {
'classes': ('counting', ),
'position': 2,
'fields': [
('first', 'second', ),
'not_third',
'not_fourth',
'last',
],
}),
('Non_Fields', {
'position': 3,
'fields': [
'non-field_name',
'not_a_field'
],
}),
(None, {
'position': None,
# 'modifiers': ['password_display', ],
'fields': [
# ('password1', 'password2', ),
'generic_field',
'bool_field',
'single_check'
]
}),
('address', {
'classes': ('collapse', 'address', ),
# 'modifiers': ['address', 'prep_country_fields', ],
'position': 'end',
'fields': [
'billing_address_1',
'billing_address_2',
('billing_city', 'billing_country_area', 'billing_postcode', ),
],
}), )
self.form.make_fieldsets()
fieldsets = self.form._fieldsets
each_are_tuples = (isinstance(ea, tuple) for ea in fieldsets)
correct_fieldset_labels = (isinstance(label, (str, type(None))) for label, opts in fieldsets)
opts_are_dictionaries = (isinstance(opts, dict) for label, opts in fieldsets)
required_keys = {'position', 'fields', 'field_names', 'rows', 'column_count', }
optional_keys = {'classes', 'modifiers', 'row_data', }
allowed_keys = required_keys | optional_keys
opt_keys = set(flatten([list(opts.keys()) for lbl, opts, in fieldsets]))
unaccepted_keys = [key for key in opt_keys if key not in allowed_keys]
has_required = (all(key in opts for key in required_keys) for lbl, opts in fieldsets)
self.assertIsInstance(fieldsets, list)
self.assertTrue(all(each_are_tuples))
self.assertTrue(all(correct_fieldset_labels))
self.assertTrue(all(opts_are_dictionaries))
self.assertEqual(len(unaccepted_keys), 0)
self.assertFalse(unaccepted_keys)
self.assertTrue(all(has_required))
self.form.fieldsets = original_fieldsets | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_no_empty_sets_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n ('Non_Fields', {\n 'position': 2,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 2)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_overall_make_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_make_fieldsets_outcome_order(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'position': None,\n 'fields': [\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n fieldsets[0], fieldsets[1] = fieldsets[1], fieldsets[0]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def show_fieldsetform(form):\n return {'form': form, 'required_fields': True}",
"def test_no_empty_rows_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_a_field',\n ('last_name', 'another_field', ),\n ('first_name', 'non-field_name', ),\n 'generic_field',\n 'last',\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: remaining_fields.pop(name) for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 3)\n self.assertEqual(len(fieldsets[1][1]['rows']), 4)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_as_fieldset(self):\n # form._html_output(self, row_tag, col_head_tag, col_tag, single_col_tag, col_head_data, col_data,\n # help_text_br, errors_on_separate_row, as_type=None, strict_columns=False)\n pass",
"def test_missing_initial_fieldsets(self):\n original_initial_fieldsets = self.form.fieldsets\n print(\"========================= TEST UNABLE TO DELETE THE PROPERTY FOR TESTING ========================\")\n print(original_initial_fieldsets)\n print(\"--------------------------------------\")\n delattr(self.form, 'fieldsets')\n response_fieldsets = self.form.make_fieldsets()\n print(response_fieldsets)\n\n setattr(self.form, 'fieldsets', original_initial_fieldsets)",
"def test_make_fieldsets_saves_results(self):\n original_initial_fieldsets = getattr(self.form, 'fieldsets', None)\n initial_fieldsets = deepcopy(original_initial_fieldsets)\n original_computed_fieldsets = getattr(self.form, '_fieldsets', None)\n original_summary = getattr(self.form, '_fs_summary', None)\n self.assertIsNotNone(original_initial_fieldsets)\n self.assertIsNone(original_computed_fieldsets)\n self.assertIsNone(original_summary)\n response_fieldsets = self.form.make_fieldsets()\n label, summary = response_fieldsets.pop()\n self.assertIsNotNone(self.form._fieldsets)\n self.assertIsNotNone(self.form._fs_summary)\n self.assertEqual('summary', label)\n self.assertEqual(summary, self.form._fs_summary)\n self.assertEqual(response_fieldsets, self.form._fieldsets)\n self.assertEqual(initial_fieldsets, self.form.fieldsets)\n\n self.form.fieldsets = original_initial_fieldsets\n self.form._fieldsets = original_computed_fieldsets\n self.form._fs_summary = original_summary\n if original_computed_fieldsets is None:\n del self.form._fieldsets\n if original_summary is None:\n del self.form._fs_summary",
"def get_formset_kwargs(self):\n return {\n 'can_order':self.can_order,\n 'can_delete':self.can_delete,\n 'extra':self.extra,\n 'max_num' : self.max_num,\n 'validate_max' : self.validate_max,\n 'min_num' : self.min_num,\n 'validate_min' : self.validate_min,\n }",
"def get_options(self):\n additional_data = self.get_additional_data()\n options_out = []\n for key, value in additional_data['DIMENSION_VALUES'].items():\n key_label = ' '.join(key.split('_')).strip().title()\n data = {'specification': key_label, 'specification_key': key, 'choices': value}\n options_out.append(data)\n return options_out",
"def get_formset_kwargs(self):\n\t\treturn {\n\t\t\t'extra': self.extra,\n\t\t\t'can_order': self.can_order,\n\t\t\t'can_delete': self.can_delete,\n\t\t\t'max_num': self.max_num,\t\t\n\t\t}",
"def test_make_fieldsets_uses_prep_fields(self):\n original_called_prep_fields = self.form.called_prep_fields = False\n full_fieldsets = self.form.make_fieldsets()\n\n self.assertFalse(original_called_prep_fields)\n self.assertIsInstance(full_fieldsets, (list, tuple))\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n self.assertTrue(self.form.called_prep_fields)\n\n self.form.called_prep_fields = original_called_prep_fields",
"def get_fieldsets(self, request, obj=None):\n fieldsets = super(AdjustableCacheMixin, self).get_fieldsets(request, obj=None)\n if CMS_GTE_330:\n return fieldsets\n\n field = 'cache_duration'\n for fieldset in fieldsets:\n new_fieldset = [\n item for item in fieldset[1]['fields'] if item != field]\n fieldset[1]['fields'] = tuple(new_fieldset)\n return fieldsets",
"def test_no_duplicate_fields_in_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n ('Confused', {\n 'position': 3,\n 'fields': [\n ('first_name', 'generic_field', ),\n 'first',\n 'last',\n ],\n }), )\n duplicates = set(('first_name', 'first', 'last', ))\n expected = []\n for names in test_fieldsets[2][1]['fields']:\n if isinstance(names, str):\n names = (names, )\n names = [name for name in names if name not in duplicates]\n if names:\n expected.append({name: self.form.fields[name] for name in names})\n self.form.fieldsets = deepcopy(test_fieldsets)\n self.form.make_fieldsets()\n computed_fieldsets = self.form._fieldsets\n opts = computed_fieldsets[2][1]\n actual = opts['rows']\n\n self.assertEqual(1, len(actual), \"Rows of already used fields were added. \")\n self.assertEqual(1, len(actual[0]), \"Columns of already used fields were added. \")\n self.assertEqual(expected, actual)\n for lbl, opts in computed_fieldsets[:2]:\n row_names = flatten([list(row.keys()) for row in opts['rows']])\n self.assertEqual(opts['field_names'], row_names, \"Field missing from its expected first fieldset. \")\n\n self.form.fieldsets = original_fieldsets",
"def get_setup_forms(self, wizard):\n return {} # pragma: no cover",
"def test_make_fieldsets_names_can_be_coded(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n (None, {\n 'position': 1,\n 'fields': [\n ('first', 'second', ),\n ('_name_for_coded', 'last', ),\n ],\n }),\n ('Your Name', {\n 'position': 2,\n 'fields': [('first_name', 'last_name', )],\n }), )\n self.form.fieldsets = test_fieldsets\n expected_name = self.form.name_for_coded\n self.form.make_fieldsets()\n computed_fieldsets = self.form._fieldsets\n opts = computed_fieldsets[0][1]\n target = opts['rows'][1]\n self.assertIn(expected_name, target.keys())\n self.assertEqual(self.form.fields.get(expected_name), target.get(expected_name, ''))\n self.assertIn('_name_for_coded', opts['field_names'])\n\n self.form.fieldsets = original_fieldsets",
"def test_raises_if_initial_fieldsets_error(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }), )\n position_missing_fieldsets = deepcopy(test_fieldsets)\n del position_missing_fieldsets[1][1]['position']\n fields_missing_fieldsets = deepcopy(test_fieldsets)\n del fields_missing_fieldsets[0][1]['fields']\n message = \"There must be 'fields' and 'position' in each fieldset. \"\n self.form.fieldsets = position_missing_fieldsets\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets()\n self.form.fieldsets = fields_missing_fieldsets\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets()\n\n self.form.fieldsets = original_fieldsets",
"def get_fieldsets(self, request, obj=None):\n base_fields = (\n None, {\n 'fields': ASCreationForm.Meta.fields\n }\n )\n host_ip_fields = (\n 'Host IPs', {\n 'fields': ('internal_ip', 'public_ip', 'bind_ip', )\n }\n )\n key_fields = (\n 'Keys & Certificates', {\n 'classes': ('collapse',),\n 'fields': (\n 'master_as_key',\n )\n }\n )\n if not obj:\n return (base_fields, host_ip_fields)\n return (base_fields, key_fields)",
"def test_construct_fieldset_tag(attributes):\n fset = FieldSet(**attributes)\n assert fset.construct() == fieldset.render(attributes)",
"def test_use_existing_computed_field_dict(self):\n if isinstance(self.form.computed_fields, list):\n self.form.computed_fields = self.form.get_computed_fields(self.form.computed_fields)\n self.form.fields.update(self.form.computed_fields) # only names in fields included in get_computed_field_names.\n result_names = self.form.get_computed_field_names([], self.form.fields)\n\n self.assertIsInstance(self.form.computed_fields, dict)\n self.assertIn('test_field', result_names)",
"def test_make_fieldsets_uses_handle_modifiers(self):\n original_called_handle_modifiers = self.form.called_handle_modifiers = False\n full_fieldsets = self.form.make_fieldsets()\n\n self.assertFalse(original_called_handle_modifiers)\n self.assertIsInstance(full_fieldsets, (list, tuple))\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n self.assertTrue(self.form.called_handle_modifiers)\n\n self.form.called_handle_modifiers = original_called_handle_modifiers",
"def test_get_flat_fields_setting(self):\n # FormOverrideMixIn.get_flat_fields_setting\n pass",
"def show_fieldsetform_nrf(form):\n return {'form': form, 'required_fields': False}",
"def render_change_form_fieldset(context, fieldset):\n return fieldset.render(context)",
"def test_form_main_rows_all_fieldsets(self):\n # form.form_main_rows(self, html_args, fieldsets, form_col_count)\n # html_args = (row_tag, col_head_tag, col_tag, single_col_tag, as_type, all_fieldsets)\n pass",
"def get_formset_kwargs(self):\n\t\tkwargs = super(InlineFormsetMixin, self).get_formset_kwargs()\n\t\t\n\t\tkwargs.update({\n\t\t\t'fields': self.fields,\n\t\t\t'exclude': self.exclude,\n\t\t\t'fk_name': self.fk_name,\n\t\t})\n\t\t\n\t\treturn kwargs",
"def get_fieldsets(self, request, obj=None):\n return (\n ('Name', {\n 'fields': (\n ('first_name', 'last_name'),)\n }),\n ('IPI', {\n 'fields': (\n ('ipi_name', 'ipi_base'),),\n }),\n ('Societies', {\n 'fields': (\n self.get_society_list(),),\n }),\n ('General agreement', {\n 'fields': (\n ('generally_controlled',\n ('saan', 'publisher_fee'))\n ),\n }),\n )",
"def test_form_main_rows_all_fieldsets_has_container(self):\n # form.form_main_rows(self, html_args, fieldsets, form_col_count)\n # html_args = (row_tag, col_head_tag, col_tag, single_col_tag, as_type, all_fieldsets)\n pass",
"def setup_known_fields(self):\n\n kfields = dict(self.known_fields)\n freg = re.compile(r\"(^.+)_\\d+$\")\n for field in self:\n if self[field].get(\"units\") is not None:\n continue\n\n if field in kfields:\n self[field][\"units\"] = kfields[field]\n continue\n\n fs = freg.search(field)\n if fs and fs.groups()[0] in kfields:\n self[field][\"units\"] = kfields[fs.groups()[0]]",
"def test_form_main_rows_html_fieldset(self):\n # form.form_main_rows(self, html_args, fieldsets, form_col_count)\n # html_args = (row_tag, col_head_tag, col_tag, single_col_tag, as_type, all_fieldsets)\n pass"
] | [
"0.641561",
"0.6393425",
"0.6136707",
"0.6101192",
"0.5897014",
"0.58947396",
"0.5781593",
"0.5745731",
"0.573621",
"0.56874764",
"0.5633608",
"0.5565005",
"0.5522902",
"0.551594",
"0.5493446",
"0.54890853",
"0.5461729",
"0.5406058",
"0.5404863",
"0.54012376",
"0.5399749",
"0.5365244",
"0.5361409",
"0.53478235",
"0.53355074",
"0.5327379",
"0.52871466",
"0.5237497",
"0.5229695",
"0.52160186"
] | 0.68545306 | 0 |
The make_fieldsets method assigns and sorts according to the expected order. | def test_make_fieldsets_outcome_order(self):
original_fieldsets = self.form.fieldsets
self.form.fieldsets = (
(None, {
'classes': ('counting', ),
'position': 2,
'fields': [
('first', 'second', ),
'last',
],
}),
('Non_Fields', {
'position': 3,
'fields': [
'non-field_name',
'not_a_field'
],
}),
('Your Name', {
'position': 1,
'fields': [('first_name', 'last_name', )],
}),
(None, {
'position': None,
'fields': [
'generic_field',
'bool_field',
'single_check'
]
}),
('address', {
'classes': ('collapse', 'address', ),
# 'modifiers': ['address', 'prep_country_fields', ],
'position': 'end',
'fields': [
'billing_address_1',
'billing_address_2',
('billing_city', 'billing_country_area', 'billing_postcode', ),
],
}), )
fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']
fieldsets[0], fieldsets[1] = fieldsets[1], fieldsets[0]
remaining_fields = self.form.fields.copy()
assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])
unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]
remaining_fields.pop('hide_field')
address_fieldset = fieldsets.pop()
opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}
fieldsets.append((None, opts))
fieldsets.append(address_fieldset)
for fieldset_label, opts in fieldsets:
opts['field_names'] = flatten(opts['fields'])
rows, column_count = [], 0
for names in opts['fields']:
if isinstance(names, str):
names = [names]
columns = {name: self.form.fields[name] for name in names if name in remaining_fields}
# TODO: Remove hidden or otherwise excluded fields.
column_count = max(column_count, len(columns))
if columns:
rows.append(columns)
opts['rows'] = rows
opts['column_count'] = column_count
self.form.make_fieldsets()
actual_fieldsets = self.form._fieldsets
self.assertEqual(len(fieldsets), 5)
self.assertEqual(len(fieldsets), len(actual_fieldsets))
count = 0
for expect, got in zip(fieldsets, actual_fieldsets):
labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))
expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])
actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])
row_names = str(expect_row_names) + '\n' + str(actual_row_names)
message = f"Fieldset # {count} named {labels} expected then got: \n{row_names}"
self.assertEqual(expect, got, message)
count += 1
self.assertEqual(fieldsets, actual_fieldsets)
self.form.fieldsets = original_fieldsets | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_make_fieldsets_uses_prep_fields(self):\n original_called_prep_fields = self.form.called_prep_fields = False\n full_fieldsets = self.form.make_fieldsets()\n\n self.assertFalse(original_called_prep_fields)\n self.assertIsInstance(full_fieldsets, (list, tuple))\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n self.assertTrue(self.form.called_prep_fields)\n\n self.form.called_prep_fields = original_called_prep_fields",
"def test_overall_make_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_make_fieldsets_saves_results(self):\n original_initial_fieldsets = getattr(self.form, 'fieldsets', None)\n initial_fieldsets = deepcopy(original_initial_fieldsets)\n original_computed_fieldsets = getattr(self.form, '_fieldsets', None)\n original_summary = getattr(self.form, '_fs_summary', None)\n self.assertIsNotNone(original_initial_fieldsets)\n self.assertIsNone(original_computed_fieldsets)\n self.assertIsNone(original_summary)\n response_fieldsets = self.form.make_fieldsets()\n label, summary = response_fieldsets.pop()\n self.assertIsNotNone(self.form._fieldsets)\n self.assertIsNotNone(self.form._fs_summary)\n self.assertEqual('summary', label)\n self.assertEqual(summary, self.form._fs_summary)\n self.assertEqual(response_fieldsets, self.form._fieldsets)\n self.assertEqual(initial_fieldsets, self.form.fieldsets)\n\n self.form.fieldsets = original_initial_fieldsets\n self.form._fieldsets = original_computed_fieldsets\n self.form._fs_summary = original_summary\n if original_computed_fieldsets is None:\n del self.form._fieldsets\n if original_summary is None:\n del self.form._fs_summary",
"def test_computed_fieldsets_structure(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n self.form.make_fieldsets()\n fieldsets = self.form._fieldsets\n each_are_tuples = (isinstance(ea, tuple) for ea in fieldsets)\n correct_fieldset_labels = (isinstance(label, (str, type(None))) for label, opts in fieldsets)\n opts_are_dictionaries = (isinstance(opts, dict) for label, opts in fieldsets)\n required_keys = {'position', 'fields', 'field_names', 'rows', 'column_count', }\n optional_keys = {'classes', 'modifiers', 'row_data', }\n allowed_keys = required_keys | optional_keys\n opt_keys = set(flatten([list(opts.keys()) for lbl, opts, in fieldsets]))\n unaccepted_keys = [key for key in opt_keys if key not in allowed_keys]\n has_required = (all(key in opts for key in required_keys) for lbl, opts in fieldsets)\n self.assertIsInstance(fieldsets, list)\n self.assertTrue(all(each_are_tuples))\n self.assertTrue(all(correct_fieldset_labels))\n self.assertTrue(all(opts_are_dictionaries))\n self.assertEqual(len(unaccepted_keys), 0)\n self.assertFalse(unaccepted_keys)\n self.assertTrue(all(has_required))\n\n self.form.fieldsets = original_fieldsets",
"def grouped_formset_factory(leafpack=None, taxon_forms=None):\n groupedform_list = []\n groupRS= LeafPackSensitivityGroup.objects.all()\n\n for gr in groupRS:\n\n groupRS = Macroinvertebrate.objects.filter(displayflag= True, sens_group=gr).order_by('display_order')\n bug_forms=[]\n for taxon in groupRS:\n if leafpack is not None:\n try:\n lpg = LeafPackBug.objects.get(bug=taxon.id, leaf_pack=leafpack.id)\n except ObjectDoesNotExist:\n lpg = LeafPackBug(bug=taxon, leaf_pack=leafpack)\n lpg.save()\n else:\n lpg = LeafPackBug(bug=taxon)\n \n bug_form = LeafPackBugForm(instance=lpg)\n bug_forms.append(bug_form)\n \n group ={}\n group['name']= 'Group {0}: {1}'.format(str(gr.id), gr.name)\n group['list']= bug_forms\n groupedform_list.append(group)\n\n # If taxon_forms is not None, plug bug_count values into new formset\n if taxon_forms is not None:\n\n def get_taxon_count(taxon_):\n for tf in taxon_forms:\n if tf.instance.bug == taxon_:\n return tf.instance.bug_count\n return 0\n\n for forms_ in taxon_forms:\n forms_[0].initial['bug_count'] = get_taxon_count(forms_[0].instance.bug)\n\n for form in forms_[1]:\n form.initial['bug_count'] = get_taxon_count(form.instance.bug)\n\n return groupedform_list",
"def test_make_fieldsets_uses_handle_modifiers(self):\n original_called_handle_modifiers = self.form.called_handle_modifiers = False\n full_fieldsets = self.form.make_fieldsets()\n\n self.assertFalse(original_called_handle_modifiers)\n self.assertIsInstance(full_fieldsets, (list, tuple))\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n self.assertTrue(self.form.called_handle_modifiers)\n\n self.form.called_handle_modifiers = original_called_handle_modifiers",
"def test_missing_initial_fieldsets(self):\n original_initial_fieldsets = self.form.fieldsets\n print(\"========================= TEST UNABLE TO DELETE THE PROPERTY FOR TESTING ========================\")\n print(original_initial_fieldsets)\n print(\"--------------------------------------\")\n delattr(self.form, 'fieldsets')\n response_fieldsets = self.form.make_fieldsets()\n print(response_fieldsets)\n\n setattr(self.form, 'fieldsets', original_initial_fieldsets)",
"def test_make_fieldsets_names_can_be_coded(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n (None, {\n 'position': 1,\n 'fields': [\n ('first', 'second', ),\n ('_name_for_coded', 'last', ),\n ],\n }),\n ('Your Name', {\n 'position': 2,\n 'fields': [('first_name', 'last_name', )],\n }), )\n self.form.fieldsets = test_fieldsets\n expected_name = self.form.name_for_coded\n self.form.make_fieldsets()\n computed_fieldsets = self.form._fieldsets\n opts = computed_fieldsets[0][1]\n target = opts['rows'][1]\n self.assertIn(expected_name, target.keys())\n self.assertEqual(self.form.fields.get(expected_name), target.get(expected_name, ''))\n self.assertIn('_name_for_coded', opts['field_names'])\n\n self.form.fieldsets = original_fieldsets",
"def get_fieldsets(self, default):\n default = default + ['-']\n\n last = None\n fields = []\n for perm in self.__permissions_to_manage():\n if last != perm.content_type:\n if fields:\n default = default + ['h3:'+last.model_class()._meta.verbose_name_plural, segment(chunks(fields, 4))]\n last = perm.content_type\n fields = []\n\n fields = fields + [perm.codename]\n\n default = default + ['h3:'+last.model_class()._meta.verbose_name_plural, segment(chunks(fields, 4))]\n return default",
"def formset_factory(leafpack=None, taxon_forms=None): # type: (LeafPack, [LeafPackBugForm]) -> list\n form_list = []\n\n queryset = Macroinvertebrate.objects.filter(family_of=None).order_by('sort_priority')\n\n for taxon in queryset:\n if leafpack is not None:\n try:\n lpg = LeafPackBug.objects.get(bug=taxon.id, leaf_pack=leafpack.id)\n except ObjectDoesNotExist:\n lpg = LeafPackBug(bug=taxon, leaf_pack=leafpack)\n lpg.save()\n else:\n lpg = LeafPackBug(bug=taxon)\n\n order_bug_form = LeafPackBugForm(instance=lpg)\n\n families = taxon.families.all().order_by('common_name').order_by('sort_priority')\n family_bug_forms = list()\n if len(families) > 0:\n\n if leafpack is not None:\n\n child_taxons = []\n for child_bug in families:\n\n try:\n child_lpg = LeafPackBug.objects.get(bug=child_bug, leaf_pack=leafpack)\n except ObjectDoesNotExist:\n child_lpg = LeafPackBug(bug=child_bug, leaf_pack=leafpack)\n child_lpg.save()\n\n child_taxons.append(child_lpg)\n\n family_bug_forms = [LeafPackBugForm(instance=taxon) for taxon in child_taxons]\n else:\n family_bug_forms = [LeafPackBugForm(instance=LeafPackBug(bug=bug)) for bug in families]\n\n form_list.append((order_bug_form, family_bug_forms))\n\n # If taxon_forms is not None, plug bug_count values into new formset\n if taxon_forms is not None:\n\n def get_taxon_count(taxon_):\n for tf in taxon_forms:\n if tf.instance.bug == taxon_:\n return tf.instance.bug_count\n return 0\n\n for forms_ in taxon_forms:\n forms_[0].initial['bug_count'] = get_taxon_count(forms_[0].instance.bug)\n\n for form in forms_[1]:\n form.initial['bug_count'] = get_taxon_count(form.instance.bug)\n\n return form_list",
"def test_no_empty_sets_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n ('Non_Fields', {\n 'position': 2,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 2)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def get_fieldsets(self, request, obj=None):\n return (\n ('Name', {\n 'fields': (\n ('first_name', 'last_name'),)\n }),\n ('IPI', {\n 'fields': (\n ('ipi_name', 'ipi_base'),),\n }),\n ('Societies', {\n 'fields': (\n self.get_society_list(),),\n }),\n ('General agreement', {\n 'fields': (\n ('generally_controlled',\n ('saan', 'publisher_fee'))\n ),\n }),\n )",
"def create_sets(self,FD_SET=['FinalD'],VA_SET=['VA']):\n \n self.m.S = Set(initialize=self.sectors, doc='sectors')\n self.m.P = Set(initialize=self.products, doc='sectors')\n self.m.row = Set(initialize=self.products, doc='products')\n self.m.col = Set(initialize=self.sectors+['FinalD'], doc='sectors and final demand')\n \n self.m.rROW = Set(initialize=self.countries,ordered=True, doc='regions including export')\n self.m.R = Set(initialize=self.countries,ordered=True, doc='regions')\n\n self.m.fdemand = Set(initialize=FD_SET, doc='Final Demand')\n\n self.m.VA = Set(initialize=VA_SET, doc='value added')",
"def create_sets(self,FD_SET=[],VA_SET=[]):\n \n self.m.S = Set(initialize=self.sectors, doc='sectors')\n\n if self.EORA is True:\n self.m.rROW = Set(initialize=self.countries+['ROW'],ordered=True, doc='regions including export')\n self.m.R = Set(initialize=self.countries+['ROW'],ordered=True, doc='regions')\n else:\n self.m.rROW = Set(initialize=self.countries,ordered=True, doc='regions including export')\n self.m.R = Set(initialize=self.countries,ordered=True, doc='regions')\n\n if self.EORA is True:\n self.m.fdemand = Set(initialize=['P3h', 'P3n','P3g', 'P51','P52','P53'], doc='Final Demand')\n else:\n self.m.fdemand = Set(initialize=self.fd_cat, doc='Final Demand')\n\n if self.EORA is True:\n self.m.VA = Set(initialize=['VA'], doc='value added')\n else:\n self.m.VA = Set(initialize=VA_SET, doc='value added')",
"def get_fieldsets(model):\n fieldsets = getattr(model, 'report_builder_fieldsets', None)\n if fieldsets:\n for fieldset_name, fieldset_dict in model.report_builder_fieldsets:\n fieldset_string_to_field(fieldset_dict, model)\n return fieldsets",
"def reorder_sets(sets):\n\n if len(sets) == 1:\n return sets\n\n s = set([])\n\n for ss in sets:\n for i in ss:\n s.add(i)\n\n tree = P(sets)\n\n\n for i in s:\n tree.set_contiguous(i)\n tree = flatten(tree)\n\n return tree.ordering()",
"def get_fieldsets(self, request, obj=None):\n if obj:\n return self._change_fieldsets\n return self._add_fieldsets",
"def get_fieldsets(self, request, obj=None):\n if obj:\n return (('Corporate Burn Attribute Summary', {\n \"fields\": ('name', 'description', ('financial_year', 'planned_season'),\n ('last_year', 'last_season',\n 'last_year_unknown', 'last_season_unknown'),\n 'region', 'district', 'location',\n 'forest_blocks',\n ('priority', 'rationale'),\n ('contentious', 'contentious_rationale'),\n 'aircraft_burn',\n # TODO: PBS-1551 # 'allocation',\n 'remote_sensing_priority', 'purposes',\n ('area', 'perimeter', 'treatment_percentage'),\n ('non_calm_tenure','non_calm_tenure_approved','non_calm_tenure_included','non_calm_tenure_value','non_calm_tenure_complete','non_calm_tenure_risks')\n )\n }), ('Other Attributes', {\n \"fields\": ('tenures', 'fuel_types', 'shires',\n 'bushfire_act_zone', 'prohibited_period',\n 'forecast_areas', 'prescribing_officer',\n 'short_code')\n }))\n else:\n return super(PrescriptionAdmin, self).get_fieldsets(request, obj)",
"def test_no_duplicate_fields_in_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n ('Confused', {\n 'position': 3,\n 'fields': [\n ('first_name', 'generic_field', ),\n 'first',\n 'last',\n ],\n }), )\n duplicates = set(('first_name', 'first', 'last', ))\n expected = []\n for names in test_fieldsets[2][1]['fields']:\n if isinstance(names, str):\n names = (names, )\n names = [name for name in names if name not in duplicates]\n if names:\n expected.append({name: self.form.fields[name] for name in names})\n self.form.fieldsets = deepcopy(test_fieldsets)\n self.form.make_fieldsets()\n computed_fieldsets = self.form._fieldsets\n opts = computed_fieldsets[2][1]\n actual = opts['rows']\n\n self.assertEqual(1, len(actual), \"Rows of already used fields were added. \")\n self.assertEqual(1, len(actual[0]), \"Columns of already used fields were added. \")\n self.assertEqual(expected, actual)\n for lbl, opts in computed_fieldsets[:2]:\n row_names = flatten([list(row.keys()) for row in opts['rows']])\n self.assertEqual(opts['field_names'], row_names, \"Field missing from its expected first fieldset. \")\n\n self.form.fieldsets = original_fieldsets",
"def _build_ID_sets(self):\n raise NotImplementedError",
"def updateAutoChoices(self):\n autoFields = {}\n for format in self.values():\n fields = format.findAutoChoiceFields()\n if fields:\n autoFields[format.name] = fields\n if autoFields:\n for item in globalref.docRef.root.descendantGen():\n for field in autoFields.get(item.formatName, []):\n field.addChoice(item.data.get(field.name, ''))\n for fieldList in autoFields.values():\n for field in fieldList:\n field.sortChoices()",
"def get_fieldsets(self, request, obj=None):\n fieldsets = super(AdjustableCacheMixin, self).get_fieldsets(request, obj=None)\n if CMS_GTE_330:\n return fieldsets\n\n field = 'cache_duration'\n for fieldset in fieldsets:\n new_fieldset = [\n item for item in fieldset[1]['fields'] if item != field]\n fieldset[1]['fields'] = tuple(new_fieldset)\n return fieldsets",
"def get_fieldsets(self, request, obj=None):\n if request.user.user_type == User.ADMIN_CEA:\n return self.cea_fieldsets\n elif request.user.user_type == User.ADMIN_CRC:\n return self.crc_fieldsets\n elif request.user.user_type == User.EXPRESS_USER:\n return self.exp_fieldsets\n return self.fieldsets",
"def sort_creation_fields(\n fields: List[DataclassCreationFields],\n) -> List[DataclassCreationFields]:\n\n def has_default(model_field: DataclassCreationFields) -> bool:\n \"\"\"Check if field has defaults.\"\"\"\n return (model_field.field.default is not dataclasses.MISSING) or (\n model_field.field.default_factory is not dataclasses.MISSING\n )\n\n return sorted(fields, key=has_default)",
"def test_entities__Entity__setFieldOrder__1(entity_with_field, field):\n assert [] == entity_with_field.getFieldOrder()\n entity_with_field.setFieldOrder(['dummy2', field.__name__, 'dummy'])\n assert (['dummy2', field.__name__, 'dummy'] ==\n entity_with_field.getFieldOrder())",
"def __init__(self, **fields):\r\n \r\n self._by_number = []\r\n self._names = []\r\n self._by_name = {}\r\n self._numbers = {}\r\n \r\n for name in sorted(fields.keys()):\r\n self.add(name, fields[name])",
"def test_no_empty_rows_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_a_field',\n ('last_name', 'another_field', ),\n ('first_name', 'non-field_name', ),\n 'generic_field',\n 'last',\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: remaining_fields.pop(name) for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 3)\n self.assertEqual(len(fieldsets[1][1]['rows']), 4)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def _sort_validators(self):\n self._validators = sorted_poset(\n iterable=self._validators,\n key=lambda record: record.context,\n reverse=True)\n\n self._is_sorted = True",
"def sort(self, func):\n self._sets.sort(key=func)",
"def change_form_fieldsets(admin_form):\n form = admin_form.form\n readonly_fields = admin_form.readonly_fields\n model_admin = admin_form.model_admin\n\n for name, options in admin_form.fieldsets:\n yield ChangeFormFieldset(form=form,\n name=name,\n readonly_fields=readonly_fields,\n model_admin=model_admin,\n **options)"
] | [
"0.6534397",
"0.6528733",
"0.63007706",
"0.5835942",
"0.573928",
"0.5678768",
"0.56393546",
"0.563493",
"0.5626828",
"0.55249393",
"0.55195516",
"0.5459207",
"0.5449235",
"0.5386196",
"0.53837943",
"0.5338345",
"0.52496123",
"0.5248201",
"0.5243698",
"0.5192275",
"0.5124239",
"0.5110853",
"0.5108803",
"0.51025534",
"0.50928676",
"0.50800633",
"0.50685686",
"0.5065687",
"0.5055156",
"0.505434"
] | 0.69416034 | 0 |
The make_fieldsets method returns the expected response. | def test_overall_make_fieldsets(self):
original_fieldsets = self.form.fieldsets
self.form.fieldsets = (
('Your Name', {
'position': 1,
'fields': [('first_name', 'last_name', )],
}),
(None, {
'classes': ('counting', ),
'position': 2,
'fields': [
('first', 'second', ),
'not_third',
'not_fourth',
'last',
],
}),
('Non_Fields', {
'position': 3,
'fields': [
'non-field_name',
'not_a_field'
],
}),
(None, {
'position': None,
# 'modifiers': ['password_display', ],
'fields': [
# ('password1', 'password2', ),
'generic_field',
'bool_field',
'single_check'
]
}),
('address', {
'classes': ('collapse', 'address', ),
# 'modifiers': ['address', 'prep_country_fields', ],
'position': 'end',
'fields': [
'billing_address_1',
'billing_address_2',
('billing_city', 'billing_country_area', 'billing_postcode', ),
],
}), )
fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']
remaining_fields = self.form.fields.copy()
assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])
unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]
remaining_fields.pop('hide_field')
address_fieldset = fieldsets.pop()
opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}
fieldsets.append((None, opts))
fieldsets.append(address_fieldset)
for fieldset_label, opts in fieldsets:
opts['field_names'] = flatten(opts['fields'])
rows, column_count = [], 0
for names in opts['fields']:
if isinstance(names, str):
names = [names]
columns = {name: self.form.fields[name] for name in names if name in remaining_fields}
# TODO: Remove hidden or otherwise excluded fields.
column_count = max(column_count, len(columns))
if columns:
rows.append(columns)
opts['rows'] = rows
opts['column_count'] = column_count
self.form.make_fieldsets()
actual_fieldsets = self.form._fieldsets
self.assertEqual(len(fieldsets), 5)
self.assertEqual(len(fieldsets), len(actual_fieldsets))
count = 0
for expect, got in zip(fieldsets, actual_fieldsets):
labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))
expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])
actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])
row_names = str(expect_row_names) + '\n' + str(actual_row_names)
message = f"Fieldset # {count} named {labels} expected then got: \n{row_names}"
self.assertEqual(expect, got, message)
count += 1
self.assertEqual(fieldsets, actual_fieldsets)
self.form.fieldsets = original_fieldsets | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_make_fieldsets_saves_results(self):\n original_initial_fieldsets = getattr(self.form, 'fieldsets', None)\n initial_fieldsets = deepcopy(original_initial_fieldsets)\n original_computed_fieldsets = getattr(self.form, '_fieldsets', None)\n original_summary = getattr(self.form, '_fs_summary', None)\n self.assertIsNotNone(original_initial_fieldsets)\n self.assertIsNone(original_computed_fieldsets)\n self.assertIsNone(original_summary)\n response_fieldsets = self.form.make_fieldsets()\n label, summary = response_fieldsets.pop()\n self.assertIsNotNone(self.form._fieldsets)\n self.assertIsNotNone(self.form._fs_summary)\n self.assertEqual('summary', label)\n self.assertEqual(summary, self.form._fs_summary)\n self.assertEqual(response_fieldsets, self.form._fieldsets)\n self.assertEqual(initial_fieldsets, self.form.fieldsets)\n\n self.form.fieldsets = original_initial_fieldsets\n self.form._fieldsets = original_computed_fieldsets\n self.form._fs_summary = original_summary\n if original_computed_fieldsets is None:\n del self.form._fieldsets\n if original_summary is None:\n del self.form._fs_summary",
"def test_make_fieldsets_uses_prep_fields(self):\n original_called_prep_fields = self.form.called_prep_fields = False\n full_fieldsets = self.form.make_fieldsets()\n\n self.assertFalse(original_called_prep_fields)\n self.assertIsInstance(full_fieldsets, (list, tuple))\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n self.assertTrue(self.form.called_prep_fields)\n\n self.form.called_prep_fields = original_called_prep_fields",
"def test_missing_initial_fieldsets(self):\n original_initial_fieldsets = self.form.fieldsets\n print(\"========================= TEST UNABLE TO DELETE THE PROPERTY FOR TESTING ========================\")\n print(original_initial_fieldsets)\n print(\"--------------------------------------\")\n delattr(self.form, 'fieldsets')\n response_fieldsets = self.form.make_fieldsets()\n print(response_fieldsets)\n\n setattr(self.form, 'fieldsets', original_initial_fieldsets)",
"def test_make_fieldsets_outcome_order(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'position': None,\n 'fields': [\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n fieldsets[0], fieldsets[1] = fieldsets[1], fieldsets[0]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def get_fieldsets(self, request, obj=None):\n if obj:\n return self._change_fieldsets\n return self._add_fieldsets",
"def test_computed_fieldsets_structure(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n self.form.make_fieldsets()\n fieldsets = self.form._fieldsets\n each_are_tuples = (isinstance(ea, tuple) for ea in fieldsets)\n correct_fieldset_labels = (isinstance(label, (str, type(None))) for label, opts in fieldsets)\n opts_are_dictionaries = (isinstance(opts, dict) for label, opts in fieldsets)\n required_keys = {'position', 'fields', 'field_names', 'rows', 'column_count', }\n optional_keys = {'classes', 'modifiers', 'row_data', }\n allowed_keys = required_keys | optional_keys\n opt_keys = set(flatten([list(opts.keys()) for lbl, opts, in fieldsets]))\n unaccepted_keys = [key for key in opt_keys if key not in allowed_keys]\n has_required = (all(key in opts for key in required_keys) for lbl, opts in fieldsets)\n self.assertIsInstance(fieldsets, list)\n self.assertTrue(all(each_are_tuples))\n self.assertTrue(all(correct_fieldset_labels))\n self.assertTrue(all(opts_are_dictionaries))\n self.assertEqual(len(unaccepted_keys), 0)\n self.assertFalse(unaccepted_keys)\n self.assertTrue(all(has_required))\n\n self.form.fieldsets = original_fieldsets",
"def get_fieldsets(self, request, obj=None):\n return (\n ('Name', {\n 'fields': (\n ('first_name', 'last_name'),)\n }),\n ('IPI', {\n 'fields': (\n ('ipi_name', 'ipi_base'),),\n }),\n ('Societies', {\n 'fields': (\n self.get_society_list(),),\n }),\n ('General agreement', {\n 'fields': (\n ('generally_controlled',\n ('saan', 'publisher_fee'))\n ),\n }),\n )",
"def test_make_fieldsets_uses_handle_modifiers(self):\n original_called_handle_modifiers = self.form.called_handle_modifiers = False\n full_fieldsets = self.form.make_fieldsets()\n\n self.assertFalse(original_called_handle_modifiers)\n self.assertIsInstance(full_fieldsets, (list, tuple))\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n self.assertTrue(self.form.called_handle_modifiers)\n\n self.form.called_handle_modifiers = original_called_handle_modifiers",
"def get_fieldsets(self, request, obj=None):\n if obj:\n return (('Corporate Burn Attribute Summary', {\n \"fields\": ('name', 'description', ('financial_year', 'planned_season'),\n ('last_year', 'last_season',\n 'last_year_unknown', 'last_season_unknown'),\n 'region', 'district', 'location',\n 'forest_blocks',\n ('priority', 'rationale'),\n ('contentious', 'contentious_rationale'),\n 'aircraft_burn',\n # TODO: PBS-1551 # 'allocation',\n 'remote_sensing_priority', 'purposes',\n ('area', 'perimeter', 'treatment_percentage'),\n ('non_calm_tenure','non_calm_tenure_approved','non_calm_tenure_included','non_calm_tenure_value','non_calm_tenure_complete','non_calm_tenure_risks')\n )\n }), ('Other Attributes', {\n \"fields\": ('tenures', 'fuel_types', 'shires',\n 'bushfire_act_zone', 'prohibited_period',\n 'forecast_areas', 'prescribing_officer',\n 'short_code')\n }))\n else:\n return super(PrescriptionAdmin, self).get_fieldsets(request, obj)",
"def get_fieldsets(model):\n fieldsets = getattr(model, 'report_builder_fieldsets', None)\n if fieldsets:\n for fieldset_name, fieldset_dict in model.report_builder_fieldsets:\n fieldset_string_to_field(fieldset_dict, model)\n return fieldsets",
"def test_no_empty_sets_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n ('Non_Fields', {\n 'position': 2,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 2)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def get_fieldsets(self, request, obj=None):\n if not obj:\n return self.fieldsets_without_readonly\n return super().get_fieldsets(request, obj=obj)",
"def get_fieldsets(self, request, obj=None):\n if request.user.user_type == User.ADMIN_CEA:\n return self.cea_fieldsets\n elif request.user.user_type == User.ADMIN_CRC:\n return self.crc_fieldsets\n elif request.user.user_type == User.EXPRESS_USER:\n return self.exp_fieldsets\n return self.fieldsets",
"def test_no_empty_rows_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_a_field',\n ('last_name', 'another_field', ),\n ('first_name', 'non-field_name', ),\n 'generic_field',\n 'last',\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: remaining_fields.pop(name) for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 3)\n self.assertEqual(len(fieldsets[1][1]['rows']), 4)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def _generate_formset_class(\n request, model, modelfield, baseformclass, formsetfieldelement\n):\n\n formfieldelements = _get_form_fields_from_layout(\n _layout.BaseElement(*formsetfieldelement)\n ) # make sure the _layout.form.FormSetField does not be considered recursively\n\n formclass = breadmodelform_factory(\n request=request,\n model=modelfield.related_model,\n layout=formfieldelements,\n instance=None,\n baseformclass=baseformclass,\n )\n\n base_formset_kwargs = {\n \"fields\": [\n formfieldelement.fieldname for formfieldelement in formfieldelements\n ],\n \"form\": formclass,\n \"extra\": 0,\n \"can_delete\": True,\n }\n base_formset_kwargs.update(formsetfieldelement.formsetfactory_kwargs)\n if isinstance(modelfield, GenericRelation):\n return generic_inlineformset_factory(\n modelfield.related_model,\n ct_field=modelfield.content_type_field_name,\n fk_field=modelfield.object_id_field_name,\n formset=InlineFormSetWithLimits,\n formfield_callback=lambda field: _formfield_callback_with_request(\n field, request, modelfield.related_model\n ),\n **base_formset_kwargs,\n )\n else:\n return forms.models.inlineformset_factory(\n model,\n modelfield.related_model,\n formset=InlineFormSetWithLimits,\n formfield_callback=lambda field: _formfield_callback_with_request(\n field, request, model\n ),\n **base_formset_kwargs,\n )",
"def get_fieldsets(self, request, obj=None):\n base_fields = (\n None, {\n 'fields': ASCreationForm.Meta.fields\n }\n )\n host_ip_fields = (\n 'Host IPs', {\n 'fields': ('internal_ip', 'public_ip', 'bind_ip', )\n }\n )\n key_fields = (\n 'Keys & Certificates', {\n 'classes': ('collapse',),\n 'fields': (\n 'master_as_key',\n )\n }\n )\n if not obj:\n return (base_fields, host_ip_fields)\n return (base_fields, key_fields)",
"def get_model_as_formset(self, client_id):\n # Basement\n formset = {\n 'form-TOTAL_FORMS': str(len(self.storage)),\n 'form-INITIAL_FORMS': u'0',\n }\n # Fill the formset\n for record_index, record in enumerate(self.storage):\n prefix = 'form-%i' % record_index\n row = {'%s-client' % prefix: client_id,}\n for model_index, model_row in enumerate(MODEL_MAP_RAW):\n name, delegate, title, action, static = model_row\n key = '%s-%s' % (prefix, name)\n value = record[model_index]\n value_t = type(value)\n\n if value is None: # send None as empty string\n value = str()\n elif value_t is datetime:\n value = dt2str(value)\n elif value_t is date:\n value = date2str(value)\n elif value_t in (int, float):\n value = str(value)\n elif value_t is dict:\n if 'id' in value:\n value = value['id']\n else:\n value = 'no id found'\n\n row.update( {key: value} )\n formset.update( row )\n return formset",
"def get_fieldsets(self, default):\n default = default + ['-']\n\n last = None\n fields = []\n for perm in self.__permissions_to_manage():\n if last != perm.content_type:\n if fields:\n default = default + ['h3:'+last.model_class()._meta.verbose_name_plural, segment(chunks(fields, 4))]\n last = perm.content_type\n fields = []\n\n fields = fields + [perm.codename]\n\n default = default + ['h3:'+last.model_class()._meta.verbose_name_plural, segment(chunks(fields, 4))]\n return default",
"def get_formset(self):\n result = generic_inlineformset_factory(\n self.inline_model, **self.get_factory_kwargs()\n )\n return result",
"def test_make_fieldsets_names_can_be_coded(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n (None, {\n 'position': 1,\n 'fields': [\n ('first', 'second', ),\n ('_name_for_coded', 'last', ),\n ],\n }),\n ('Your Name', {\n 'position': 2,\n 'fields': [('first_name', 'last_name', )],\n }), )\n self.form.fieldsets = test_fieldsets\n expected_name = self.form.name_for_coded\n self.form.make_fieldsets()\n computed_fieldsets = self.form._fieldsets\n opts = computed_fieldsets[0][1]\n target = opts['rows'][1]\n self.assertIn(expected_name, target.keys())\n self.assertEqual(self.form.fields.get(expected_name), target.get(expected_name, ''))\n self.assertIn('_name_for_coded', opts['field_names'])\n\n self.form.fieldsets = original_fieldsets",
"def test_construct_fieldset_tag(attributes):\n fset = FieldSet(**attributes)\n assert fset.construct() == fieldset.render(attributes)",
"def get_formset(self, **kwargs):\n return self.formsets[kwargs.get('prefix')](\n data=self.get_form_kwargs().get('data'),\n **kwargs\n )",
"def test_as_fieldset(self):\n # form._html_output(self, row_tag, col_head_tag, col_tag, single_col_tag, col_head_data, col_data,\n # help_text_br, errors_on_separate_row, as_type=None, strict_columns=False)\n pass",
"def test_form_main_rows_all_fieldsets_has_container(self):\n # form.form_main_rows(self, html_args, fieldsets, form_col_count)\n # html_args = (row_tag, col_head_tag, col_tag, single_col_tag, as_type, all_fieldsets)\n pass",
"def getFormFields(self, request, fieldSet = None):\n fields = []\n if fieldSet is None:\n fieldSet = self.formFields\n if not self.shouldProcess(request):\n return fieldSet\n\n for field in fieldSet:\n if len(field)==5:\n inputType, displayName, inputName, inputValue, description = field\n else:\n inputType, displayName, inputName, inputValue = field\n description = \"\"\n\n if inputType == 'checkbox':\n if request.args.has_key('__checkboxes__'):\n if inputName in request.args['__checkboxes__']:\n inputValue = 1\n else:\n inputValue = 0\n else:\n inputValue = 0\n elif inputType in ('checkgroup', 'radio'):\n if request.args.has_key(inputName):\n keys = request.args[inputName]\n else:\n keys = []\n iv = inputValue\n inputValue = []\n for optionName, optionDisplayName, checked in iv:\n checked = optionName in keys\n inputValue.append([optionName, optionDisplayName, checked])\n elif request.args.has_key(inputName):\n iv = request.args[inputName][0]\n if inputType in ['menu', 'multimenu']:\n if iv in inputValue:\n inputValue.remove(iv)\n inputValue.insert(0, iv)\n else:\n inputValue = iv\n fields.append([inputType, displayName, inputName, inputValue, description])\n return fields",
"def test_form_main_rows_all_fieldsets(self):\n # form.form_main_rows(self, html_args, fieldsets, form_col_count)\n # html_args = (row_tag, col_head_tag, col_tag, single_col_tag, as_type, all_fieldsets)\n pass",
"def list(self, request, *args, **kwargs):\n fields = request.GET.get(\"fields\")\n query = request.GET.get(\"query\", {})\n sort = request.GET.get(\"sort\")\n start = parse_int(request.GET.get(\"start\"))\n limit = parse_int(request.GET.get(\"limit\"))\n export_type = kwargs.get(\"format\", request.GET.get(\"format\"))\n lookup_field = self.lookup_field\n lookup = self.kwargs.get(lookup_field)\n is_public_request = lookup == self.public_data_endpoint\n\n if lookup_field not in list(kwargs):\n # pylint: disable=attribute-defined-outside-init\n self.object_list = self.filter_queryset(self.get_queryset())\n serializer = self.get_serializer(self.object_list, many=True)\n\n return Response(serializer.data)\n\n if is_public_request:\n # pylint: disable=attribute-defined-outside-init\n self.object_list = self._get_public_forms_queryset()\n elif lookup:\n queryset = self.filter_queryset(self.get_queryset()).values_list(\n \"pk\", \"is_merged_dataset\"\n )\n xform_id, is_merged_dataset = queryset[0] if queryset else (lookup, False)\n pks = [xform_id]\n if is_merged_dataset:\n merged_form = MergedXForm.objects.get(pk=xform_id)\n queryset = merged_form.xforms.filter(\n deleted_at__isnull=True\n ).values_list(\"id\", \"num_of_submissions\")\n try:\n pks, num_of_submissions = [list(value) for value in zip(*queryset)]\n num_of_submissions = sum(num_of_submissions)\n except ValueError:\n pks, num_of_submissions = [], 0\n else:\n num_of_submissions = XForm.objects.get(id=xform_id).num_of_submissions\n # pylint: disable=attribute-defined-outside-init\n self.object_list = Instance.objects.filter(\n xform_id__in=pks, deleted_at=None\n ).only(\"json\")\n\n # Enable ordering for XForms with Submissions that are less\n # than the SUBMISSION_RETRIEVAL_THRESHOLD\n if num_of_submissions < SUBMISSION_RETRIEVAL_THRESHOLD:\n # pylint: disable=attribute-defined-outside-init\n self.object_list = self.object_list.order_by(\"id\")\n\n xform = self.get_object()\n # pylint: disable=attribute-defined-outside-init\n self.object_list = filter_queryset_xform_meta_perms(\n xform, request.user, self.object_list\n )\n tags = self.request.query_params.get(\"tags\")\n not_tagged = self.request.query_params.get(\"not_tagged\")\n\n # pylint: disable=attribute-defined-outside-init\n self.object_list = filters.InstanceFilter(\n self.request.query_params, queryset=self.object_list, request=request\n ).qs\n\n if tags and isinstance(tags, six.string_types):\n tags = tags.split(\",\")\n self.object_list = self.object_list.filter(tags__name__in=tags)\n if not_tagged and isinstance(not_tagged, six.string_types):\n not_tagged = not_tagged.split(\",\")\n self.object_list = self.object_list.exclude(tags__name__in=not_tagged)\n\n if (\n export_type is None or export_type in [\"json\", \"jsonp\", \"debug\", \"xml\"]\n ) and hasattr(self, \"object_list\"):\n return self._get_data(query, fields, sort, start, limit, is_public_request)\n\n xform = self.get_object()\n kwargs = {\"instance__xform\": xform}\n\n if export_type == Attachment.OSM:\n if request.GET:\n self.set_object_list(\n query, fields, sort, start, limit, is_public_request\n )\n kwargs = {\"instance__in\": self.object_list}\n osm_list = OsmData.objects.filter(**kwargs).order_by(\"instance\")\n page = self.paginate_queryset(osm_list)\n serializer = self.get_serializer(page)\n\n return Response(serializer.data)\n\n if export_type is None or export_type in [\"json\"]:\n # perform default viewset retrieve, no data export\n return super().list(request, *args, **kwargs)\n\n if export_type == \"geojson\":\n # raise 404 if all instances dont have geoms\n if not xform.instances_with_geopoints and not (\n xform.polygon_xpaths() or xform.geotrace_xpaths()\n ):\n raise Http404(_(\"Not Found\"))\n\n # add pagination when fetching geojson features\n page = self.paginate_queryset(self.object_list)\n serializer = self.get_serializer(page, many=True)\n\n return Response(serializer.data)\n\n return custom_response_handler(request, xform, query, export_type)",
"def parse(self, response):\n yield from self.all_forms(response)",
"def grouped_formset_factory(leafpack=None, taxon_forms=None):\n groupedform_list = []\n groupRS= LeafPackSensitivityGroup.objects.all()\n\n for gr in groupRS:\n\n groupRS = Macroinvertebrate.objects.filter(displayflag= True, sens_group=gr).order_by('display_order')\n bug_forms=[]\n for taxon in groupRS:\n if leafpack is not None:\n try:\n lpg = LeafPackBug.objects.get(bug=taxon.id, leaf_pack=leafpack.id)\n except ObjectDoesNotExist:\n lpg = LeafPackBug(bug=taxon, leaf_pack=leafpack)\n lpg.save()\n else:\n lpg = LeafPackBug(bug=taxon)\n \n bug_form = LeafPackBugForm(instance=lpg)\n bug_forms.append(bug_form)\n \n group ={}\n group['name']= 'Group {0}: {1}'.format(str(gr.id), gr.name)\n group['list']= bug_forms\n groupedform_list.append(group)\n\n # If taxon_forms is not None, plug bug_count values into new formset\n if taxon_forms is not None:\n\n def get_taxon_count(taxon_):\n for tf in taxon_forms:\n if tf.instance.bug == taxon_:\n return tf.instance.bug_count\n return 0\n\n for forms_ in taxon_forms:\n forms_[0].initial['bug_count'] = get_taxon_count(forms_[0].instance.bug)\n\n for form in forms_[1]:\n form.initial['bug_count'] = get_taxon_count(form.instance.bug)\n\n return groupedform_list",
"def test_no_duplicate_fields_in_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n ('Confused', {\n 'position': 3,\n 'fields': [\n ('first_name', 'generic_field', ),\n 'first',\n 'last',\n ],\n }), )\n duplicates = set(('first_name', 'first', 'last', ))\n expected = []\n for names in test_fieldsets[2][1]['fields']:\n if isinstance(names, str):\n names = (names, )\n names = [name for name in names if name not in duplicates]\n if names:\n expected.append({name: self.form.fields[name] for name in names})\n self.form.fieldsets = deepcopy(test_fieldsets)\n self.form.make_fieldsets()\n computed_fieldsets = self.form._fieldsets\n opts = computed_fieldsets[2][1]\n actual = opts['rows']\n\n self.assertEqual(1, len(actual), \"Rows of already used fields were added. \")\n self.assertEqual(1, len(actual[0]), \"Columns of already used fields were added. \")\n self.assertEqual(expected, actual)\n for lbl, opts in computed_fieldsets[:2]:\n row_names = flatten([list(row.keys()) for row in opts['rows']])\n self.assertEqual(opts['field_names'], row_names, \"Field missing from its expected first fieldset. \")\n\n self.form.fieldsets = original_fieldsets"
] | [
"0.71624404",
"0.61265737",
"0.6096746",
"0.60655487",
"0.6024743",
"0.59263253",
"0.59168625",
"0.5904047",
"0.58811647",
"0.58270705",
"0.58269846",
"0.563818",
"0.5591763",
"0.55192465",
"0.53909874",
"0.53210807",
"0.5267671",
"0.5244225",
"0.521522",
"0.5199726",
"0.5155622",
"0.5101782",
"0.50449324",
"0.5008828",
"0.49708542",
"0.49635583",
"0.49624848",
"0.4943727",
"0.49322954",
"0.4896657"
] | 0.61366403 | 1 |
The column_formats method returns the column and single_column strings with formatting placeholders. | def test_column_formats(self):
attrs = '%(html_col_attr)s'
col_tag = 'span'
single_col_tag = ''
col_data = '%(errors)s%(label)s %(field)s%(help_text)s'
expected_col = self.form._html_tag(col_tag, col_data, attrs)
expected_single = col_data if not single_col_tag else self.form._html_tag(single_col_tag, col_data, attrs)
actual_col, actual_single = self.form.column_formats(None, col_tag, single_col_tag, '', col_data)
self.assertEqual(expected_col, actual_col)
self.assertEqual(expected_single, actual_single) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_column_formats(self):\n image_columns = self.image_column_nums()\n formats = [self.column_formats[i] if i not in image_columns else '%h' for i in range(len(self.column_formats))]\n return formats[1:-2]",
"def format_column(self, column, use_table=False, name=None, table_name=None):\n if name is None:\n name = column.name\n if not getattr(column, 'is_literal', False):\n if use_table:\n return self.format_table(column.table, use_schema=False, name=table_name) + \".\" + self.__generic_obj_format(column, name)\n else:\n return self.__generic_obj_format(column, name)\n else:\n # literal textual elements get stuck into ColumnClause alot, which shouldnt get quoted\n if use_table:\n return self.format_table(column.table, use_schema=False, name=table_name) + \".\" + name\n else:\n return name",
"def update_column_format(self):\n pass",
"def __makeFormatString(self):\n self.__formatString = \"\"\n for f in self.__columns:\n self.__formatString += \"%(\"+ f + \")-\" + str(self.__widths[f]) + \\\n \"s \"",
"def formats(self):\n if getattr(self, \"_coldefs\", None) is not None:\n return self._coldefs.formats\n\n return None",
"def get_column_formatters(df):\n formatters = {}\n for p in df.columns:\n (a, b) = p\n if b.endswith(\"Q\"):\n formatters[p] = lambda x: \"%.2f\" % x\n elif b.startswith(\"T_\"):\n formatters[p] = lambda x: \"%.1f\" % x\n else:\n formatters[p] = lambda x: \"%.0f\" % x\n return formatters",
"def getRuntimeColFmts(col_name, table, fmt_type):\n\n # the only string-type data displayed is at the end of the row\n # so it doesn't require any special formatting\n column_fmt = '{0}'\n number_fmt = '{0}'\n\n if fmt_type == 'str':\n return (column_fmt, number_fmt)\n\n # for numerical data, compare the length of the column name\n # to the length of the largest (in characters) number.\n name_width = len(col_name)\n\n # the \"largest\" number could be negative, so check both max and min\n i = COL_NAMES.index(col_name)\n max_val = max(table, key=lambda row: row[i] if row[i] is not None else 0)[i]\n min_val = min(table, key=lambda row: row[i] if row[i] is not None else 0)[i]\n\n try:\n max_width = len('{0:d}'.format(int(max_val)))\n except TypeError:\n max_width = 0\n\n try:\n min_width = len('{0:d}'.format(int(min_val)))\n except TypeError:\n min_width = 0\n\n n_width = max([max_width, min_width])\n\n # for floats, we want the largest number of decimal places\n # that we can get away with without needlessly expanding the column size\n if fmt_type in ['float', 'floatneg']:\n\n # add one to the length of columns that could have negative numbers\n if fmt_type == 'floatneg':\n n_width += 1 \n\n # compare against max int length + 1 because of decimal point\n if (n_width + 1) < name_width:\n decimals = name_width - (n_width + 1)\n n_width = (n_width + decimals + 1)\n else:\n decimals = 0\n\n col_width = max([n_width, name_width])\n\n column_fmt = '{0:>%ds}' % (col_width,)\n number_fmt = '{0:>%d.%df}' % (col_width, decimals)\n\n # for integers, we just need to make sure that we aren't needlessly\n # expanding the column size unless the numbers are really large\n if fmt_type == 'int':\n col_width = max([n_width, name_width])\n\n column_fmt = '{0:>%ds}' % (col_width,)\n number_fmt = '{0:>%dd}' % (col_width,)\n\n return (column_fmt, number_fmt)",
"def format_cols(met,format_columns_sp,format_columns_dp, format_columns_tp):\n emp_list = []\n #format_columns = ['ISO','BABIP','AVG', 'OBP', 'SLG','wOBA']\n for item in met:\n if item in format_columns_sp or item in format_columns_dp or item in format_columns_tp:\n emp_list.append(item)\n\n if not emp_list:\n return [{\"name\": i, \"id\": i} for i in met]\n else:\n ret_list = []\n for item in met:\n if item in format_columns_sp:\n ret_list.append({\"name\": item, \"id\": item, \"type\":\"numeric\", \"format\":Format(precision=1, scheme=Scheme.fixed)})\n elif item in format_columns_dp:\n ret_list.append({\"name\": item, \"id\": item, \"type\":\"numeric\", \"format\":Format(precision=2, scheme=Scheme.fixed)})\n elif item in format_columns_tp:\n ret_list.append({\"name\": item, \"id\": item, \"type\":\"numeric\", \"format\":Format(precision=3, scheme=Scheme.fixed)})\n else:\n ret_list.append({\"name\": item, \"id\": item})\n\n return ret_list",
"def format_column(cls, label, column, min_width=min_val_width, max_width=max_val_width, etc=' ...'):\n val_width = 0 if len(column) == 0 else max(len(cls.format_value(v)) for v in column)\n val_width = min(val_width, max_width)\n width = max(val_width, len(str(label)), min_width, len(etc))\n def pad(value):\n raw = cls.format_value(value)\n if len(raw) > width:\n prefix = raw[:width-len(etc)] + etc\n else:\n prefix = raw\n return prefix.ljust(width)\n return pad",
"def format_column(data,col_num):\n assert isinstance(col_num,int) and col_num>=0\n \n if col_num in [0,1,11,13,14,15,16,17,19,20,21,28,31,45,46,47,48]: return data #emptry string will NOT return None\n if col_num in [2,3,12,18]: return type_cast(lambda x: int(float(x)),data)\n if col_num in [6,7,8,9,10,23,24,25,26,27,29,30]: return type_cast(float,data)\n if col_num in [4,5,22]: return type_cast(datetime.strptime,data,'%Y-%m-%d %H:%M:%S')\n if col_num in range(32,45):\n if data=='False': return False #bool('False') returns True!\n elif data=='True': return True\n else: return None",
"def _col_format(a, nme=\"fld\", deci=0):\n a_kind = a.dtype.kind\n a_nm = nme\n if a_kind in ('i', 'u'): # integer type\n w_, m_ = [':> {}.0f', '{:> 0.0f}']\n col_wdth = len(m_.format(a.max())) + 1\n col_wdth = max(len(a_nm), col_wdth) + 1 # + deci\n c_fmt = w_.format(col_wdth, 0)\n # print(\"name {} c_fmt {}, wdth {}\".format(a_nm, c_fmt, col_wdth))\n elif a_kind == 'f' and np.isscalar(a[0]): # float type with rounding\n w_, m_ = [':> {}.{}f', '{:> 0.{}f}']\n a_max, a_min = np.round(np.sort(a[[0, -1]]), deci)\n col_wdth = max(len(m_.format(a_max, deci)),\n len(m_.format(a_min, deci))) + 1\n col_wdth = max(len(a_nm), col_wdth) + 1\n c_fmt = w_.format(col_wdth, deci)\n else: # lists, arrays, strings\n col_wdth = max([len(str(i)) for i in a])\n col_wdth = max(len(a_nm), col_wdth) + 1 # + deci\n c_fmt = \"!s:>\" + \"{}\".format(col_wdth)\n return c_fmt, col_wdth",
"def test_column_formats_col_head_tag(self):\n col_head_tag = 'th'\n col_tag = 'td'\n single_col_tag = col_tag\n col_head_data = '%(label)s'\n col_data = '%(errors)s%(field)s%(help_text)s'\n head_html = self.form._html_tag(col_head_tag, col_head_data, '%(html_head_attr)s')\n base_col_html = self.form._html_tag(col_tag, col_data, '%(html_col_attr)s')\n expected_html = head_html + base_col_html\n args = (col_head_tag, col_tag, single_col_tag, col_head_data, col_data)\n col_html, single_col_html = self.form.column_formats(*args)\n\n self.assertEqual(expected_html, col_html)\n self.assertEqual(expected_html, single_col_html)",
"def _add_column_and_format(self, table, label, column):\n table[label] = column\n if label in self._formats:\n table.set_format(label, self._formats[label])",
"def format_column_with_table(self, column, column_name=None, table_name=None):\n \n return self.format_column(column, use_table=True, name=column_name, table_name=table_name)",
"def test_provide_column_types():\n expected_column_types = (bool, float)\n data = ((1, 1.0), (0, 2))\n headers = (\"a\", \"b\")\n\n def preprocessor(data, headers, column_types=(), **_):\n assert expected_column_types == column_types\n return data, headers\n\n format_output(\n data,\n headers,\n \"csv\",\n column_types=expected_column_types,\n preprocessors=(preprocessor,),\n )",
"def justify_column(column):\n formatted_strings = ['{:,.3f}'.format(v) for v in column]\n justify = len(max(formatted_strings, key=len))\n column_strings = [s.rjust(justify) for s in formatted_strings]\n return (column_strings, justify)",
"def format_col(values, num_decimal=3):\n new_vals = []\n for val in values:\n if np.isnan(val):\n new_val = NA_REP\n elif isinstance(val, numbers.Number):\n new_val = text_util.format_num(val, num_decimal=num_decimal)\n else:\n new_val = val\n new_vals.append(new_val)\n\n return new_vals",
"def getFormat(headings):\n Indent = 4\n DescWid = 20\n ColWid = 12\n\n # figure out how wide our columns have to be\n wid = 0\n for s in headings:\n if len(s) > wid:\n wid = len(s)\n if wid >= ColWid:\n ColWid = wid + 1\n\n # generate the format string\n f = \"\"\n i = 0\n while i < Indent:\n f += ' '\n i += 1\n\n col = 0\n while col < len(headings):\n wid = DescWid if col == 0 else ColWid\n f += '%'\n if col == 0:\n f += \"-%ds\" % wid\n else:\n f += \"%ds\" % wid\n col += 1\n return f",
"def columnBinder(dataSet, colIndex): \n \n if len(colIndex) == 0:\n return dataSet[dataSet.columns].apply(lambda x:\n ' '.join(x.dropna().astype(str)),axis=1 )\n else:\n col = [int(dd)-1 for dd in colIndex.split(',') ]\n return dataSet[dataSet.columns[col]].apply(lambda x:\n ' '.join(x.dropna().astype(str)),axis=1 )",
"def get_column_def(self):\r\n return '{} {}'.format(self.cql, self.db_type)",
"def get_column_def(self):\r\n db_type = self.db_type.format(self.value_type.db_type)\r\n return '{} {}'.format(self.cql, db_type)",
"def get_column_def(self):\r\n db_type = self.db_type.format(\r\n self.key_type.db_type,\r\n self.value_type.db_type\r\n )\r\n return '{} {}'.format(self.cql, db_type)",
"def test_format(self):\n MAX_LINES_val = pprint.MAX_LINES()\n pprint.MAX_LINES.set(7)\n c1 = Column(name='a', data=np.arange(2000), dtype=float,\n format='%6.2f')\n assert str(c1) == (' a \\n-------\\n 0.00\\n'\n ' 1.00\\n ...\\n1998.00\\n1999.00')\n pprint.MAX_LINES.set(MAX_LINES_val)",
"def get_formatted_text(self, n_cols):",
"def get_columns_display(self):\n columns = []\n for column in self.columns:\n if None != column.display.name:\n columns.append(column.display.name)\n else:\n columns.append(column.data.name)\n return columns",
"def __format__(self, formatstr):\n return self.df.__format__(formatstr)",
"def _format_column(self, row_data):\n return [[row[i] for row in row_data] for i in range(self.row_length)]",
"def get_column_info(config):\n columns = config.view.columns\n colnames = dict(zip(columns, list(s.replace(\"_\", \" \") for s in columns)))\n colnames.update(config.view.colnames)\n column = config.view.column\n return columns, colnames, column",
"def get_fixed_regex(self):\n import re\n\n pos = 0\n regex = ''\n header = []\n\n for col in self.columns:\n\n size = col.width if col.width else col.size\n\n if not size:\n continue\n\n pos += size\n\n regex += \"(.{{{}}})\".format(size)\n header.append(col.name)\n\n return header, re.compile(regex), regex",
"def info(self):\n # define the return string\n bigstring = ''\n\n # assemble the information on the column\n bigstring += 'Column name: ' + self.colname + '\\n'\n bigstring += 'Column type: ' + str(self._type) + '\\n'\n bigstring += 'Column format: ' + str(self._format) + '\\n'\n bigstring += 'Column null value : ' + str(self._null) + '\\n'\n if self.unit:\n bigstring += 'Column unit : ' + self.unit + '\\n'\n if self.colcomment:\n bigstring += 'Column comment : ' + self.colcomment + '\\n'\n\n # return the result\n return bigstring"
] | [
"0.6807568",
"0.6566808",
"0.63878995",
"0.6377883",
"0.6346472",
"0.6292111",
"0.62664866",
"0.62439483",
"0.6219398",
"0.60932344",
"0.5966978",
"0.58984876",
"0.58768934",
"0.5819751",
"0.57350343",
"0.57184577",
"0.5713034",
"0.5690501",
"0.5494927",
"0.545833",
"0.54567343",
"0.5425671",
"0.53888977",
"0.5339053",
"0.5324369",
"0.53122646",
"0.5296634",
"0.52897453",
"0.5279224",
"0.520942"
] | 0.7047156 | 0 |
The column_formats method, when col_head_tag is present, returns the expected response. | def test_column_formats_col_head_tag(self):
col_head_tag = 'th'
col_tag = 'td'
single_col_tag = col_tag
col_head_data = '%(label)s'
col_data = '%(errors)s%(field)s%(help_text)s'
head_html = self.form._html_tag(col_head_tag, col_head_data, '%(html_head_attr)s')
base_col_html = self.form._html_tag(col_tag, col_data, '%(html_col_attr)s')
expected_html = head_html + base_col_html
args = (col_head_tag, col_tag, single_col_tag, col_head_data, col_data)
col_html, single_col_html = self.form.column_formats(*args)
self.assertEqual(expected_html, col_html)
self.assertEqual(expected_html, single_col_html) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_column_formats(self):\n attrs = '%(html_col_attr)s'\n col_tag = 'span'\n single_col_tag = ''\n col_data = '%(errors)s%(label)s %(field)s%(help_text)s'\n expected_col = self.form._html_tag(col_tag, col_data, attrs)\n expected_single = col_data if not single_col_tag else self.form._html_tag(single_col_tag, col_data, attrs)\n actual_col, actual_single = self.form.column_formats(None, col_tag, single_col_tag, '', col_data)\n self.assertEqual(expected_col, actual_col)\n self.assertEqual(expected_single, actual_single)",
"def get_column_formats(self):\n image_columns = self.image_column_nums()\n formats = [self.column_formats[i] if i not in image_columns else '%h' for i in range(len(self.column_formats))]\n return formats[1:-2]",
"def formats(self):\n if getattr(self, \"_coldefs\", None) is not None:\n return self._coldefs.formats\n\n return None",
"def test_provide_column_types():\n expected_column_types = (bool, float)\n data = ((1, 1.0), (0, 2))\n headers = (\"a\", \"b\")\n\n def preprocessor(data, headers, column_types=(), **_):\n assert expected_column_types == column_types\n return data, headers\n\n format_output(\n data,\n headers,\n \"csv\",\n column_types=expected_column_types,\n preprocessors=(preprocessor,),\n )",
"def __get_header_tags(self):\n tag = \"<th>{}</th>\"\n\n return (tag * len(self.__rows)).format(*self.__rows)",
"def _generateColumnHeader(self, obj, **args):\n result = []\n header = self._script.utilities.columnHeaderForCell(obj)\n if not header:\n return result\n\n text = self._script.utilities.displayedText(header)\n if not text:\n return result\n\n roleString = self.getLocalizedRoleName(obj, pyatspi.ROLE_COLUMN_HEADER)\n if args.get('mode') == 'speech':\n if settings.speechVerbosityLevel == settings.VERBOSITY_LEVEL_VERBOSE \\\n and not args.get('formatType') in ['basicWhereAmI', 'detailedWhereAmI']:\n text = \"%s %s\" % (text, roleString)\n elif args.get('mode') == 'braille':\n text = \"%s %s\" % (text, roleString)\n\n result.append(text)\n return result",
"def update_column_format(self):\n pass",
"def format_cols(met,format_columns_sp,format_columns_dp, format_columns_tp):\n emp_list = []\n #format_columns = ['ISO','BABIP','AVG', 'OBP', 'SLG','wOBA']\n for item in met:\n if item in format_columns_sp or item in format_columns_dp or item in format_columns_tp:\n emp_list.append(item)\n\n if not emp_list:\n return [{\"name\": i, \"id\": i} for i in met]\n else:\n ret_list = []\n for item in met:\n if item in format_columns_sp:\n ret_list.append({\"name\": item, \"id\": item, \"type\":\"numeric\", \"format\":Format(precision=1, scheme=Scheme.fixed)})\n elif item in format_columns_dp:\n ret_list.append({\"name\": item, \"id\": item, \"type\":\"numeric\", \"format\":Format(precision=2, scheme=Scheme.fixed)})\n elif item in format_columns_tp:\n ret_list.append({\"name\": item, \"id\": item, \"type\":\"numeric\", \"format\":Format(precision=3, scheme=Scheme.fixed)})\n else:\n ret_list.append({\"name\": item, \"id\": item})\n\n return ret_list",
"def format_report_header(self):",
"def columnTitles(self):\n \n pass",
"def columnTitles(self):\n \n pass",
"def _format_header(self):\n return self._format_dict(self.header)",
"def format_header(self, header):\n raise NotImplementedError()",
"def _get_table_columns(self):\n try:\n table_header = parse_table_head(self.table.value, version=self.version)\n merged_data = self.table.value[table_header.tdef_header_end:]\n if table_header.TDEF_header.next_page_ptr:\n merged_data = merged_data + self._merge_table_data(table_header.TDEF_header.next_page_ptr)\n\n parsed_data = parse_table_data(merged_data, table_header.real_index_count,\n table_header.column_count, version=self.version)\n\n # Merge Data back to table_header\n table_header['column'] = parsed_data['column']\n table_header['column_names'] = parsed_data['column_names']\n\n except ConstructError:\n logging.error(f\"Failed to parse table header {self.table.value}\")\n return\n col_names = table_header.column_names\n columns = table_header.column\n\n # Add names to columns metadata so we can use only columns for parsing\n for i, c in enumerate(columns):\n c.col_name_str = col_names[i].col_name_str\n\n # column_index is more accurate(id is always incremented so it is wrong when a column is deleted).\n # Some tables like the catalog don't have index, so if indexes are 0 use id.\n\n # create a dict of index to column to make it easier to access. offset is used to make this zero based\n offset = min(x.column_index for x in columns)\n column_dict = {x.column_index - offset: x for x in columns}\n # If column index is not unique try best effort\n if len(column_dict) != len(columns):\n # create a dict of id to column to make it easier to access\n column_dict = {x.column_id: x for x in columns}\n\n if len(column_dict) != table_header.column_count:\n logging.debug(f\"expected {table_header.column_count} columns got {len(column_dict)}\")\n return column_dict, table_header",
"def construct_report_columns(self):\n return \"Date,Status\"",
"def col_headers(self):\n return \"i_site_domain\\ti_batch_num\\ti_instance_num\\t\"\\\n \"i_visit_success\\tmed_num_http_req\\t\"\\\n \"med_num_http_resp\\tmed_total_http_download\\t\"\\\n \"med_total_http_upload\\t\"\\\n \"i_total_incoming_tcp_data\\ti_total_outgoing_tcp_data\\t\"\\\n \"med_http_duration\\t\"\\\n \"i_tshark_duration\\ti_screenshot_hash\\t\"\\\n \"i_html_src_hash\\ti_pcap_size\\tmed_html_src_size\\t\"\\\n \"med_screenshot_size\\ti_page_title\\t\"\\\n \"i_html_src_simhash\\ti_begin_time\\tmed_num_domains\\t\"\\\n \"med_num_redirs\\tmed_num_scripts\\tmed_num_stylesheets\\tmed_num_htmls\\t\"\\\n \"med_num_images\\tmed_num_videos\\tmed_num_audios\\tmed_num_fonts\\t\"\\\n \"med_num_other_content\\tmed_num_empty_content\\ti_time_to_first_byte\\t\"\\\n \"med_num_waterfall_phases\\t\"\\\n \"mo_cms_used\\tmo_made_with_wordpress\\t\"\\\n \"mo_made_with_woocommerce\\tmo_made_with_joomla\\t\"\\\n \"mo_made_with_drupal\\tmo_made_with_mediawiki\\t\"\\\n \"mo_made_with_dokuwiki\\tmo_made_with_vbulletin\\t\"\\\n \"mo_made_with_django\\tmo_made_with_phpsqlitecms\\t\"\\\n \"mo_made_with_onionmail\\tmo_has_ads\\tmo_has_tracking\"",
"def format_output(response, response_format):\n if response is not None:\n has_printed_columns = False\n # Check if the response has model obects\n if contains_model_object(response):\n response_type = get_response_type(response)\n if response_type in column_settings.keys() and response_format == 'column':\n return column_dumps(response, response_type)\n elif isinstance(response, list):\n response = [o.serialize() for o in response]\n else:\n response = response.serialize()\n\n # fallback mode\n if response_format == 'json_pp' or (response_format == 'column' and not has_printed_columns):\n return json_dumps(response, indent=2, sort_keys=True)\n elif response_format == 'json':\n return json_dumps(response)\n elif response_format == 'yaml':\n return yaml_dumps(response)",
"def parseColHeader(self, i, j) :\n cell_content = self.processString(self.source_cell.value)\n if self.isEmpty(i,j):\n if self.insideMergeBox(i,j):\n k, l = self.getMergeBoxCoord(i,j)\n \n # If we are in a vertical merge box, skip adding the dimension\n if l == j:\n return\n\n # Update cell content \n cell_content = self.processString(self.r_sheet.cell(k,l).value)\n else:\n return\n\n # Add the value qname to the column_dimensions list for that column\n self.column_dimensions.setdefault(j,[self.sheet_qname]).append(cell_content)\n \n # Add the data to the graph\n resource = self.getColHeaderValueURI(self.column_dimensions[j])\n self.graph.add((resource, RDF.type, self.namespaces['tablink']['ColumnHeader']))\n self.graph.add((resource, self.namespaces['skos']['prefLabel'], Literal(cell_content)))\n self.graph.add((resource, self.namespaces['tablink']['cell'], Literal(self.source_cell_name)))\n return",
"def test_collected_columns_as_table_one_col_from_one(self):\n col_double, allow_colspan = True, True # as_type == 'table'\n col_args = ('span', False, {})\n name, multi_field_row = 'first', False\n names = [name]\n row = {name: self.form.fields[name]}\n col_count = 1\n expected = [self.form.collect_col_data(name, self.form.fields[name], *col_args) for name in names]\n for ea in expected:\n if multi_field_row:\n ea['css_classes'] = ' '.join(['nowrap', ea['css_classes']])\n ea['html_head_attr'] = ' class=\"nowrap\"'\n val = ea.pop('css_classes', '')\n val = ' class=\"%s\"' % val if val else ''\n if not multi_field_row and col_count > 1:\n val = val + ' colspan=\"{}\"'.format(2 * col_count - 1)\n ea['html_col_attr'] = val\n col_settings = (multi_field_row, col_count, col_double, allow_colspan)\n actual = self.form.collect_columns(row, col_settings, *col_args)\n\n self.assertEqual(len(expected), len(actual))\n for expect, got in zip(expected, actual):\n self.assertEqual(len(expect), len(got))\n self.assertListEqual(list(expect.keys()), list(got.keys()))\n self.assertListEqual(list(expect.values()), list(got.values()))\n self.assertEqual(expected, actual)",
"def get_column():\n q = request.query.decode()\n worksheet = q['worksheetKey']\n col = q['col']\n values = ss.read_column(worksheet, col)\n if values is not None:\n response.status = '200 OK'\n response.content_type = 'application/json'\n return {'values': values,\n 'col': col,\n 'worksheetKey': worksheet}\n else:\n response.status = '400 Bad Request'\n return response",
"def columns(self):\n headers = self.headers()\n for h in headers:\n col = self.get_column(h)\n yield col",
"def mkcol(self, url, body, dummy=None):\n return self.request(url, \"MKCOL\", body)",
"def first_header():\n return \"\"\"\n<th>Target\n<th>Date\n<th colspan=\"2\">UT\n<th>Exp\n<th>Cycle\n<th>No. of\n<th>Filters\n<th>XxY\n<th>Speed\n<th>NX1xNY1\n<th>X1\n<th>Y1\n<th>NX2xNY2\n<th>X2\n<th>Y2\n<th>Grat.\n<th>Slit\n<th>Slit\n<th>ID\n<th>PI\n<th align=\"left\">Comment\n\"\"\"",
"def output_columns(self) -> List[str]:",
"def test_tabular_format_output_wrapper():\n data = [[\"1\", None], [\"2\", \"Sam\"], [\"3\", \"Joe\"]]\n headers = [\"id\", \"name\"]\n expected = dedent(\n \"\"\"\\\n +----+------+\n | id | name |\n +----+------+\n | 1 | N/A |\n | 2 | Sam |\n | 3 | Joe |\n +----+------+\"\"\"\n )\n\n assert expected == \"\\n\".join(\n format_output(iter(data), headers, format_name=\"ascii\", missing_value=\"N/A\")\n )",
"def test_empty_cols_allowed(self):\n self.test_table.allow_empty_columns = True\n self.test_table.change_header(Path=1, SectionType=3, Value=4)\n self.assertEqual(self.test_table._header, [\"Path\", None, \"SectionType\",\n \"Value\"])",
"def render_column(self, row, column):\n # try to find rightmost object\n obj = row\n parts = column.split('.')\n for part in parts[:-1]:\n if obj is None:\n break\n obj = getattr(obj, part)\n\n # try using get_OBJECT_display for choice fields\n if hasattr(obj, 'get_%s_display' % parts[-1]):\n value = getattr(obj, 'get_%s_display' % parts[-1])()\n else:\n value = self._column_value(obj, parts[-1])\n\n if value is None:\n value = self.none_string\n\n if isinstance(value, datetime):\n value = localtime(value).strftime('%d-%b-%Y %H:%M')\n\n if self.escape_values:\n value = escape(value)\n\n if value and hasattr(obj, 'get_absolute_url') and column == 'bom_name':\n return '<a href=\"%s\">%s</a>' % (obj.get_absolute_url(), value)\n\n if value and column == 'parts':\n y = ast.literal_eval(unescape(value))\n z = \"<hr>\".join([\"<br>\".join(['{}: {}'.format(k, v) for k, v in i.items()]) for i in y])\n return z\n\n return value",
"def has_supported_header_hormat(cls, csv_reader):\n return csv_reader.fieldnames == cls.INGFormatHeader",
"def get_raw_column_names(request):\n body = json.loads(request.body)\n import_file = ImportFile.objects.get(pk=body.get('import_file_id'))\n\n return {\n 'status': 'success',\n 'raw_columns': import_file.first_row_columns\n }",
"def add_header(self, *column_headers):\n header = \"<tr>\"\n header += \" \".join(f\"<th>{header}</th> \" for header in column_headers)\n header += \"</tr>\\n\"\n self.result += header"
] | [
"0.7332766",
"0.6072905",
"0.6048208",
"0.5892109",
"0.58095014",
"0.5799792",
"0.5785104",
"0.5629377",
"0.55766165",
"0.5543907",
"0.5543907",
"0.5517988",
"0.5467961",
"0.5380816",
"0.5371949",
"0.53589845",
"0.5341816",
"0.52791214",
"0.52547175",
"0.5219514",
"0.52178514",
"0.518975",
"0.51854426",
"0.5179553",
"0.51783824",
"0.51673526",
"0.5094201",
"0.5089107",
"0.5084286",
"0.50708824"
] | 0.78356194 | 0 |
The collect_columns method applies the multi_field_row_class to HTML attributes on columns. | def test_css_class_for_multi_field_row_columns(self):
# form._html_output(self, row_tag, col_head_tag, col_tag, single_col_tag, col_head_data, col_data,
# help_text_br, errors_on_separate_row, as_type=None, strict_columns=False)
# css_classes = ' '.join(['nowrap', css_classes])
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_collected_columns_as_table_one_col_from_many(self):\n col_double, allow_colspan = True, True # as_type == 'table'\n col_args = ('span', False, {})\n name, multi_field_row = 'first', False\n names = [name]\n row = {name: self.form.fields[name]}\n col_count = 3\n expected = [self.form.collect_col_data(name, self.form.fields[name], *col_args) for name in names]\n for ea in expected:\n if multi_field_row:\n ea['css_classes'] = ' '.join(['nowrap', ea['css_classes']])\n ea['html_head_attr'] = ' class=\"nowrap\"'\n val = ea.pop('css_classes', '')\n val = ' class=\"%s\"' % val if val else ''\n if not multi_field_row and col_count > 1:\n val = val + ' colspan=\"{}\"'.format(2 * col_count - 1)\n ea['html_col_attr'] = val\n col_settings = (multi_field_row, col_count, col_double, allow_colspan)\n actual = self.form.collect_columns(row, col_settings, *col_args)\n\n self.assertEqual(len(expected), len(actual))\n for expect, got in zip(expected, actual):\n self.assertEqual(len(expect), len(got))\n self.assertListEqual(list(expect.keys()), list(got.keys()))\n self.assertListEqual(list(expect.values()), list(got.values()))\n self.assertEqual(expected, actual)",
"def append_columns(classdict, shape=()):\n heavy = common.heavy\n for (itype, type_) in enumerate(sorted(type_info)):\n if not heavy and type_ in heavy_types:\n continue # skip heavy type in non-heavy mode\n colpos = itype + 1\n colname = 'c_%s' % type_\n if type_ == 'enum':\n base = tb.Atom.from_sctype(sctype_from_type[type_])\n col = tb.EnumCol(enum, enum(0), base, shape=shape, pos=colpos)\n else:\n sctype = sctype_from_type[type_]\n dtype = np.dtype((sctype, shape))\n col = tb.Col.from_dtype(dtype, pos=colpos)\n classdict[colname] = col\n ncols = colpos\n return ncols",
"def test_collected_columns_no_table_one_col_from_one(self):\n col_double, allow_colspan = False, False # as_type != 'table'\n col_args = ('span', False, {})\n name, multi_field_row = 'first', False\n names = [name]\n row = {name: self.form.fields[name]}\n col_count = 1\n expected = [self.form.collect_col_data(name, self.form.fields[name], *col_args) for name in names]\n for ea in expected:\n if multi_field_row:\n ea['css_classes'] = ' '.join(['nowrap', ea['css_classes']])\n ea['html_head_attr'] = ' class=\"nowrap\"'\n val = ea.pop('css_classes', '')\n val = ' class=\"%s\"' % val if val else ''\n ea['html_col_attr'] = val\n col_settings = (multi_field_row, col_count, col_double, allow_colspan)\n actual = self.form.collect_columns(row, col_settings, *col_args)\n\n self.assertEqual(len(expected), len(actual))\n for expect, got in zip(expected, actual):\n self.assertEqual(len(expect), len(got))\n self.assertListEqual(list(expect.keys()), list(got.keys()))\n self.assertListEqual(list(expect.values()), list(got.values()))\n self.assertEqual(expected, actual)",
"def get_selected_columns(self):\n self._export_mode = 'columns'\n self._counter_update_data += 1",
"def add_widget_multicolumn(self,name, widget_dict, sizes=None):\n if recoverer is not None:\n for widget_name in widget_dict:\n widget_dict[widget_name] = self.stato_iniziale(widget_name, widget_dict[widget_name])\n\n self.widget_dict[name] = partial(st_functional_columns, widget_dict, sizes)",
"def load_columns(self):\n pass",
"def test_collected_columns_as_table_one_col_from_one(self):\n col_double, allow_colspan = True, True # as_type == 'table'\n col_args = ('span', False, {})\n name, multi_field_row = 'first', False\n names = [name]\n row = {name: self.form.fields[name]}\n col_count = 1\n expected = [self.form.collect_col_data(name, self.form.fields[name], *col_args) for name in names]\n for ea in expected:\n if multi_field_row:\n ea['css_classes'] = ' '.join(['nowrap', ea['css_classes']])\n ea['html_head_attr'] = ' class=\"nowrap\"'\n val = ea.pop('css_classes', '')\n val = ' class=\"%s\"' % val if val else ''\n if not multi_field_row and col_count > 1:\n val = val + ' colspan=\"{}\"'.format(2 * col_count - 1)\n ea['html_col_attr'] = val\n col_settings = (multi_field_row, col_count, col_double, allow_colspan)\n actual = self.form.collect_columns(row, col_settings, *col_args)\n\n self.assertEqual(len(expected), len(actual))\n for expect, got in zip(expected, actual):\n self.assertEqual(len(expect), len(got))\n self.assertListEqual(list(expect.keys()), list(got.keys()))\n self.assertListEqual(list(expect.values()), list(got.values()))\n self.assertEqual(expected, actual)",
"def test_col_data_css_classes(self):\n help_tag = 'span'\n help_text_br = False\n label_attrs = {}\n names = ('first', 'billing_address_1')\n expected = [self.form[name].css_classes() for name in names]\n actual = []\n for name in names:\n field = self.form.fields[name]\n response = self.form.collect_col_data(name, field, help_tag, help_text_br, label_attrs)\n actual.append(response.get('css_classes'))\n\n for expect, got in zip(expected, actual):\n self.assertEqual(expect, got)",
"def setup_row_from_columns(self, as_type, field_setup=None, error_names=None, errors_on_separate_row=True):\n col_args = ('span', as_type == 'table', {})\n is_table = as_type == 'table'\n if is_table:\n row_tag = 'tr',\n tag_info = ('th', 'td', 'td', '%(label)s', '%(errors)s%(field)s%(help_text)s')\n else:\n row_tag = 'li' if as_type == 'ul' else 'p'\n col_data = '%(errors)s%(label)s %(field)s%(help_text)s'\n if as_type == 'p':\n col_data = '%(label)s %(field)s%(help_text)s'\n tag_info = (None, 'span', '', '', col_data)\n col_html, single_col_html = self.form.column_formats(*tag_info)\n error_setup = self.setup_error_data(field_setup, error_names, is_table)\n result = []\n for row in error_setup:\n error_settings = row['settings']\n multi_field_row = error_settings[1]\n col_ct = error_settings[2]\n col_settings = (multi_field_row, col_ct, True, True) if is_table else (multi_field_row, col_ct, True, True)\n row_data = {name: self.form.fields[name] for name in row['field_names']}\n columns = self.form.collect_columns(row_data, col_settings, *col_args)\n for num, ea in enumerate(columns): # update each column with the artificial error data\n ea.update(row['columns'][num])\n html_row_attr = '' if multi_field_row or is_table else columns[0]['html_col_attr']\n cur_format = col_html if multi_field_row else single_col_html\n row_settings = (cur_format, html_row_attr, *error_settings)\n col_data = [cur_format % ea for ea in columns]\n err_data = row['actual'] if errors_on_separate_row else []\n expected = self.form.make_row(col_data, err_data, row_tag, html_row_attr)\n actual = self.form.row_from_columns(columns, row_tag, errors_on_separate_row, row_settings)\n result.append({'expected': expected, 'actual': actual})\n return result",
"def columns(self) -> java.util.Collection:\n ...",
"def as_columns(self, **columns):\n return self.__class__.from_columns(columns, self.meta)\n # return self.__class__(self.data.loc[:, columns], self.meta.copy())",
"def column_choices(field_order, fields_mapped, fields_selected):\n return (\n \"<div class='col-sm-4'>\"\n + \"</div><div class='col-sm-4'>\".join(\n [make_check_tag(f, fields_mapped, fields_selected) for f in field_order]\n )\n + '</div>'\n )",
"def test_collected_columns_as_table_two_col_from_two(self):\n col_double, allow_colspan = True, True # as_type == 'table'\n col_args = ('span', False, {})\n names, multi_field_row = ('first', 'billing_address_1'), True\n row = {name: self.form.fields[name] for name in names}\n col_count = 2\n expected = [self.form.collect_col_data(name, self.form.fields[name], *col_args) for name in names]\n for ea in expected:\n if multi_field_row:\n ea['css_classes'] = ' '.join(['nowrap', ea['css_classes']])\n ea['html_head_attr'] = ' class=\"nowrap\"'\n val = ea.pop('css_classes', '')\n val = ' class=\"%s\"' % val if val else ''\n if not multi_field_row and col_count > 1:\n val = val + ' colspan=\"{}\"'.format(2 * col_count - 1)\n ea['html_col_attr'] = val\n col_settings = (multi_field_row, col_count, col_double, allow_colspan)\n actual = self.form.collect_columns(row, col_settings, *col_args)\n\n self.assertEqual(len(expected), len(actual))\n for expect, got in zip(expected, actual):\n self.assertEqual(len(expect), len(got))\n self.assertListEqual(list(expect.keys()), list(got.keys()))\n self.assertListEqual(list(expect.values()), list(got.values()))\n self.assertEqual(expected, actual)",
"def test_collected_columns_no_table_two_col_from_two(self):\n col_double, allow_colspan = False, False # as_type != 'table'\n col_args = ('span', False, {})\n names, multi_field_row = ('first', 'billing_address_1'), True\n row = {name: self.form.fields[name] for name in names}\n col_count = 2\n expected = [self.form.collect_col_data(name, self.form.fields[name], *col_args) for name in names]\n for ea in expected:\n if multi_field_row:\n ea['css_classes'] = ' '.join(['nowrap', ea['css_classes']])\n ea['html_head_attr'] = ' class=\"nowrap\"'\n val = ea.pop('css_classes', '')\n val = ' class=\"%s\"' % val if val else ''\n ea['html_col_attr'] = val\n col_settings = (multi_field_row, col_count, col_double, allow_colspan)\n actual = self.form.collect_columns(row, col_settings, *col_args)\n\n self.assertEqual(len(expected), len(actual))\n for expect, got in zip(expected, actual):\n self.assertEqual(len(expect), len(got))\n self.assertListEqual(list(expect.keys()), list(got.keys()))\n self.assertListEqual(list(expect.values()), list(got.values()))\n self.assertEqual(expected, actual)",
"def columns(self):\n \n pass",
"def mixin_cols(request):\n cols = OrderedDict()\n mixin_cols = deepcopy(MIXIN_COLS)\n cols[\"i\"] = table.Column([0, 1, 2, 3], name=\"i\")\n cols[\"a\"] = table.Column([\"a\", \"b\", \"b\", \"c\"], name=\"a\")\n cols[\"b\"] = table.Column([\"b\", \"c\", \"a\", \"d\"], name=\"b\")\n cols[\"m\"] = mixin_cols[request.param]\n\n return cols",
"def _generate_rowklass(self):\n header = six.next(self.resolved)\n clean = []\n for h in header:\n underscoreless = h.strip().lower().replace(' ', '_').replace('.', '_')\n specialless = underscoreless.replace('(', '').replace(')', '').replace('?', '').replace('-', '')\n if specialless == '':\n clean.append(specialless)\n continue\n try:\n num = int(specialless[0])\n numbers = {1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five',\n 6: 'six', 7: 'seven', 8: 'eight', 9: 'nine', 10: 'ten'}\n numless = numbers[num] + specialless[1:]\n cleaned = numless\n except ValueError:\n cleaned = specialless\n\n more = 1\n while cleaned in clean:\n more += 1\n cleaned += str(more)\n\n clean.append(cleaned)\n\n for i, v in enumerate(clean):\n if v == '':\n clean[i] = 'field_' + str(i)\n self.rowklass = collections.namedtuple('RowKlass', clean)",
"def _updateColAttrs(self, grid):\n col = 0\n\n for colname in self.table.columns:\n attr = wx.grid.GridCellAttr()\n renderer = MegaFontRenderer(self.table)\n attr.SetRenderer(renderer)\n grid.SetColAttr(col, attr)\n col += 1",
"def multi_col_error_format(self, as_type, errors, **kwargs):\n error_data = [self.error_format(as_type, error, **kwargs) for error in errors]\n row_tag = 'tr' if as_type == 'as_table' else 'li' if as_type == 'ul' else 'p'\n row_tag = kwargs.get('row_tag', row_tag)\n error_row = self.form._html_tag(row_tag, ' '.join(error_data))\n return error_row",
"def columns(self, *args):\n column_set = set(self._columns)\n for c in args:\n if c in column_set:\n continue\n else:\n self._columns.append(c)\n # column_set.add(c) # FIXME failing tests\n return self",
"def get_column_class_names(self, classes_set, bound_column):\n cset = super(ColumnShiftTable, self).get_column_class_names(classes_set, bound_column)\n cset.add(bound_column.name)\n return cset",
"def get_columns(self, request, cl):\n columns = []\n for field_name in cl.model_admin.list_display:\n text, _ = label_for_field(field_name, cl.model, model_admin=cl.model_admin, return_attr=True)\n columns.append({field_name: text})\n return columns",
"def select(self, *args):\n for column in args:\n self._columns += (SelectExpression(column),)\n return self",
"def test_column_formats(self):\n attrs = '%(html_col_attr)s'\n col_tag = 'span'\n single_col_tag = ''\n col_data = '%(errors)s%(label)s %(field)s%(help_text)s'\n expected_col = self.form._html_tag(col_tag, col_data, attrs)\n expected_single = col_data if not single_col_tag else self.form._html_tag(single_col_tag, col_data, attrs)\n actual_col, actual_single = self.form.column_formats(None, col_tag, single_col_tag, '', col_data)\n self.assertEqual(expected_col, actual_col)\n self.assertEqual(expected_single, actual_single)",
"def column_selection_change():\n d = curdoc()\n _remove_fig(d)\n model_id, message_name, _ = run_handlers.get_modelid_messagename_type(d)\n sind = run_handlers.get_source_index(d.session_context.id, model_id, message_name)\n source = d.get_model_by_name(sind)\n _install_callback_and_cds(sind, model_id, message_name, stream_limit=1)\n sel_cols = d.get_model_by_name(COLUMN_MULTISELECT).value\n columns = [ TableColumn(field=c, title=c) for c in sel_cols ]\n data_table = DataTable(source=source, columns=columns, width=500, height=500)\n table_widget = widgetbox(data_table, name=FIGURE_MODEL)\n d.add_root(table_widget)",
"def adjust_columns(self):\r\n for col in range(3):\r\n self.resizeColumnToContents(col)",
"def GetColumns(self):\n ret = super().GetColumns()\n ret.append((\"name\",\"text\"))\n return ret",
"def add_columns(self, specs, before=False):\n import hxl.filters\n return hxl.filters.AddColumnsFilter(self, specs=specs, before=before)",
"def column_descriptions(self):\n meth = SelectState.get_plugin_class(self).get_column_descriptions\n return meth(self)",
"def _get_columns(self):\n columns = []\n for column in self.plate_meta['columns']:\n columns.append(column['name'])\n self.columns = columns"
] | [
"0.55407095",
"0.52808714",
"0.5144478",
"0.51113474",
"0.5090835",
"0.5089068",
"0.50605047",
"0.5045822",
"0.50412333",
"0.49674788",
"0.49350232",
"0.49150926",
"0.49048653",
"0.49031234",
"0.48734918",
"0.48659092",
"0.48523653",
"0.48229092",
"0.48038903",
"0.4799636",
"0.4779166",
"0.47760198",
"0.47676724",
"0.47564635",
"0.4740904",
"0.4721242",
"0.46985847",
"0.46977335",
"0.46949676",
"0.4676714"
] | 0.74624133 | 0 |
The FormFieldsetMixIn new _html_output method will call assign_focus_field method if present. | def test_html_output_formfieldset_use_focus_if_present(self):
original_focus_called = self.form.called_assign_focus_field
for as_type in ('as_p', 'as_ul', 'as_table', 'as_fieldset'):
self.form.called_assign_focus_field = False
html_output = getattr(self.form, as_type)()
message = "The FormFieldsetMixIn new _html_output failed on {}".format(as_type)
self.assertTrue(self.form.called_assign_focus_field, message)
self.assertIsNotNone(html_output)
self.form.called_assign_focus_field = original_focus_called | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_html_output_default_use_focus_if_present(self):\n original_focus_called = self.form.called_assign_focus_field\n for as_type in ('as_p', 'as_ul', 'as_table'):\n self.form.called_assign_focus_field = False\n html_output = getattr(self.form, as_type + '_old')()\n message = \"The FormFieldsetMixIn OLD _html_output failed on {}\".format(as_type)\n self.assertTrue(self.form.called_assign_focus_field, message)\n self.assertIsNotNone(html_output)\n\n self.form.called_assign_focus_field = original_focus_called",
"def test_as_fieldset(self):\n # form._html_output(self, row_tag, col_head_tag, col_tag, single_col_tag, col_head_data, col_data,\n # help_text_br, errors_on_separate_row, as_type=None, strict_columns=False)\n pass",
"def test_prep_fields_called_html_output(self):\n pass",
"def focus(self):\n raise NotImplementedError",
"def run_autofocus(self):\n raise NotImplementedError",
"def test_make_fieldsets_uses_handle_modifiers(self):\n original_called_handle_modifiers = self.form.called_handle_modifiers = False\n full_fieldsets = self.form.make_fieldsets()\n\n self.assertFalse(original_called_handle_modifiers)\n self.assertIsInstance(full_fieldsets, (list, tuple))\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n self.assertTrue(self.form.called_handle_modifiers)\n\n self.form.called_handle_modifiers = original_called_handle_modifiers",
"def process_show_formset(self, request, step, formset):\n pass",
"def _focus(self, event) -> None:\n self.focus = True",
"def setFocus(*args, **kwargs)->None:\n pass",
"def render_change_form_fieldset(context, fieldset):\n return fieldset.render(context)",
"def force_focus_set(self, event):\n self.focus_set()",
"def test_focus_on_limited_fields(self):\n original_named_focus = self.form.named_focus\n original_fields_focus = self.form.fields_focus\n original_given_focus = self.form.given_focus\n original_fields = self.form.fields\n self.form.named_focus = None\n self.form.given_focus = None\n allowed = [name for name, field in self.form.fields.items()\n if not field.disabled and not isinstance(field.widget, (HiddenInput, MultipleHiddenInput))]\n self.assertGreater(len(allowed), 1)\n fields_focus = allowed[1:]\n self.form.fields_focus = fields_focus\n expected = fields_focus[0]\n actual = self.form.assign_focus_field(None, fields=self.form.fields_focus)\n\n self.assertEqual(expected, actual)\n self.assertEqual(self.form.given_focus, actual)\n\n self.form.name_focus = original_named_focus\n self.form.fields_focus = original_fields_focus\n self.form.given_focus = original_given_focus\n self.form.fields = original_fields",
"def run_autofocus_stig(self):\n raise NotImplementedError",
"def render_form():",
"def render(self, **kwargs):\r\n return h.text_field(self.name, value=self.value, **kwargs)",
"def OnSetFocus(self, event):\r\n\r\n self._owner.SetFocus()",
"def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n placeholders = {\n \"first_name\": \"First Name\",\n \"last_name\": \"Last Name\",\n \"default_phone_num\": \"Phone Number\",\n \"default_passport_num\": \"Passport Number\",\n }\n\n self.fields[\"default_phone_num\"].widget.attrs[\"autofocus\"] = True\n for field in self.fields:\n placeholder = placeholders[field]\n self.fields[field].widget.attrs[\"placeholder\"] = placeholder\n self.fields[field].widget.attrs[\n \"class\"\n ] = \"border-black rounded-0 \\\n all-form-input\"\n self.fields[field].label = False\n self.helper = FormHelper()\n self.helper.form_tag = True\n self.helper.layout = Layout(\n Div(\n Field(\n \"first_name\",\n ),\n Field(\n \"last_name\",\n ),\n Field(\n \"default_phone_num\",\n ),\n Field(\n \"default_passport_num\",\n ),\n ),\n ButtonHolder(\n Submit(\"submit\", \"Save\", css_class=\"m-0 btn btn-outline\"),\n ),\n )",
"def render_formset(self, request, step, formset, context):\n\n\n return render_to_response(self.get_template(request, step, formset),\n context, RequestContext(request))",
"def __init__(self, *args, **kwargs):\n super(PostFilterForm, self).__init__(*args, **kwargs)\n self.helper = FormHelper()\n self.helper.form_class = 'form-inline'\n self.helper.form_method = 'get'\n self.helper.add_input(Submit('submit', 'Filter'))",
"def setField(self, data):\n\t\tview = self.view\n\t\tview.sbAbstraccion.setValue(data['sbAbstraccion'])",
"def OnSetFocus(self, event):\r\n\r\n self.Refresh()",
"def as_bootstrap(self):\n top_errors = self.non_field_errors() # Errors that should be displayed above all fields.\n output, hidden_fields = [], []\n normal_row = u'<div%(html_class_attr)s>%(label)s<div class=\"controls\">%(field)s%(help_text)s</div>%(errors)s</div>'\n boolean_row = u'<div%(html_class_attr)s><div class=\"controls\">%(label_and_field)s%(help_text)s</div>%(errors)s</div>'\n error_row = u'<div class=\"alert alert-error\">%s</div>'\n row_ender = u'</div>'\n help_text_html = u'<span class=\"help-inline\">%s</span>'\n errors_on_separate_row = False\n\n for name, field in self.fields.items():\n html_class_attr = ''\n bf = self[name]\n is_boolean = isinstance(field, forms.fields.BooleanField)\n bf_errors = self.error_class([conditional_escape(error) for error in bf.errors]) # Escape and cache in local variable.\n if bf.is_hidden:\n if bf_errors:\n top_errors.extend([u'(Hidden field %s) %s' % (name, force_unicode(e)) for e in bf_errors])\n hidden_fields.append(unicode(bf))\n else:\n # Create a 'class=\"...\"' atribute if the row should have any\n # CSS classes applied.\n css_classes = bf.css_classes(extra_classes='control-group')\n if css_classes:\n html_class_attr = ' class=\"%s\"' % css_classes\n\n if errors_on_separate_row and bf_errors:\n output.append(error_row % force_unicode(bf_errors))\n\n if bf.label:\n label = conditional_escape(force_unicode(bf.label))\n if is_boolean:\n label = bf.label_tag(unicode(bf) + label,\n attrs={'class': 'checkbox'}) or ''\n else:\n # Only add the suffix if the label does not end in\n # punctuation.\n if self.label_suffix:\n if label[-1] not in ':?.!':\n label += self.label_suffix\n\n label = bf.label_tag(label,\n attrs={'class': 'control-label'}) or ''\n else:\n label = ''\n\n if field.help_text:\n help_text = help_text_html % force_unicode(field.help_text)\n else:\n help_text = u''\n\n if bf_errors:\n errors = u' '.join([error_row % force_unicode(error)\n for error in bf_errors])\n else:\n errors = u''\n\n if is_boolean:\n output.append(boolean_row % {\n 'errors': errors,\n 'label_and_field': force_unicode(label),\n 'help_text': help_text,\n 'html_class_attr': html_class_attr\n })\n else:\n output.append(normal_row % {\n 'errors': errors,\n 'label': force_unicode(label),\n 'field': unicode(bf),\n 'help_text': help_text,\n 'html_class_attr': html_class_attr\n })\n\n if top_errors:\n output.insert(0, error_row % force_unicode(top_errors))\n\n if hidden_fields: # Insert any hidden fields in the last row.\n str_hidden = u''.join(hidden_fields)\n if output:\n last_row = output[-1]\n # Chop off the trailing row_ender (e.g. '</td></tr>') and\n # insert the hidden fields.\n if not last_row.endswith(row_ender):\n # This can happen in the as_p() case (and possibly others\n # that users write): if there are only top errors, we may\n # not be able to conscript the last row for our purposes,\n # so insert a new, empty row.\n last_row = (normal_row % {'errors': '', 'label': '',\n 'field': '', 'help_text': '',\n 'html_class_attr': html_class_attr})\n output.append(last_row)\n output[-1] = last_row[:-len(row_ender)] + str_hidden + row_ender\n else:\n # If there aren't any rows in the output, just append the\n # hidden fields.\n output.append(str_hidden)\n return mark_safe(u'\\n'.join(output))",
"def setfocus(self, focus):\n self.focus = self.data[focus]\n self.focus_stage = focus\n for k in self.focus.keys():\n setattr(self, k, self.focus[k])",
"def setFocus(*args):",
"def setFocus(*args):",
"def setFocus(*args):",
"def setFocus(*args):",
"def __call__(self, *args, **kwargs):\n \n # Store the panel args, in case other methods want to use them.\n self.panel_args = args\n self.panel_kwargs = kwargs\n \n # Then do the default.\n data = super(FormPanel, self).__call__()\n \n # Reset the form if told to.\n if data.get('reset_form'):\n form = data['form_instance']\n data['render_form'] = lambda: form.render(self.default_appstruct)\n \n # And append the flash queue.\n data['flash_queue'] = self.flash_queue\n return data",
"def __init__(self, *args, **kwargs):\n\n\t\tsuper(CustomStatusFormset, self).__init__(*args, **kwargs)\n\n\t\tfor form in self.forms:\n\t\t\tfor field in form.fields:\n\t\t\t\tform.fields[field].widget.attrs.update({'class': 'form-control'})",
"def render_form_content(self):\n return mark_safe(self.render_as_object() + self.render_missing_fields())"
] | [
"0.7107614",
"0.56360286",
"0.53862023",
"0.53715336",
"0.51885885",
"0.5155153",
"0.5140702",
"0.5073164",
"0.5016641",
"0.50019234",
"0.49776796",
"0.49149355",
"0.4902441",
"0.49001548",
"0.48874465",
"0.4879166",
"0.4837746",
"0.48375157",
"0.47979036",
"0.47805056",
"0.47562537",
"0.4735499",
"0.47260046",
"0.47194558",
"0.47194558",
"0.47194558",
"0.47194558",
"0.47003937",
"0.46888277",
"0.46650243"
] | 0.77101827 | 0 |
The default _html_output method will call assign_focus_field method if present. | def test_html_output_default_use_focus_if_present(self):
original_focus_called = self.form.called_assign_focus_field
for as_type in ('as_p', 'as_ul', 'as_table'):
self.form.called_assign_focus_field = False
html_output = getattr(self.form, as_type + '_old')()
message = "The FormFieldsetMixIn OLD _html_output failed on {}".format(as_type)
self.assertTrue(self.form.called_assign_focus_field, message)
self.assertIsNotNone(html_output)
self.form.called_assign_focus_field = original_focus_called | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_html_output_formfieldset_use_focus_if_present(self):\n original_focus_called = self.form.called_assign_focus_field\n for as_type in ('as_p', 'as_ul', 'as_table', 'as_fieldset'):\n self.form.called_assign_focus_field = False\n html_output = getattr(self.form, as_type)()\n message = \"The FormFieldsetMixIn new _html_output failed on {}\".format(as_type)\n self.assertTrue(self.form.called_assign_focus_field, message)\n self.assertIsNotNone(html_output)\n\n self.form.called_assign_focus_field = original_focus_called",
"def test_prep_fields_called_html_output(self):\n pass",
"def render(self, **kwargs):\r\n return h.text_field(self.name, value=self.value, **kwargs)",
"def __html__(self):\n return self.html",
"def run_autofocus(self):\n raise NotImplementedError",
"def focus(self):\n raise NotImplementedError",
"def render_form():",
"def run_autofocus_stig(self):\n raise NotImplementedError",
"def render(self):\r\n super().render()",
"def output(self):\n return super(RequireJSPage, self).output",
"def html(self, html):\n\n self._html = html",
"def render(self):\n start_tag = format_html('<div {}>', mark_safe(' '.join(self.field_attrs)))\n output = [start_tag]\n for widget in self:\n output.append(force_text(widget))\n output.append('</div>')\n return mark_safe('\\n'.join(output))",
"def render(self):\n pass",
"def render(self):\n pass",
"def render(self):\n pass",
"def render(self):\n pass",
"def render(self):\n pass",
"def render(self):\n pass",
"def test_as_fieldset(self):\n # form._html_output(self, row_tag, col_head_tag, col_tag, single_col_tag, col_head_data, col_data,\n # help_text_br, errors_on_separate_row, as_type=None, strict_columns=False)\n pass",
"def output(self):\r\n self.logic ( )\r\n return self.output",
"def _render(self) -> None:\n pass",
"def initFormat(self):\n self.html = True",
"def initFormat(self):\n self.html = True",
"def rawHTMLrendered(self):",
"def get_html(self):\r\n pass",
"def _repr_html_(self):\n\n return self._repr__base(rich_output=True)",
"def _repr_html_(self):\n\n return self._repr__base(rich_output=True)",
"def render(self):\n self.rendered = self.value\n return self.rendered",
"def set_output(self, iclass):\n self._custom_setter('output', iclass)\n self._custom_setter('presenting', True)",
"def test_html_output(self):\n pass"
] | [
"0.70727175",
"0.5861443",
"0.5413612",
"0.52534735",
"0.5232743",
"0.5035901",
"0.5027788",
"0.4992459",
"0.49813837",
"0.49795794",
"0.4854642",
"0.4845558",
"0.48208484",
"0.48208484",
"0.48208484",
"0.48208484",
"0.48208484",
"0.48208484",
"0.47939968",
"0.4782367",
"0.47619578",
"0.47386765",
"0.47386765",
"0.47386557",
"0.4703392",
"0.46878722",
"0.46878722",
"0.46751702",
"0.4668482",
"0.46610525"
] | 0.7255053 | 0 |
For as_type='table', regardless of other settings, the 'determine_label_width' method is not called. | def test_html_output_label_attrs_table(self):
self.label_calls = []
def fake_label_width(rows): self.label_calls.append(rows); return {}
original_adjust_label_width = self.form.adjust_label_width
self.form.adjust_label_width = True
original_label_method = self.form.determine_label_width
self.form.determine_label_width = fake_label_width
collected = []
for as_type in ('as_p', 'as_ul', 'as_table', 'as_fieldset'):
collected.append({'type': as_type, 'html': getattr(self.form, as_type)(), 'calls': self.label_calls})
self.label_calls = []
expected = [opts['rows'] for lbl, opts in self.form._fieldsets]
for ea in collected:
expect = [] if ea['type'] == 'as_table' else expected
message = f"Mismatch for {ea['type']} html_output. "
self.assertEqual(expect, ea['calls'], message)
self.form.determine_label_width = original_label_method
self.form.adjust_label_width = original_adjust_label_width
del self.label_calls | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_determine_label_width(self):\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed_fields = self.get_allowed_width_fields()\n test_fields = allowed_fields.copy() # TODO: ? Try an input with some double and some single column rows?\n labels = [field.label or pretty_name(name) for name, field in test_fields.items()]\n full_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch\n word_width = max(len(word) for label in labels for word in label.split()) // 2\n expected_width = full_width if full_width < self.form.max_label_width else word_width\n expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(expected_width)}\n expected_attrs = {name: expected_attrs for name in list(test_fields.keys())}\n actual_attrs = self.form.determine_label_width(self.form.fields)\n\n self.assertLess(word_width, self.form.max_label_width)\n self.assertEqual(expected_attrs, actual_attrs)\n\n self.form.adjust_label_width = original_setting",
"def test_raises_too_wide_label_width(self):\n original_max = self.form.max_label_width\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n max_width = 2\n self.form.max_label_width = max_width\n allowed_fields = self.get_allowed_width_fields()\n group_keys = list(allowed_fields.keys())\n message = \"The max_label_width of {} is not enough for the fields: {} \".format(max_width, group_keys)\n\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.determine_label_width(self.form.fields)\n\n self.form.max_label_width = original_max\n self.form.adjust_label_width = original_setting",
"def test_label_width_fits_full_label_if_small_enough(self):\n original_max = self.form.max_label_width\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed_fields = self.get_allowed_width_fields()\n labels = [field.label or pretty_name(name) for name, field in allowed_fields.items()]\n full_label_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch\n expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(full_label_width)}\n expected_attrs = {name: expected_attrs for name in allowed_fields}\n max_width = full_label_width + 5\n self.form.max_label_width = max_width\n actual_attrs = self.form.determine_label_width(self.form.fields)\n\n self.assertGreater(max_width, full_label_width)\n self.assertEqual(expected_attrs, actual_attrs)\n\n self.form.max_label_width = original_max\n self.form.adjust_label_width = original_setting",
"def test_table_sizes(self):\n labels_tables = self.labels.find_one({ 'dataset': 'SF1' })['tables']\n\n for label_data in labels_tables.values():\n self.assertEqual(label_data['size'], len(label_data['labels']))",
"def test_word_wrap_label_width(self):\n original_max = self.form.max_label_width\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed_fields = self.get_allowed_width_fields()\n labels = [field.label or pretty_name(name) for name, field in allowed_fields.items()]\n full_label_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch\n word_width = max(len(word) for label in labels for word in label.split()) // 2\n expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(word_width)}\n expected_attrs = {name: expected_attrs for name in allowed_fields}\n max_width = word_width + 1\n self.form.max_label_width = max_width\n actual_attrs = self.form.determine_label_width(self.form.fields)\n\n self.assertLess(max_width, full_label_width)\n self.assertEqual(expected_attrs, actual_attrs)\n\n self.form.max_label_width = original_max\n self.form.adjust_label_width = original_setting",
"def test_label_width_not_enough_single_field_rows(self):\n name, *names = list(self.form.fields.keys())\n field_rows = [{name: self.form.fields[name]}]\n if len(names) > 1:\n double_row = {name: self.form.fields[name] for name in names[:2]}\n field_rows.append(double_row)\n expected = {}\n actual = self.form.determine_label_width(field_rows)\n self.assertEqual(expected, actual)",
"def test_not_adjust_label_width(self):\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = False\n expected = {}\n actual = self.form.determine_label_width(self.form.fields)\n self.assertFalse(self.form.adjust_label_width)\n self.assertEqual(expected, actual)\n self.form.adjust_label_width = original_setting",
"def label_width(self):\n return self._label_width",
"def label_width(self, start, end, numlabels=None, char_width=None):\n return self.formatter.estimate_width(start, end, numlabels, char_width,\n ticker=self)",
"def test_only_correct_widget_classes(self):\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed = self.get_allowed_width_fields()\n reject_fields = {name: field for name, field in self.form.fields.items() if name not in allowed}\n expected = {}\n actual = self.form.determine_label_width(reject_fields)\n self.assertEqual(expected, actual)\n self.form.adjust_label_width = original_setting",
"def Width(self):\n return _table.Table_Width(self)",
"def width(self):\n\t\tpass",
"def __repr__(self):\n return '<widths: {}, subtable: {}>'.format(self.widths, self.subtable)",
"def estimate_width(start, end, numlabels=None, char_width=None):\n return 0, 0",
"def _label_width(text):\n width = 0\n for lineno, line in enumerate(text.split(u'\\n')):\n size = [_BIG_FONT, _SMALL_FONT][lineno > 0] # Cool idiom, huh?\n width = max(width, size * len(line))\n return width",
"def set_width( self, width ):\n # label seems to be the controlling thing\n self.label_widget.configure( width = width )",
"def test_numalign_short_width():\n tbl = Txtble(\n headers=[\"Thing\", \"Value\"],\n data=[\n [\"Foo\", 12345],\n [\"Bar\", 1234.5],\n [\"Baz\", 123.45],\n [\"Quux\", 12.345],\n [\"Glarch\", 1.2345],\n ],\n align=[\"l\", \"n\"],\n widths=[None, 6],\n )\n with pytest.raises(NumericWidthOverflowError) as excinfo:\n str(tbl)\n assert str(excinfo.value) == \"Numeric alignment overflows column width\"",
"def _get_tabletype(cls) -> str:\n return 'HTML'",
"def test_attributes(cls):\n table_data = [\n ['Name', 'Color', 'Type'],\n ['Avocado', 'green', 'nut'],\n ['Tomato', 'red', 'fruit'],\n ['Lettuce', 'green', 'vegetable'],\n ]\n table = cls(table_data) # '| Lettuce | green | vegetable |'\n\n table.outer_border = False\n assert 58 == table.column_max_width(0)\n assert 56 == table.column_max_width(1)\n assert 60 == table.column_max_width(2)\n table.outer_border = True\n\n table.inner_column_border = False\n assert 58 == table.column_max_width(0)\n assert 56 == table.column_max_width(1)\n assert 60 == table.column_max_width(2)\n table.outer_border = False\n assert 60 == table.column_max_width(0)\n assert 58 == table.column_max_width(1)\n assert 62 == table.column_max_width(2)\n table.outer_border = True\n table.inner_column_border = True\n\n table.padding_left = 0\n assert 59 == table.column_max_width(0)\n assert 57 == table.column_max_width(1)\n assert 61 == table.column_max_width(2)\n table.padding_right = 5\n assert 47 == table.column_max_width(0)\n assert 45 == table.column_max_width(1)\n assert 49 == table.column_max_width(2)",
"def _generateTable(self, obj, **args):\n\n if self._script.utilities.isLayoutOnly(obj):\n return []\n\n try:\n table = obj.queryTable()\n except:\n return []\n\n return [messages.tableSize(table.nRows, table.nColumns)]",
"def updateWidthFromLabel(self):\n prevWidth = self.rect().width()\n width = self.text.boundingRect().width() + \\\n CurrentTheme.VERSION_LABEL_MARGIN[0] - 4\n r = self.rect()\n r.setX(r.x()+(prevWidth-width)/2.0)\n r.setWidth(width)\n self.setRect(r)\n self.update()",
"def test_simple(cls):\n table_data = [\n ['Name', 'Color', 'Type'],\n ['Avocado', 'green', 'nut'],\n ['Tomato', 'red', 'fruit'],\n ['Lettuce', 'green', 'vegetable'],\n ]\n table = cls(table_data) # '| Lettuce | green | vegetable |'\n\n assert 56 == table.column_max_width(0)\n assert 54 == table.column_max_width(1)\n assert 58 == table.column_max_width(2)\n\n table_data.append(['Watermelon', 'green', 'fruit'])\n assert 56 == table.column_max_width(0)\n assert 51 == table.column_max_width(1)\n assert 55 == table.column_max_width(2)",
"def GetLabelSize(self, label):\r\n\r\n dc = wx.ClientDC(self)\r\n dc.SetFont(self._font)\r\n\r\n return GetLabelSize(dc, label, self._tool_orientation != AUI_TBTOOL_HORIZONTAL)",
"def start_table(self):\n self.col_widths = []\n self.result = \"\"",
"def add_run_length_encoding_table(self, tag, line, rows, columns, row_labels=None, underline=False):\n if row_labels:\n columns += 1\n\n with tag(\"table\"):\n with tag(\"tbody\"):\n for row_index in range(rows):\n with tag(\"tr\"):\n for column_index in range(columns):\n line(\"td\", \"\", klass=\"bordered-cell\")\n if row_labels and row_index < len(row_labels):\n line(\"td\", row_labels[row_index], klass=\"label-cell\")\n if underline:\n line(\"td\", \"\", klass=\"padding-cell\")\n line(\"td\", \"\", klass=\"underline-cell\")",
"def calc_width(self):\n current_longest = 0\n\n for i in range(len(self.list_of_motif_objects)):\n current_object = self.list_of_motif_objects[i]\n if(len(current_object.sequence) > current_longest):\n current_longest = len(current_object.sequence)\n \n width_for_drawing = current_longest + 50 + 15 \n\n self.width = width_for_drawing + self.width_of_legend",
"def width(self) -> int:",
"def width(self) -> int:",
"def pixwidth(self):\n return self._labelWidth * self.transform.scale[0]",
"def weight_width(self):\n raise NotImplementedError(\"subclasses need to override this method\")"
] | [
"0.7241686",
"0.64997905",
"0.64593494",
"0.64277035",
"0.63348335",
"0.62912124",
"0.62319434",
"0.61944085",
"0.6070183",
"0.5979112",
"0.5969667",
"0.58039486",
"0.57957506",
"0.56060773",
"0.5570745",
"0.5514113",
"0.5506302",
"0.5504249",
"0.5498929",
"0.5462957",
"0.5424459",
"0.539994",
"0.534364",
"0.5342876",
"0.5330278",
"0.52975565",
"0.52924603",
"0.52924603",
"0.5270622",
"0.5248938"
] | 0.69940203 | 1 |
The FormFieldsetMixIn new _html_output method mimics the default behavior for including top_errors. | def test_top_errors_at_top_html(self):
original_errors = getattr(self.form, '_errors', None)
original_cleaned_data = getattr(self.form, 'cleaned_data', None)
self.form._errors = ErrorDict()
self.form.cleaned_data = {}
test_error = "This non-field error is placed here just to pick on you. "
self.form.add_error(None, test_error)
self.form.make_fieldsets()
row_tag = 'p'
html_output = self.form._html_output_new( # replicates as_p()
row_tag=row_tag,
col_head_tag=None,
col_tag='span',
single_col_tag='',
col_head_data='',
col_data='%(label)s %(field)s%(help_text)s',
help_text_br=False,
errors_on_separate_row=True,
as_type='p'
)
html_rows = html_output.split('\n')
actual_top_html = html_rows[0]
expected_top_html = self.form._html_tag(row_tag, test_error, ' id="top_errors"')
self.assertIn(NON_FIELD_ERRORS, self.form._errors)
self.assertEqual(expected_top_html, actual_top_html)
self.form.cleaned_data = original_cleaned_data
self.form._errors = original_errors
if original_errors is None:
del self.form._errors
if original_cleaned_data is None:
del self.form.cleaned_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def as_bootstrap(self):\n top_errors = self.non_field_errors() # Errors that should be displayed above all fields.\n output, hidden_fields = [], []\n normal_row = u'<div%(html_class_attr)s>%(label)s<div class=\"controls\">%(field)s%(help_text)s</div>%(errors)s</div>'\n boolean_row = u'<div%(html_class_attr)s><div class=\"controls\">%(label_and_field)s%(help_text)s</div>%(errors)s</div>'\n error_row = u'<div class=\"alert alert-error\">%s</div>'\n row_ender = u'</div>'\n help_text_html = u'<span class=\"help-inline\">%s</span>'\n errors_on_separate_row = False\n\n for name, field in self.fields.items():\n html_class_attr = ''\n bf = self[name]\n is_boolean = isinstance(field, forms.fields.BooleanField)\n bf_errors = self.error_class([conditional_escape(error) for error in bf.errors]) # Escape and cache in local variable.\n if bf.is_hidden:\n if bf_errors:\n top_errors.extend([u'(Hidden field %s) %s' % (name, force_unicode(e)) for e in bf_errors])\n hidden_fields.append(unicode(bf))\n else:\n # Create a 'class=\"...\"' atribute if the row should have any\n # CSS classes applied.\n css_classes = bf.css_classes(extra_classes='control-group')\n if css_classes:\n html_class_attr = ' class=\"%s\"' % css_classes\n\n if errors_on_separate_row and bf_errors:\n output.append(error_row % force_unicode(bf_errors))\n\n if bf.label:\n label = conditional_escape(force_unicode(bf.label))\n if is_boolean:\n label = bf.label_tag(unicode(bf) + label,\n attrs={'class': 'checkbox'}) or ''\n else:\n # Only add the suffix if the label does not end in\n # punctuation.\n if self.label_suffix:\n if label[-1] not in ':?.!':\n label += self.label_suffix\n\n label = bf.label_tag(label,\n attrs={'class': 'control-label'}) or ''\n else:\n label = ''\n\n if field.help_text:\n help_text = help_text_html % force_unicode(field.help_text)\n else:\n help_text = u''\n\n if bf_errors:\n errors = u' '.join([error_row % force_unicode(error)\n for error in bf_errors])\n else:\n errors = u''\n\n if is_boolean:\n output.append(boolean_row % {\n 'errors': errors,\n 'label_and_field': force_unicode(label),\n 'help_text': help_text,\n 'html_class_attr': html_class_attr\n })\n else:\n output.append(normal_row % {\n 'errors': errors,\n 'label': force_unicode(label),\n 'field': unicode(bf),\n 'help_text': help_text,\n 'html_class_attr': html_class_attr\n })\n\n if top_errors:\n output.insert(0, error_row % force_unicode(top_errors))\n\n if hidden_fields: # Insert any hidden fields in the last row.\n str_hidden = u''.join(hidden_fields)\n if output:\n last_row = output[-1]\n # Chop off the trailing row_ender (e.g. '</td></tr>') and\n # insert the hidden fields.\n if not last_row.endswith(row_ender):\n # This can happen in the as_p() case (and possibly others\n # that users write): if there are only top errors, we may\n # not be able to conscript the last row for our purposes,\n # so insert a new, empty row.\n last_row = (normal_row % {'errors': '', 'label': '',\n 'field': '', 'help_text': '',\n 'html_class_attr': html_class_attr})\n output.append(last_row)\n output[-1] = last_row[:-len(row_ender)] + str_hidden + row_ender\n else:\n # If there aren't any rows in the output, just append the\n # hidden fields.\n output.append(str_hidden)\n return mark_safe(u'\\n'.join(output))",
"def test_as_fieldset(self):\n # form._html_output(self, row_tag, col_head_tag, col_tag, single_col_tag, col_head_data, col_data,\n # help_text_br, errors_on_separate_row, as_type=None, strict_columns=False)\n pass",
"def set_error_page(self, html):\n return self.manager.set_error_page(self, html)",
"def error_format(self, as_type, error, **kwargs):\n error = str(error)\n multi_field_row, txt, attr = None, '', ''\n errors_own_row = kwargs.get('errors_on_separate_row', None)\n errors_own_row = True if as_type == 'as_p' and errors_own_row is None else errors_own_row\n context = 'default_row' if errors_own_row else 'default'\n if issubclass(self.form.__class__, FormFieldsetMixIn):\n context = 'special'\n multi_field_row = kwargs.get('multi_field_row', False)\n if errors_own_row:\n context = 'row_multi' if multi_field_row else 'row'\n tag = kwargs.get('col_tag', 'span') if multi_field_row else kwargs.get('single_col_tag', '')\n if as_type in ('as_table', 'table'):\n tag = 'td'\n colspan = 2 if multi_field_row else 2 * kwargs.get('col_count', 1)\n attr += ' colspan=\"{}\"'.format(colspan)\n txt = error if not tag else self.form._html_tag(tag, error, attr) # used if as_type not in format_error\n\n format_error = {\n 'as_table': {\n 'default': '%s',\n 'default_row': '<tr><td colspan=\"2\">%s</td></tr>',\n 'normal_row': '<tr%(html_class_attr)s><th>%(label)s</th><td>%(errors)s%(field)s%(help_text)s</td></tr>',\n 'special': '%s',\n 'row': '<tr><td%s>%s</td></tr>',\n 'row_multi': '<td%s>%s</td>',\n 'special_col_data': '%(errors)s%(field)s%(help_text)s',\n },\n 'as_ul': {\n 'default': '%s',\n 'default_row': '<li>%s</li>',\n 'normal_row': '<li%(html_class_attr)s>%(errors)s%(label)s %(field)s%(help_text)s</li>',\n 'special': '%s',\n 'row': '<li>%s</li>',\n 'row_multi': '<span>%s</span>',\n 'special_col_data': '%(errors)s%(label)s %(field)s%(help_text)s',\n },\n 'as_p': {\n 'default': '%s',\n 'default_row': '%s', # errors_on_separate_row=True is the default only for 'as_p'.\n 'normal_row': '<p%(html_class_attr)s>%(label)s %(field)s%(help_text)s</p>',\n 'special': '%s',\n 'row': '<p>%s</p>',\n 'row_multi': '<span>%s</span>',\n 'special_col_data': '%(label)s %(field)s%(help_text)s',\n },\n 'as_fieldset': {\n 'default': '',\n 'default_row': '',\n 'normal_row': '',\n 'special': '%s',\n 'row': '<p>%s</p>',\n 'row_multi': '<span>%s</span>',\n 'special_col_data': '%(errors)s%(label)s %(field)s%(help_text)s',\n },\n }\n if as_type in format_error:\n error = (attr, error) if attr else error\n txt = format_error[as_type][context] % error\n if errors_own_row and not multi_field_row:\n txt += '\\n'\n return txt",
"def test_html_output_formfieldset_use_focus_if_present(self):\n original_focus_called = self.form.called_assign_focus_field\n for as_type in ('as_p', 'as_ul', 'as_table', 'as_fieldset'):\n self.form.called_assign_focus_field = False\n html_output = getattr(self.form, as_type)()\n message = \"The FormFieldsetMixIn new _html_output failed on {}\".format(as_type)\n self.assertTrue(self.form.called_assign_focus_field, message)\n self.assertIsNotNone(html_output)\n\n self.form.called_assign_focus_field = original_focus_called",
"def test_top_errors_has_hidden_field_errors(self):\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form._errors = ErrorDict()\n self.form.cleaned_data = {}\n name = 'hide_field'\n test_error = \"This is a test error. \"\n expected = self.form.error_class(error_class='nonfield')\n expected.append(f'(Hidden field {name}) {test_error}')\n self.form.add_error(name, test_error)\n self.form.make_fieldsets()\n top_errors = self.form._fs_summary['top_errors']\n\n self.assertIn(name, self.form._errors)\n self.assertEqual(expected, top_errors)\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def decorate_error(self, element, error):\n if error is None:\n return element\n\n div = self.div(class_='nagare-error-input')\n div.append(element)\n\n return self.div(\n div,\n self.div(error, class_='nagare-error-message'),\n class_='nagare-error-field'\n )",
"def test_html_output_default_use_focus_if_present(self):\n original_focus_called = self.form.called_assign_focus_field\n for as_type in ('as_p', 'as_ul', 'as_table'):\n self.form.called_assign_focus_field = False\n html_output = getattr(self.form, as_type + '_old')()\n message = \"The FormFieldsetMixIn OLD _html_output failed on {}\".format(as_type)\n self.assertTrue(self.form.called_assign_focus_field, message)\n self.assertIsNotNone(html_output)\n\n self.form.called_assign_focus_field = original_focus_called",
"def test_error_html_using_patch(self):\n pass",
"def set_error_page(self, loadbalancer, html):\n return loadbalancer.set_error_page(html)",
"def display_errors(self):\r\n\r\n def format_name(field_name):\r\n \"\"\"Formats field names for error display\"\"\"\r\n if field_name == \"celebration_tier\":\r\n return \"{wLargesse{n\"\r\n return \"{w%s{n\" % field_name.capitalize()\r\n\r\n msg = \"Please correct the following errors:\\n\"\r\n msg += \"\\n\".join(\r\n \"%s: {r%s{n\" % (format_name(field), \", \".join(errs))\r\n for field, errs in self.errors.items()\r\n )\r\n return msg",
"def __showError(self, out):\n self.errorGroup.show()\n self.errors.insertPlainText(Utilities.filterAnsiSequences(out))\n self.errors.ensureCursorVisible()\n \n QCoreApplication.processEvents()",
"def test_error_html_using_options(self):\n pass",
"def _render_errors(field):\n template = '{0}/layout/field_errors.html'.format(getattr(settings, 'CRISPY_TEMPLATE_PACK', 'bootstrap3'))\n return render_to_string(template, {\n 'field': field,\n 'form_show_errors': True,\n })",
"def setup_error_data(self, field_setup, error_names, is_table=False, col_tag='span', single_col_tag=''):\n backup_fieldset_fields = [\n ('first', 'second'),\n 'billing_address_1',\n ('billing_city', 'billing_country_area', 'billing_postcode'),\n 'last',\n ]\n field_setup = field_setup or backup_fieldset_fields\n error_names = set(error_names or flatten(field_setup))\n col_count = max([1 if isinstance(ea, str) else len(ea) for ea in field_setup])\n error_txt = \"This is a {} test error. \"\n row_info = []\n for row in field_setup:\n if isinstance(row, str):\n row = [row]\n multi_col_row = len(row) > 1\n if is_table:\n cur_tag = 'td'\n error_settings = (cur_tag, multi_col_row, col_count, True, True)\n attr = ' colspan=\"{}\"'.format(2 if multi_col_row else 2 * col_count)\n else:\n cur_tag = col_tag if multi_col_row else single_col_tag\n error_settings = (cur_tag, multi_col_row, col_count, False, False)\n attr = ''\n error_list = [error_txt.format(name) if name in error_names else '' for name in row]\n columns = [{'errors': ea} for ea in error_list]\n expected = [err if not cur_tag else self.form._html_tag(cur_tag, err, attr) for err in error_list]\n if all(ea == '' for ea in error_list):\n expected = []\n actual = self.form.get_error_data(columns, error_settings)\n row_summary = {'expected': expected, 'actual': actual, 'field_names': row, 'settings': error_settings}\n row_summary['columns'] = columns\n row_info.append(row_summary)\n return row_info",
"def render_form_content(self):\n return mark_safe(self.render_as_object() + self.render_missing_fields())",
"def show_errors(self):\n\n if self.errors:\n print('Clean error in:')\n for file in self.errors:\n print(' %s' % file)",
"def enrich_errors(self, run):\n return run",
"def multi_col_error_format(self, as_type, errors, **kwargs):\n error_data = [self.error_format(as_type, error, **kwargs) for error in errors]\n row_tag = 'tr' if as_type == 'as_table' else 'li' if as_type == 'ul' else 'p'\n row_tag = kwargs.get('row_tag', row_tag)\n error_row = self.form._html_tag(row_tag, ' '.join(error_data))\n return error_row",
"def show_errors(self, view, output):\n errors = self.compiler_variant.errors_from_output(output)\n self.error_vis.generate(view, errors)\n self.error_vis.show_regions(view)",
"def test_prep_fields_called_html_output(self):\n pass",
"def test_form_main_rows_html_fieldset(self):\n # form.form_main_rows(self, html_args, fieldsets, form_col_count)\n # html_args = (row_tag, col_head_tag, col_tag, single_col_tag, as_type, all_fieldsets)\n pass",
"def errorbars (self):\n return self._errorbars",
"def add_error(self, content):\n self._add_content(html_error(content))",
"def set_error_page(self, loadbalancer, html):\n uri = \"/loadbalancers/%s/errorpage\" % utils.get_id(loadbalancer)\n req_body = {\"errorpage\": {\"content\": html}}\n resp, body = self.api.method_put(uri, body=req_body)\n return body",
"def render_mainpageerror(errormsg) -> 'html':\n return render_template('mainpage.html',\n title='Word association',\n analyse=errormsg)",
"def __html__(self):\n return self.html",
"def get_wtf_errors(self, wtf_errors):\n\t\tmessages = []\n\t\tmessages.append('<ol class=\"wtf-errors\">')\n\t\tfor field, errors in wtf_errors.iteritems():\n\t\t\tmessages.append(\"<li>\"+field+\": <br />\")\n\t\t\tfor error in errors:\n\t\t\t\tmessages.append(\"— \"+error+ \"<br />\")\n\t\t\tmessages.append(\"</li>\")\n\t\tmessages.append(\"</ol>\")\n\t\treturn \"\".join(messages)",
"def errors(self):\n raise NotImplementedError",
"def render_errors(form):\n return {\n \"form\": form\n }"
] | [
"0.66065264",
"0.6020077",
"0.598511",
"0.5979558",
"0.5977636",
"0.5950189",
"0.58260643",
"0.5744498",
"0.5719048",
"0.5718157",
"0.5701717",
"0.5622944",
"0.5612383",
"0.5560728",
"0.55581754",
"0.55074865",
"0.54561716",
"0.54443824",
"0.54206306",
"0.5382315",
"0.5365857",
"0.53466773",
"0.5337886",
"0.5293487",
"0.5282722",
"0.5263823",
"0.5238976",
"0.52185184",
"0.5183139",
"0.5146595"
] | 0.7641828 | 0 |
When there are no errors, and only hidden fields, the form should still include the hidden fields. | def test_when_only_hidden_fields(self):
original_fields = self.form.fields
test_fields = deepcopy(original_fields)
test_fields = {name: field for name, field in test_fields.items() if isinstance(field, CharField)}
for name, field in test_fields.items():
widget = field.hidden_widget
widget = widget()
if field.localize:
widget.is_localized = True
widget.is_required = field.required
extra_attrs = field.widget_attrs(widget)
if extra_attrs:
widget.attrs.update(extra_attrs)
field.widget = widget
self.form.fields = test_fields
self.form.make_fieldsets()
expected = ''.join(self.form._fs_summary['hidden_fields'])
self.assertEqual([], self.form._fieldsets)
for as_type in ('as_p', 'as_ul', 'as_table', 'as_fieldset'):
output = getattr(self.form, as_type)()
message = "Hidden fields not found in output {}: \n\n{} \n\n{}".format(as_type.upper(), expected, output)
self.assertIn(expected, output, message)
self.form.fields = original_fields | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_make_form_hidden():",
"def form_Hidden(request):\n schema = schemaish.Structure()\n schema.add('Visible', schemaish.String())\n schema.add('Hidden', schemaish.String())\n\n form = formish.Form(schema, 'form')\n form['Hidden'].widget = formish.Hidden()\n return form",
"def test_top_errors_has_hidden_field_errors(self):\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form._errors = ErrorDict()\n self.form.cleaned_data = {}\n name = 'hide_field'\n test_error = \"This is a test error. \"\n expected = self.form.error_class(error_class='nonfield')\n expected.append(f'(Hidden field {name}) {test_error}')\n self.form.add_error(name, test_error)\n self.form.make_fieldsets()\n top_errors = self.form._fs_summary['top_errors']\n\n self.assertIn(name, self.form._errors)\n self.assertEqual(expected, top_errors)\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def clean_form(self):\n\n for condition in self.conditional_rules:\n\n all_conditions_passed = True\n\n # Only check if the field is required\n field_required = condition['required']\n if field_required:\n action = condition['action']\n\n for cond in condition['conditions']:\n condition_rule = cond['rule']\n condition_value = cond['value']\n condition_field_value = self.cleaned_data.get(cond['field_name'], None)\n\n all_conditions_passed = conditions_passed(condition_rule, condition_value, condition_field_value)\n if not all_conditions_passed:\n break\n\n if not all_conditions_passed and action == consts.FIELD_ACTION_SHOW:\n if condition['field_name'] in self._errors:\n del self._errors[condition['field_name']]\n elif all_conditions_passed and action == consts.FIELD_ACTION_HIDE:\n if condition['field_name'] in self._errors:\n del self._errors[condition['field_name']]\n\n return self.cleaned_data",
"def set_form_hidden_fields(formset, fields_to_show):\n for form in formset:\n for field in form.fields:\n if not any(field in s for s in fields_to_show):\n form.fields[field].widget = forms.HiddenInput()",
"def form_invalid(self, form, request):\n return",
"def form_invalid(self, form, request):\n return",
"def test_hidden_fields_at_bottom(self):\n hidden_fields = self.form.hidden_fields() # The boundfield objects for all hidden fields.\n str_hidden = ''.join(str(bf) for bf in hidden_fields)\n self.assertTrue(str_hidden, \"There are no hidden fields to confirm they were included correctly. \")\n for as_type in ('as_p', 'as_ul', 'as_table', 'as_fieldset'):\n output = getattr(self.form, as_type)()\n last_row = output.split('\\n')[-1]\n message = \"Hidden fields not found in final HTML row for {}\".format(as_type.upper())\n self.assertIn(str_hidden, last_row, message)",
"def full_clean(self):\n self._errors = ErrorDict()\n if not self.is_bound: # Stop further processing.\n return\n self.cleaned_data = {}\n if self.empty_permitted and not self.has_changed():\n self.cleaned_data = None\n return\n for name, field in self.fields.items():\n self.clean_field(name, field)\n try:\n self.cleaned_data = self.clean()\n except ValidationError, e:\n self._errors[NON_FIELD_ERRORS] = e.messages\n if self._errors:\n delattr(self, 'cleaned_data')",
"def set_form_hidden_fields_hidden_fields(formset, fields_to_hide):\n for form in formset:\n for field in form.fields:\n if field in fields_to_hide:\n form.fields[field].widget = forms.HiddenInput()",
"def update_only_validator(form):\n return \"form_result\" not in form.__dict__",
"def test_hidden_field():",
"def form_valid(self, form):\n return super().form_valid(form)",
"def test_raises_if_missed_fields(self):\n name = 'second'\n self.form.called_handle_modifiers = False\n remove = {'remove_field': name}\n self.form.handle_modifiers({}, [], **remove)\n self.assertNotIn(name, self.form.fields)\n self.assertIn(name, self.form.hold_field)\n message = \"Some unassigned fields, perhaps some added during handle_modifiers. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets(add_field=name)\n self.form.called_handle_modifiers = False",
"def form_valid(self, form):\n if self.fields is None:\n self.object.__dict__.update({\n field.name:form.cleaned_data[field.name] for field in form.visible_fields()\n })\n else:\n self.object.__dict__.update({\n field:form.cleaned_data[field] for field in self.fields\n })\n self.object.save()\n if self.request.is_ajax():\n return self.ajax_form_valid()\n else:\n return HttpResponseRedirect(self.get_success_url())",
"def test_blank(self):\n form_data = self.form_data('')\n form = self.form(data=form_data, user=self.u)\n self.assertFalse(form.is_valid())",
"def clean(self):\n cleaned_data = super().clean()\n if any(self.errors):\n # Don't bother validating unless each field is valid on its own\n return\n if not self.household.editing:\n raise forms.ValidationError(\"Household is not in editing mode.\")",
"def clean(self):\n\n self.cleaned_data = super(RoomForm, self).clean()\n\n cleaned_data = self.cleaned_data.copy()\n\n if cleaned_data.get(\"trial\") is None:\n self.cleaned_data[\"trial\"] = False\n else:\n cleaned_data.pop(\"trial\")\n\n if not all(cleaned_data.get(field) for field in cleaned_data.keys()):\n\n raise forms.ValidationError(\n message=\"You must fill in all the required fields!\",\n )",
"def test_unbound_form(self):\r\n self.assertTrue(self.elements, 'No input fields in form')\r\n self.assertFalse(self.unbound_form.is_bound)\r\n self.check_form_fields(self.unbound_form)\r\n self.check_form_fields(self.unbound_form.sub1)\r\n self.check_form_fields(self.unbound_form.sub2)",
"def clean(self):\r\n cleaned_data = super(RPEventCreateForm, self).clean()\r\n self.check_risk()\r\n self.check_costs()\r\n self.check_location_or_plotroom()\r\n return cleaned_data",
"def _is_form_filled_out(self):\n\t\tif self.entry_amount.get() == \"\":\n\t\t\treturn False\n\n\t\tif self.selected_food.get() == \"Select food\":\n\t\t\treturn False\n\n\t\treturn True",
"def test_checkout_renders_form(self):\n self.fill_session_cart()\n response = self.client.get(self.CHECKOUT_URL)\n rendered_fields = list(response.context['form'].fields.keys())\n for field in self.CHECKOUT_FIELDS:\n rendered_fields.remove(field)\n self.assertEqual(len(rendered_fields), 0)",
"def clean(self):\n return self.cleaned_data",
"def _clean(self):\n return self._cleaned_data",
"def test_handle_removals_missing_removed_fields(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n self.form.remove_field_names = []\n if hasattr(self.form, 'removed_fields'):\n del self.form.removed_fields\n result = self.form.handle_removals(fields)\n\n self.assertTrue(hasattr(self.form, 'removed_fields'))\n self.assertEqual(len(original_fields), len(result))\n self.assertEqual(0, len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(original_fields, result)\n self.assertIs(fields, result)",
"def test_dont_show_hidden_fields(self):\n class ExampleSerializer(serializers.Serializer):\n integer_field = serializers.IntegerField(max_value=10)\n hidden_field = serializers.HiddenField(default=1)\n\n class ExampleView(views.APIView):\n \"\"\"Example view.\"\"\"\n def post(self, request):\n pass\n\n def get_serializer(self):\n return ExampleSerializer()\n\n view = ExampleView.as_view()\n response = view(request=request)\n assert response.status_code == status.HTTP_200_OK\n assert set(response.data['actions']['POST'].keys()) == {'integer_field'}",
"def test_no_error_handle_flag_field(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n new_cleaned_data = {self.form.name_for_user: 'test_value', self.form.name_for_email: 'test_value'}\n new_cleaned_data[self.form.USERNAME_FLAG_FIELD] = True # False\n user_field = self.form.computed_fields.pop(self.form.name_for_user, None)\n self.form.fields.update({self.form.name_for_user: user_field})\n email_field = self.form.fields[self.form.name_for_email]\n email_field.initial = new_cleaned_data[self.form.name_for_email]\n self.form.cleaned_data = new_cleaned_data.copy()\n expected = {}\n actual = self.form.handle_flag_field(self.form.name_for_email, self.form.name_for_user)\n\n self.assertIsNotNone(user_field)\n self.assertFalse(email_field.has_changed(email_field.initial, self.form.cleaned_data[self.form.name_for_email]))\n self.assertEqual(expected, actual)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def clean(self):\n super(RequireOneFormSet, self).clean()\n for error in self.errors:\n if error:\n return\n completed = 0\n for cleaned_data in self.cleaned_data:\n # form has data and we aren't deleting it.\n if cleaned_data and not cleaned_data.get('DELETE', False):\n completed += 1\n\n if completed < 1:\n raise forms.ValidationError(\"At least one %s is required.\" %\n self.model._meta.object_name.lower())",
"def test_charter_form_excluded_fields(self):\n\n charter_form = CharterForm()\n self.assertNotIn(\"created_at\", charter_form.fields)",
"def form_invalid(self, form, cruiseday_form, participant_form, document_form, equipment_form, invoice_form):\r\n\t\tprint(cruiseday_form)\r\n\t\tprint(document_form)\r\n\t\tprint(equipment_form)\r\n\t\tprint(invoice_form)\r\n\t\treturn self.render_to_response(\r\n\t\t\tself.get_context_data(\r\n\t\t\t\tform=form,\r\n\t\t\t\tcruiseday_form=cruiseday_form,\r\n\t\t\t\tparticipant_form=participant_form,\r\n\t\t\t\tdocument_form=document_form,\r\n\t\t\t\tequipment_form=equipment_form,\r\n\t\t\t\tinvoice_form=invoice_form,\r\n\t\t\t\tis_NTNU=self.request.user.userdata.organization.is_NTNU,\r\n\t\t\t\tbilling_type=\"auto\",\r\n\t\t\t\tis_invalid=True,\r\n\t\t\t)\r\n\t\t)"
] | [
"0.68661916",
"0.6811355",
"0.67987543",
"0.6677568",
"0.64834374",
"0.6395069",
"0.6395069",
"0.6357457",
"0.6294517",
"0.6206772",
"0.61329913",
"0.60750717",
"0.60695505",
"0.60664195",
"0.60267085",
"0.59971064",
"0.592704",
"0.5909231",
"0.5896396",
"0.58840674",
"0.5853841",
"0.5841313",
"0.58276194",
"0.5807597",
"0.5800362",
"0.5782326",
"0.5772247",
"0.5768304",
"0.57442206",
"0.5737372"
] | 0.69236904 | 0 |
The as_fieldset method returns the expected HTML content. | def test_as_fieldset(self):
# form._html_output(self, row_tag, col_head_tag, col_tag, single_col_tag, col_head_data, col_data,
# help_text_br, errors_on_separate_row, as_type=None, strict_columns=False)
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render_change_form_fieldset(context, fieldset):\n return fieldset.render(context)",
"def test_form_main_rows_html_fieldset_has_container(self):\n # form.form_main_rows(self, html_args, fieldsets, form_col_count)\n # html_args = (row_tag, col_head_tag, col_tag, single_col_tag, as_type, all_fieldsets)\n pass",
"def show_fieldsetform(form):\n return {'form': form, 'required_fields': True}",
"def test_html_output_formfieldset_use_focus_if_present(self):\n original_focus_called = self.form.called_assign_focus_field\n for as_type in ('as_p', 'as_ul', 'as_table', 'as_fieldset'):\n self.form.called_assign_focus_field = False\n html_output = getattr(self.form, as_type)()\n message = \"The FormFieldsetMixIn new _html_output failed on {}\".format(as_type)\n self.assertTrue(self.form.called_assign_focus_field, message)\n self.assertIsNotNone(html_output)\n\n self.form.called_assign_focus_field = original_focus_called",
"def test_form_main_rows_html_fieldset(self):\n # form.form_main_rows(self, html_args, fieldsets, form_col_count)\n # html_args = (row_tag, col_head_tag, col_tag, single_col_tag, as_type, all_fieldsets)\n pass",
"def render(self):\n content = \"<fieldset>\\n<legend>\" + self._title + \"</legend>\\n\"\n for item in self._items:\n val = self._items.get(item)\n title = val[0]\n is_sel = val[1]\n name = self._name + \"_chk_\" + item\n lbl_name = self._name + \"_lbl_\" + item\n label = \"<label for='\" + name + \"' id='\" + lbl_name + \"' >\"\\\n + (title if title is not None else item) + \"</label>\"\n checkbox = \"<input id='\" + name + \"' type='checkbox'\"\\\n + (\" checked\" if is_sel else \"\")\\\n + \" name='\" + self._name + \"_chk'\"\\\n + \" onclick='\" + self._attach_onclick(item) + \"' />\"\n content += \"\\n\" + label + \"\\n\" + checkbox\n self._widget_content = content + \"\\n</fieldset>\"\\\n + self._attach_script() + \"\\n\"\\\n + self._attach_polling()\n return self._widget_content",
"def test_construct_fieldset_tag(attributes):\n fset = FieldSet(**attributes)\n assert fset.construct() == fieldset.render(attributes)",
"def render(self):\n content = \"<fieldset>\\n<legend>\" + self._title + \"</legend>\\n\"\n for item in self._items:\n val = self._items.get(item)\n title = val[0]\n is_sel = val[1]\n name = self._name + \"_rd_\" + item\n lbl_name = self._name + \"_lbl_\" + item\n label = \"<label for='\" + name + \"' id='\" + lbl_name + \"' >\"\\\n + (title if title is not None else item) + \"</label>\"\n radio = \"<input id='\" + name + \"' type='radio'\"\\\n + (\" checked\" if is_sel else \"\")\\\n + \" name='\" + self._name + \"_rd'\"\\\n + \" onclick='\" + self._attach_onclick(item) + \"' />\"\n content += \"\\n\" + label + \"\\n\" + radio\n self._widget_content = content + \"\\n</fieldset>\"\\\n + self._attach_script() + \"\\n\"\\\n + self._attach_polling()\n return self._widget_content",
"def test_form_main_rows_simple(self):\n # TODO: Better Test for this. After a lot of setup, the following is nearly a copy of tested code.\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n self.form.make_fieldsets()\n fieldsets = deepcopy(self.form._fieldsets)\n for as_type in ('p', 'ul', 'fieldset', 'table'):\n all_fieldsets = True if as_type == 'fieldset' else False\n form_col_count = 1 if all_fieldsets else self.form._fs_summary['columns']\n errors_on_separate_row = False\n help_tag, help_text_br = 'span', as_type == 'table'\n if as_type == 'table':\n row_tag, col_tag, single_col_tag, col_head_tag = 'tr', 'td', 'td', 'th'\n col_double, allow_colspan, attr_on_lonely_col = True, True, True\n col_head_data = '%(label)s'\n col_data = '%(errors)s%(field)s%(help_text)s'\n else:\n row_tag = 'li' if as_type == 'ul' else 'p'\n col_tag, single_col_tag, col_head_tag = 'span', '', None\n col_double, allow_colspan, attr_on_lonely_col = False, False, False\n col_head_data = ''\n col_data = '%(errors)s%(label)s %(field)s%(help_text)s'\n if as_type == 'p':\n col_data = '%(label)s %(field)s%(help_text)s'\n errors_on_separate_row = True\n html_col_tags = (col_head_tag, col_tag, single_col_tag)\n col_format, single_col_format = self.form.column_formats(*html_col_tags, col_head_data, col_data)\n for fieldset_label, opts in fieldsets:\n col_count = opts['column_count'] if fieldset_label else form_col_count\n format_tags = (col_format, single_col_format, row_tag, col_tag, single_col_tag, help_tag, help_text_br)\n settings = (errors_on_separate_row, {}, col_count, allow_colspan, col_double, attr_on_lonely_col)\n opts['row_data'] = self.form.collect_row_data(opts, settings, format_tags)\n html_args = (row_tag, *html_col_tags, as_type, all_fieldsets)\n actual = self.form.form_main_rows(html_args, fieldsets, form_col_count)\n expected = []\n for fieldset_label, opts in fieldsets:\n row_data = opts['row_data']\n if all_fieldsets or fieldset_label is not None:\n fieldset_classes = list(opts.get('classes', []))\n if not fieldset_label and self.form.untitled_fieldset_class:\n fieldset_classes.append(self.form.untitled_fieldset_class)\n fieldset_attr = ' class=\"%s\"' % ' '.join(fieldset_classes) if fieldset_classes else ''\n container = None if as_type in ('p', 'fieldset') else as_type\n data = '\\n'.join(row_data)\n if container:\n container_attr = f' class=\"fieldset_{as_type}\"'\n data = self.form._html_tag(container, data, container_attr) + '\\n'\n legend = self.form._html_tag('legend', fieldset_label) + '\\n' if fieldset_label else ''\n fieldset_el = self.form._html_tag('fieldset', legend + data, fieldset_attr)\n if container:\n row_attr = ' class=\"fieldset_row\"'\n fieldset_el = self.form.make_headless_row(html_args, fieldset_el, form_col_count, '', row_attr)\n expected.append(fieldset_el)\n else:\n expected.extend(row_data)\n self.assertEqual(len(expected), len(actual))\n for expect, got in zip(expected, actual):\n if expect != got:\n print(f\"======================== TEST MAIN ROWS as type: {as_type} ==========================\")\n print(expect)\n print(\"*****************\")\n print(got)\n print(\"-----------------------------------\")\n self.assertEqual(expect, got)\n\n self.form.fieldsets = original_fieldsets",
"def test_overall_make_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def render_form_content(self):\n return mark_safe(self.render_as_object() + self.render_missing_fields())",
"def roles_fieldset(self):\n for role in self._get_roles():\n yield (\n role.id,\n role.name,\n list(tuskar_ui.forms.fieldset(\n self, prefix=get_field_name_from_role_id_and_flavor_id(\n str(role.id)))),\n )",
"def test_make_fieldsets_outcome_order(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'position': None,\n 'fields': [\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n fieldsets[0], fieldsets[1] = fieldsets[1], fieldsets[0]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_computed_fieldsets_structure(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n self.form.make_fieldsets()\n fieldsets = self.form._fieldsets\n each_are_tuples = (isinstance(ea, tuple) for ea in fieldsets)\n correct_fieldset_labels = (isinstance(label, (str, type(None))) for label, opts in fieldsets)\n opts_are_dictionaries = (isinstance(opts, dict) for label, opts in fieldsets)\n required_keys = {'position', 'fields', 'field_names', 'rows', 'column_count', }\n optional_keys = {'classes', 'modifiers', 'row_data', }\n allowed_keys = required_keys | optional_keys\n opt_keys = set(flatten([list(opts.keys()) for lbl, opts, in fieldsets]))\n unaccepted_keys = [key for key in opt_keys if key not in allowed_keys]\n has_required = (all(key in opts for key in required_keys) for lbl, opts in fieldsets)\n self.assertIsInstance(fieldsets, list)\n self.assertTrue(all(each_are_tuples))\n self.assertTrue(all(correct_fieldset_labels))\n self.assertTrue(all(opts_are_dictionaries))\n self.assertEqual(len(unaccepted_keys), 0)\n self.assertFalse(unaccepted_keys)\n self.assertTrue(all(has_required))\n\n self.form.fieldsets = original_fieldsets",
"def as_bootstrap(self):\n top_errors = self.non_field_errors() # Errors that should be displayed above all fields.\n output, hidden_fields = [], []\n normal_row = u'<div%(html_class_attr)s>%(label)s<div class=\"controls\">%(field)s%(help_text)s</div>%(errors)s</div>'\n boolean_row = u'<div%(html_class_attr)s><div class=\"controls\">%(label_and_field)s%(help_text)s</div>%(errors)s</div>'\n error_row = u'<div class=\"alert alert-error\">%s</div>'\n row_ender = u'</div>'\n help_text_html = u'<span class=\"help-inline\">%s</span>'\n errors_on_separate_row = False\n\n for name, field in self.fields.items():\n html_class_attr = ''\n bf = self[name]\n is_boolean = isinstance(field, forms.fields.BooleanField)\n bf_errors = self.error_class([conditional_escape(error) for error in bf.errors]) # Escape and cache in local variable.\n if bf.is_hidden:\n if bf_errors:\n top_errors.extend([u'(Hidden field %s) %s' % (name, force_unicode(e)) for e in bf_errors])\n hidden_fields.append(unicode(bf))\n else:\n # Create a 'class=\"...\"' atribute if the row should have any\n # CSS classes applied.\n css_classes = bf.css_classes(extra_classes='control-group')\n if css_classes:\n html_class_attr = ' class=\"%s\"' % css_classes\n\n if errors_on_separate_row and bf_errors:\n output.append(error_row % force_unicode(bf_errors))\n\n if bf.label:\n label = conditional_escape(force_unicode(bf.label))\n if is_boolean:\n label = bf.label_tag(unicode(bf) + label,\n attrs={'class': 'checkbox'}) or ''\n else:\n # Only add the suffix if the label does not end in\n # punctuation.\n if self.label_suffix:\n if label[-1] not in ':?.!':\n label += self.label_suffix\n\n label = bf.label_tag(label,\n attrs={'class': 'control-label'}) or ''\n else:\n label = ''\n\n if field.help_text:\n help_text = help_text_html % force_unicode(field.help_text)\n else:\n help_text = u''\n\n if bf_errors:\n errors = u' '.join([error_row % force_unicode(error)\n for error in bf_errors])\n else:\n errors = u''\n\n if is_boolean:\n output.append(boolean_row % {\n 'errors': errors,\n 'label_and_field': force_unicode(label),\n 'help_text': help_text,\n 'html_class_attr': html_class_attr\n })\n else:\n output.append(normal_row % {\n 'errors': errors,\n 'label': force_unicode(label),\n 'field': unicode(bf),\n 'help_text': help_text,\n 'html_class_attr': html_class_attr\n })\n\n if top_errors:\n output.insert(0, error_row % force_unicode(top_errors))\n\n if hidden_fields: # Insert any hidden fields in the last row.\n str_hidden = u''.join(hidden_fields)\n if output:\n last_row = output[-1]\n # Chop off the trailing row_ender (e.g. '</td></tr>') and\n # insert the hidden fields.\n if not last_row.endswith(row_ender):\n # This can happen in the as_p() case (and possibly others\n # that users write): if there are only top errors, we may\n # not be able to conscript the last row for our purposes,\n # so insert a new, empty row.\n last_row = (normal_row % {'errors': '', 'label': '',\n 'field': '', 'help_text': '',\n 'html_class_attr': html_class_attr})\n output.append(last_row)\n output[-1] = last_row[:-len(row_ender)] + str_hidden + row_ender\n else:\n # If there aren't any rows in the output, just append the\n # hidden fields.\n output.append(str_hidden)\n return mark_safe(u'\\n'.join(output))",
"def show_fieldsetform_nrf(form):\n return {'form': form, 'required_fields': False}",
"def test_form_main_rows_all_fieldsets_has_container(self):\n # form.form_main_rows(self, html_args, fieldsets, form_col_count)\n # html_args = (row_tag, col_head_tag, col_tag, single_col_tag, as_type, all_fieldsets)\n pass",
"def render(self):\n start_tag = format_html('<div {}>', mark_safe(' '.join(self.field_attrs)))\n output = [start_tag]\n for widget in self:\n output.append(force_text(widget))\n output.append('</div>')\n return mark_safe('\\n'.join(output))",
"def test_prep_fields_called_html_output(self):\n pass",
"def content_to_html(self):\n if self.title != \"\":\n string_title = html_tag(\n plain_to_html(self.title), self.title, self.proc\n )\n string_title = html_heading(string_title, self.level)\n else:\n string_title = html_heading(html_line(\"1\"), self.level)\n\n if self.level == 1: # it's not a sub-analysis\n string_title = html_line_before(string_title, \"5\")\n\n # We render all our content before all our subsections to stop any of\n # our content looking like it belongs to the subsection.\n string_content = \"\".join(self.content)\n for section in self.subsections:\n string_content += section.content_to_html()\n\n return string_title + string_content",
"def make_fields(self):\n #Let's first get fields in material_information printer_information\n metadata = GUI.api.get_metadata()\n field_correct_form = filter(lambda field: field['form_name']=='material_information' or field['form_name'] == 'printer_information', metadata)\n rows_w_fields = []\n for field in field_correct_form:\n #make label\n row = []\n key = field['field_name']\n type = field['field_type']\n row.append(sg.Text(text = field['field_label'], key=key+\"_label\"))#keys for labels are key_label (ex. record_id_label)\n if(type == 'radio' or type == \"dropdown\"):\n options = utils.get_options(field)\n row.append(sg.Combo(options, key=key, disabled= True, metadata=True, enable_events=True))\n elif(type == \"yesno\"):\n options = [\"Yes\", \"No\"]\n row.append(sg.Combo(options, key=key, disabled= True, metadata=True, enable_events=True))\n elif(type == \"text\"):\n row.append(sg.Input(key=key, disabled=True, metadata=True))\n else:#descirptive\n row[0] = sg.Text(text = field['field_label'], key=key, metadata=True)#we only need text in this case\n rows_w_fields.append(row)\n return rows_w_fields",
"def _html(self, parent, group):\r\n return ItemFactory.create(\r\n parent_location=parent.location,\r\n category=\"html\",\r\n display_name=\"Group {} Sees This HTML\".format(group),\r\n data=\"Some HTML for group {}\".format(group),\r\n )",
"def as_table(self, field_name=None):\r\n if field_name is None:\r\n normal_row = u'<tr><th>%(label)s</th><td>%(errors)s%(field)s' \\\r\n u'%(help_text)s</td></tr>'\r\n error_row = u'<tr><td colspan=\"2\">%s</td></tr>'\r\n return self._html_output(normal_row, error_row, '</td></tr>',\r\n u'<br />%s', False)\r\n else:\r\n # Only render a single field as a table row\r\n self.backup_fields = self.fields\r\n self.fields = {\r\n field_name: self.backup_fields[field_name]\r\n }\r\n normal_row = u'<tr><th>%(label)s</th><td>%(errors)s%(field)s' \\\r\n u'%(help_text)s</td></tr>'\r\n error_row = u'<tr><td colspan=\"2\">%s</td></tr>'\r\n result = self._html_output(normal_row, error_row, '</td></tr>',\r\n u'<br />%s', False)\r\n self.fields = self.backup_fields\r\n return result",
"def get_fieldsets(self, request, obj=None):\n return (\n ('Name', {\n 'fields': (\n ('first_name', 'last_name'),)\n }),\n ('IPI', {\n 'fields': (\n ('ipi_name', 'ipi_base'),),\n }),\n ('Societies', {\n 'fields': (\n self.get_society_list(),),\n }),\n ('General agreement', {\n 'fields': (\n ('generally_controlled',\n ('saan', 'publisher_fee'))\n ),\n }),\n )",
"def test_no_empty_sets_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n ('Non_Fields', {\n 'position': 2,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 2)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def get_inner_html(self):\n\n pass",
"def get_html(self):\r\n pass",
"def get_fieldsets(self, request, obj=None):\n if obj:\n return (('Corporate Burn Attribute Summary', {\n \"fields\": ('name', 'description', ('financial_year', 'planned_season'),\n ('last_year', 'last_season',\n 'last_year_unknown', 'last_season_unknown'),\n 'region', 'district', 'location',\n 'forest_blocks',\n ('priority', 'rationale'),\n ('contentious', 'contentious_rationale'),\n 'aircraft_burn',\n # TODO: PBS-1551 # 'allocation',\n 'remote_sensing_priority', 'purposes',\n ('area', 'perimeter', 'treatment_percentage'),\n ('non_calm_tenure','non_calm_tenure_approved','non_calm_tenure_included','non_calm_tenure_value','non_calm_tenure_complete','non_calm_tenure_risks')\n )\n }), ('Other Attributes', {\n \"fields\": ('tenures', 'fuel_types', 'shires',\n 'bushfire_act_zone', 'prohibited_period',\n 'forecast_areas', 'prescribing_officer',\n 'short_code')\n }))\n else:\n return super(PrescriptionAdmin, self).get_fieldsets(request, obj)",
"def get_outer_html(self):\n\n pass",
"def get_formset(self):\n result = generic_inlineformset_factory(\n self.inline_model, **self.get_factory_kwargs()\n )\n return result"
] | [
"0.68415874",
"0.65187925",
"0.64655817",
"0.6356494",
"0.6348469",
"0.63407326",
"0.6289891",
"0.6259091",
"0.58220214",
"0.57917166",
"0.57520664",
"0.5586527",
"0.5541364",
"0.55403435",
"0.55008024",
"0.5432789",
"0.54069513",
"0.52744323",
"0.525591",
"0.52468085",
"0.52234274",
"0.5169209",
"0.5155892",
"0.51474845",
"0.5127316",
"0.5116846",
"0.50876206",
"0.5085826",
"0.5057976",
"0.5049012"
] | 0.8279127 | 0 |
Focus is never assigned to a hidden field when targeted. | def test_focus_not_on_hidden(self):
target = 'hide_field'
field = self.form.fields.get(target, None)
result_name = self.form.assign_focus_field(target)
focused = self.find_focus_field()
self.assertTrue(isinstance(getattr(field, 'widget', None), (HiddenInput, MultipleHiddenInput, )))
self.assertIn(target, self.form.fields)
self.assertEqual(1, len(focused))
self.assertNotEqual(target, focused[0])
self.assertNotEqual(target, result_name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def focus(self):\n raise NotImplementedError",
"def XPLoseKeyboardFocus(inWidget):\n pass",
"def _focus(self, event) -> None:\n self.focus = True",
"def XPSetKeyboardFocus(inWidget):\n pass",
"def setFocus(*args, **kwargs)->None:\n pass",
"def OnSetFocus(self, event):\r\n\r\n self._owner.SetFocus()",
"def start_blur(self):\r\n super(Defocus, self)._start()",
"def XPGetWidgetWithFocus():\n pass",
"def test_focus_not_on_disabled(self):\n target = 'disable_field'\n field = self.form.fields.get(target, None)\n result_name = self.form.assign_focus_field(target)\n focused = self.find_focus_field()\n\n self.assertTrue(field.disabled)\n self.assertIn(target, self.form.fields)\n self.assertEqual(1, len(focused))\n self.assertNotEqual(target, focused[0])\n self.assertNotEqual(target, result_name)",
"def focus_on(self, card_idx: int) -> None:",
"def test_focus_on_limited_fields(self):\n original_named_focus = self.form.named_focus\n original_fields_focus = self.form.fields_focus\n original_given_focus = self.form.given_focus\n original_fields = self.form.fields\n self.form.named_focus = None\n self.form.given_focus = None\n allowed = [name for name, field in self.form.fields.items()\n if not field.disabled and not isinstance(field.widget, (HiddenInput, MultipleHiddenInput))]\n self.assertGreater(len(allowed), 1)\n fields_focus = allowed[1:]\n self.form.fields_focus = fields_focus\n expected = fields_focus[0]\n actual = self.form.assign_focus_field(None, fields=self.form.fields_focus)\n\n self.assertEqual(expected, actual)\n self.assertEqual(self.form.given_focus, actual)\n\n self.form.name_focus = original_named_focus\n self.form.fields_focus = original_fields_focus\n self.form.given_focus = original_given_focus\n self.form.fields = original_fields",
"def edit_widget_focus(self):\n if self.goto:\n self.goto_node()\n self.update_position(self.get_position())",
"def setFocus(*args):",
"def setFocus(*args):",
"def setFocus(*args):",
"def setFocus(*args):",
"def __window_focus(self):\n pass",
"def OnSetFocus(self, event):\r\n\r\n treectrl = self._wnd.GetParent()\r\n select = treectrl.GetSelection()\r\n\r\n # If the window is associated to an item that currently is selected\r\n # (has focus) we don't kill the focus. Otherwise we do it.\r\n if select != self:\r\n treectrl._hasFocus = False\r\n else:\r\n treectrl._hasFocus = True\r\n \r\n event.Skip()",
"def OnSetFocus(self, event):\r\n\r\n treectrl = self._owner\r\n select = treectrl.GetSelection()\r\n\r\n # If the window is associated to an item that currently is selected\r\n # (has focus) we don't kill the focus. Otherwise we do it.\r\n if select != self:\r\n treectrl._hasFocus = False\r\n else:\r\n treectrl._hasFocus = True\r\n \r\n event.Skip()",
"def end_blur(self):\r\n super(Defocus, self)._end()",
"def OnSetFocus(self, event):\r\n\r\n self.Refresh()",
"def force_focus_set(self, event):\n self.focus_set()",
"def HandleFocusIn(self, event: tkEvent):\n pass",
"def hidden(self, val):\n self.set_property(\"Hidden\", val)",
"def onFocus(*args):",
"def onFocus(*args):",
"def onFocus(*args):",
"def onFocus(*args):",
"def field_is_not_hidden_xpath(driver, locator):\n elem = driver.find_element_by_xpath(locator)\n is_hidden = elem.get_attribute(\"style\")\n if is_hidden == 'display: none;':\n log_to_file('Hidden field displayed test failed', 'WARNING')\n return False\n else:\n print \"Hidden field displayed = true\"\n return True",
"def focusOutEvent(self, event):\n self.firefocus.trigger()\n QLineEdit.focusOutEvent(self, event)"
] | [
"0.6382761",
"0.6354733",
"0.6317249",
"0.6208623",
"0.61726147",
"0.60827786",
"0.60427195",
"0.5998974",
"0.5994161",
"0.5970299",
"0.59276265",
"0.59212893",
"0.5848262",
"0.5848262",
"0.5848262",
"0.5848262",
"0.58345133",
"0.58045936",
"0.57720476",
"0.57620573",
"0.5757648",
"0.5744574",
"0.5718577",
"0.5712593",
"0.56476116",
"0.56476116",
"0.56476116",
"0.56476116",
"0.5611345",
"0.560712"
] | 0.7910866 | 0 |
Focus is never assigned to a disabled field when targeted. | def test_focus_not_on_disabled(self):
target = 'disable_field'
field = self.form.fields.get(target, None)
result_name = self.form.assign_focus_field(target)
focused = self.find_focus_field()
self.assertTrue(field.disabled)
self.assertIn(target, self.form.fields)
self.assertEqual(1, len(focused))
self.assertNotEqual(target, focused[0])
self.assertNotEqual(target, result_name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def XPLoseKeyboardFocus(inWidget):\n pass",
"def test_focus_on_limited_fields(self):\n original_named_focus = self.form.named_focus\n original_fields_focus = self.form.fields_focus\n original_given_focus = self.form.given_focus\n original_fields = self.form.fields\n self.form.named_focus = None\n self.form.given_focus = None\n allowed = [name for name, field in self.form.fields.items()\n if not field.disabled and not isinstance(field.widget, (HiddenInput, MultipleHiddenInput))]\n self.assertGreater(len(allowed), 1)\n fields_focus = allowed[1:]\n self.form.fields_focus = fields_focus\n expected = fields_focus[0]\n actual = self.form.assign_focus_field(None, fields=self.form.fields_focus)\n\n self.assertEqual(expected, actual)\n self.assertEqual(self.form.given_focus, actual)\n\n self.form.name_focus = original_named_focus\n self.form.fields_focus = original_fields_focus\n self.form.given_focus = original_given_focus\n self.form.fields = original_fields",
"def _focus(self, event) -> None:\n self.focus = True",
"def start_blur(self):\r\n super(Defocus, self)._start()",
"def test_focus_not_on_hidden(self):\n target = 'hide_field'\n field = self.form.fields.get(target, None)\n result_name = self.form.assign_focus_field(target)\n focused = self.find_focus_field()\n\n self.assertTrue(isinstance(getattr(field, 'widget', None), (HiddenInput, MultipleHiddenInput, )))\n self.assertIn(target, self.form.fields)\n self.assertEqual(1, len(focused))\n self.assertNotEqual(target, focused[0])\n self.assertNotEqual(target, result_name)",
"def focus(self):\n raise NotImplementedError",
"def disable(self):\n self.colour_combo.config(state=tk.DISABLED)\n self.game_name_entry.config(state=tk.DISABLED)\n self.num_tickets_entry.config(state=tk.DISABLED)",
"def XPSetKeyboardFocus(inWidget):\n pass",
"def OnSetFocus(self, event):\r\n\r\n treectrl = self._owner\r\n select = treectrl.GetSelection()\r\n\r\n # If the window is associated to an item that currently is selected\r\n # (has focus) we don't kill the focus. Otherwise we do it.\r\n if select != self:\r\n treectrl._hasFocus = False\r\n else:\r\n treectrl._hasFocus = True\r\n \r\n event.Skip()",
"def OnSetFocus(self, event):\r\n\r\n treectrl = self._wnd.GetParent()\r\n select = treectrl.GetSelection()\r\n\r\n # If the window is associated to an item that currently is selected\r\n # (has focus) we don't kill the focus. Otherwise we do it.\r\n if select != self:\r\n treectrl._hasFocus = False\r\n else:\r\n treectrl._hasFocus = True\r\n \r\n event.Skip()",
"def setFocus(*args, **kwargs)->None:\n pass",
"def force_focus_set(self, event):\n self.focus_set()",
"def OnSetFocus(self, event):\r\n\r\n self._owner.SetFocus()",
"def disable_tk(self):\n self.clear_inputhook()",
"def is_disabled(field):\n if not getattr(field.field, 'editable', True):\n return True\n if getattr(field.field.widget.attrs, 'readonly', False):\n return True\n if getattr(field.field.widget.attrs, 'disabled', False):\n return True\n return False",
"def OnSetFocus(self, event):\r\n\r\n self._hasFocus = True\r\n self.RefreshSelected()\r\n event.Skip()",
"def disableEditing(self, disable):\n self.disabled = disable",
"def set_disabled(self, val):\n self._disabled = val",
"def set_disabled(self, val):\n self._disabled = val",
"def _disable_entry(self):\n self.insert_entry.delete(0, tk.END)\n self.insert_entry.configure(state=tk.DISABLED)\n self.insert_button.configure(state=tk.DISABLED)",
"def AcceptsFocus(self):\n\n return self.IsShown() and self.IsEnabled()",
"def __disableControls(self):\n self.ignoreAll()",
"def run_autofocus(self):\n raise NotImplementedError",
"def OnKillFocus(self, event):\r\n\r\n # We must let the native text control handle focus, too, otherwise\r\n # it could have problems with the cursor (e.g., in wxGTK).\r\n event.Skip()",
"def XPGetWidgetWithFocus():\n pass",
"def AcceptsFocus(self):\r\n\r\n # overridden base class method, allows this ctrl to\r\n # participate in the tab-order, etc. It's overridable because\r\n # of deriving this class from wx.PyScrolledWindow...\r\n return True",
"def OnKillFocus(self, event):\r\n\r\n self._hasFocus = False\r\n self.RefreshSelected()\r\n event.Skip()",
"def setFocus(*args):",
"def setFocus(*args):",
"def setFocus(*args):"
] | [
"0.65576744",
"0.6084644",
"0.60535353",
"0.60353684",
"0.6023091",
"0.5991919",
"0.5899241",
"0.58820546",
"0.5868405",
"0.5863868",
"0.5862695",
"0.5829498",
"0.5777314",
"0.5753486",
"0.5707517",
"0.5685013",
"0.56837887",
"0.5669752",
"0.5669752",
"0.5663315",
"0.56414413",
"0.5634679",
"0.56061095",
"0.55953556",
"0.5591448",
"0.5574042",
"0.55070037",
"0.54958546",
"0.54958546",
"0.54958546"
] | 0.7954488 | 0 |
All fields that previously had focus should have it removed when giving focus to another field. | def test_remove_previous_focus(self):
target_1 = 'generic_field'
result_1 = self.form.assign_focus_field(target_1)
focused_1 = self.find_focus_field()
target_2 = 'another_field'
result_2 = self.form.assign_focus_field(target_2)
focused_2 = self.find_focus_field()
self.assertNotEqual(target_1, target_2)
self.assertIn(target_1, self.form.fields)
self.assertEqual(1, len(focused_1))
self.assertEqual(target_1, focused_1[0])
self.assertEqual(target_1, result_1)
self.assertIn(target_2, self.form.fields)
self.assertEqual(1, len(focused_2))
self.assertEqual(target_2, focused_2[0])
self.assertEqual(target_2, result_2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pop_focus(self):\n self._focus.pop()",
"def OnKillFocus(self, event):\r\n\r\n self.Refresh()",
"def OnKillFocus(self, event):\r\n\r\n self._hasFocus = False\r\n self.RefreshSelected()\r\n event.Skip()",
"def remove_all_fields(self):\n self.fields = None",
"def test_focus_on_limited_fields(self):\n original_named_focus = self.form.named_focus\n original_fields_focus = self.form.fields_focus\n original_given_focus = self.form.given_focus\n original_fields = self.form.fields\n self.form.named_focus = None\n self.form.given_focus = None\n allowed = [name for name, field in self.form.fields.items()\n if not field.disabled and not isinstance(field.widget, (HiddenInput, MultipleHiddenInput))]\n self.assertGreater(len(allowed), 1)\n fields_focus = allowed[1:]\n self.form.fields_focus = fields_focus\n expected = fields_focus[0]\n actual = self.form.assign_focus_field(None, fields=self.form.fields_focus)\n\n self.assertEqual(expected, actual)\n self.assertEqual(self.form.given_focus, actual)\n\n self.form.name_focus = original_named_focus\n self.form.fields_focus = original_fields_focus\n self.form.given_focus = original_given_focus\n self.form.fields = original_fields",
"def clearField(self):\n self.field.setCurrentIndex(0)",
"def end_blur(self):\r\n super(Defocus, self)._end()",
"def del_field_pattern(self):\n self.ui.tableFields.removeRow(self.ui.tableFields.currentRow())",
"def clearField(self):\n self.field.clearFields()",
"def XPLoseKeyboardFocus(inWidget):\n pass",
"def keyboard_clear_focus(self) -> None:\n lib.wlr_seat_keyboard_clear_focus(self._ptr)",
"def clear_field_values(self):\n\t\tlogging.info(\"Clearing values in the field[] dictionary of the object\")\n\t\tlogging.debug(\"Before = \" + str(self.field))\n\t\tfor key, value in self.fields.items():\n\t\t\tself.field[str(key)] = None\n\t\tlogging.debug(\"After = \" + str(self.field))\n\t\treturn",
"def clearField(self):\n self.field.setText(\"\")",
"def reset_inputs(self):\n for widget in self.frame.winfo_children():\n if isinstance(widget, tkinter.Entry):\n widget.delete(0, tkinter.END)\n widget.insert(0, \"\")\n elif isinstance(widget, tkinter.Checkbutton):\n widget.deselect()",
"def start_blur(self):\r\n super(Defocus, self)._start()",
"def test_unchanged_handle_removals(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n self.form.removed_fields = {}\n self.form.remove_field_names = []\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result))\n self.assertEqual(0, len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(original_fields, result)\n self.assertIs(fields, result)",
"def clear_fields(self):\n\n if not self.is_root:\n return\n self.field_data.clear()",
"def clear_new_talk_fields(self):\r\n self.newTalkWidget.talkDetailsWidget.titleLineEdit.clear()\r\n self.newTalkWidget.talkDetailsWidget.presenterLineEdit.clear()\r\n self.newTalkWidget.talkDetailsWidget.descriptionTextEdit.clear()\r\n self.newTalkWidget.talkDetailsWidget.categoryLineEdit.clear()",
"def OnKillFocus(self, event):\r\n\r\n # We must let the native text control handle focus, too, otherwise\r\n # it could have problems with the cursor (e.g., in wxGTK).\r\n event.Skip()",
"def focusOutEvent(self, event):\n self.firefocus.trigger()\n QLineEdit.focusOutEvent(self, event)",
"def clearField(self):\n raise Exception(\"Default clearing method called! Please implement clearing for {0}\".format(self.__class__.__name__))",
"def test_handle_removals_remove_field_names(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n remove_names = ['second', 'last']\n expected_fields = {name: field for name, field in fields.items() if name not in remove_names}\n self.form.removed_fields = {}\n self.form.remove_field_names = remove_names\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result) + len(remove_names))\n self.assertEqual(len(remove_names), len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(expected_fields, result)\n self.assertIs(fields, result)",
"def test_handle_removals_missing_removed_fields(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n self.form.remove_field_names = []\n if hasattr(self.form, 'removed_fields'):\n del self.form.removed_fields\n result = self.form.handle_removals(fields)\n\n self.assertTrue(hasattr(self.form, 'removed_fields'))\n self.assertEqual(len(original_fields), len(result))\n self.assertEqual(0, len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(original_fields, result)\n self.assertIs(fields, result)",
"def hide(self):\n self.row_box.grid_remove()\n self.field_name_box.grid_remove()\n self.field_name_label.grid_remove()\n self.value_box.grid_remove()\n self.active_value_widget.grid_remove()",
"def test_handle_removals_named_fields_not_in_data(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n remove_names = ['second', 'last']\n original_data = self.form.data\n data = original_data.copy()\n data.appendlist(remove_names[1], 'test_data_last')\n data._mutable = False\n self.form.data = data\n expected_fields = {name: field for name, field in fields.items() if name != remove_names[0]}\n self.form.removed_fields = {}\n self.form.remove_field_names = remove_names\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result) + len(remove_names) - 1)\n self.assertEqual(len(remove_names) - 1, len(self.form.removed_fields))\n self.assertEqual(1, len(self.form.remove_field_names))\n self.assertDictEqual(expected_fields, result)\n self.assertIs(fields, result)\n\n self.form.data = original_data",
"def test_handle_removals_missing_remove_field_names(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n if hasattr(self.form, 'remove_field_names'):\n del self.form.remove_field_names\n\n with self.assertRaises(ImproperlyConfigured):\n self.form.handle_removals(fields)",
"def clear_inputs(self):\n self.root.ids.input_title.text, self.root.ids.input_artist.text, self.root.ids.input_year.text = (\"\", \"\", \"\")",
"def on_clearButton_clicked(self):\n self.origEdit.clear()\n self.transEdit.clear()",
"def HandleFocusOut(self, event: tkEvent):\n pass",
"def Clear_input(self):\r\n self.root.ids.place_name.text = '' # Clear input\r\n self.root.ids.place_country.text = ''\r\n self.root.ids.place_priority.text = ''"
] | [
"0.64085096",
"0.6284488",
"0.6279339",
"0.62759113",
"0.62412",
"0.6222219",
"0.61831456",
"0.61306286",
"0.60730654",
"0.60544926",
"0.6027801",
"0.5896498",
"0.58639044",
"0.58150744",
"0.5804271",
"0.5801935",
"0.5785319",
"0.57268244",
"0.5713611",
"0.5705902",
"0.56901664",
"0.5685971",
"0.56232566",
"0.5617475",
"0.5586868",
"0.55167335",
"0.5506665",
"0.55057013",
"0.54983926",
"0.54918134"
] | 0.7392664 | 0 |
Focus assignment can be limited to a subset of form fields by setting 'fields_focus' on form. | def test_focus_on_limited_fields(self):
original_named_focus = self.form.named_focus
original_fields_focus = self.form.fields_focus
original_given_focus = self.form.given_focus
original_fields = self.form.fields
self.form.named_focus = None
self.form.given_focus = None
allowed = [name for name, field in self.form.fields.items()
if not field.disabled and not isinstance(field.widget, (HiddenInput, MultipleHiddenInput))]
self.assertGreater(len(allowed), 1)
fields_focus = allowed[1:]
self.form.fields_focus = fields_focus
expected = fields_focus[0]
actual = self.form.assign_focus_field(None, fields=self.form.fields_focus)
self.assertEqual(expected, actual)
self.assertEqual(self.form.given_focus, actual)
self.form.name_focus = original_named_focus
self.form.fields_focus = original_fields_focus
self.form.given_focus = original_given_focus
self.form.fields = original_fields | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setFocus(*args, **kwargs)->None:\n pass",
"def _focus(self, event) -> None:\n self.focus = True",
"def setFocus(*args):",
"def setFocus(*args):",
"def setFocus(*args):",
"def setFocus(*args):",
"def force_focus_set(self, event):\n self.focus_set()",
"def focus(self):\n raise NotImplementedError",
"def test_focus(self, name=None):\n focus_func = getattr(self.form, 'assign_focus_field', None)\n fields = self.get_current_fields()\n if focus_func and issubclass(self.__class__, FocusMixIn):\n name = name or getattr(self.form, 'named_focus', None)\n expected = focus_func(name, fields)\n else:\n expected = 'username' if 'username' in fields else None\n expected = name or expected or None\n if not expected:\n self.assertTrue(True)\n return\n focus_list = self.find_focus_field()\n self.assertEqual(1, len(focus_list))\n self.assertEqual(expected, focus_list[0])",
"def OnSetFocus(self, event):\r\n\r\n self._owner.SetFocus()",
"def focus_force(self):\n self._canvas.focus_force()",
"def test_remove_previous_focus(self):\n target_1 = 'generic_field'\n result_1 = self.form.assign_focus_field(target_1)\n focused_1 = self.find_focus_field()\n\n target_2 = 'another_field'\n result_2 = self.form.assign_focus_field(target_2)\n focused_2 = self.find_focus_field()\n\n self.assertNotEqual(target_1, target_2)\n self.assertIn(target_1, self.form.fields)\n self.assertEqual(1, len(focused_1))\n self.assertEqual(target_1, focused_1[0])\n self.assertEqual(target_1, result_1)\n self.assertIn(target_2, self.form.fields)\n self.assertEqual(1, len(focused_2))\n self.assertEqual(target_2, focused_2[0])\n self.assertEqual(target_2, result_2)",
"def fl_set_focus_object(ptr_flform, ptr_flobject):\n _fl_set_focus_object = library.cfuncproto(\n library.load_so_libforms(), \"fl_set_focus_object\", \\\n None, [cty.POINTER(xfdata.FL_FORM), cty.POINTER(xfdata.FL_OBJECT)],\n \"\"\"void fl_set_focus_object(FL_FORM * form, FL_OBJECT * obj) \"\"\")\n library.check_if_flinitialized()\n library.verify_flformptr_type(ptr_flform)\n library.verify_flobjectptr_type(ptr_flobject)\n library.keep_elem_refs(ptr_flform, ptr_flobject)\n _fl_set_focus_object(ptr_flform, ptr_flobject)",
"def set_focus_mode(self, focus_mode):\n gevent.spawn(self.focus_mode_task,\n focus_mode)\n self.emit('focusingModeRequested', focus_mode)",
"def setfocus(self, focus):\n self.focus = self.data[focus]\n self.focus_stage = focus\n for k in self.focus.keys():\n setattr(self, k, self.focus[k])",
"def OnSetFocus(self, event):\r\n\r\n self.Refresh()",
"def OnSetFocus(self, event):\r\n\r\n self._hasFocus = True\r\n self.RefreshSelected()\r\n event.Skip()",
"def fl_activate_form(ptr_flform):\n _fl_activate_form = library.cfuncproto(\n library.load_so_libforms(), \"fl_activate_form\", \\\n None, [cty.POINTER(xfdata.FL_FORM)], \\\n \"\"\"void fl_activate_form(FL_FORM * form) \"\"\")\n library.check_if_flinitialized()\n library.verify_flformptr_type(ptr_flform)\n library.keep_elem_refs(ptr_flform)\n _fl_activate_form(ptr_flform)",
"def set_motor_focus_mode(self, motor_name, focus_mode):\n if focus_mode is not None:\n for motor in self.motors_groups:\n motor.set_motor_focus_mode(motor_name, focus_mode)",
"def show_fieldsetform(form):\n return {'form': form, 'required_fields': True}",
"def XPSetKeyboardFocus(inWidget):\n pass",
"def onFocus(*args):",
"def onFocus(*args):",
"def onFocus(*args):",
"def onFocus(*args):",
"def set_focus(self, pos):\n urwid.emit_signal(self, 'focus_change', pos)\n return super(OptionListWalker, self).set_focus(pos)",
"def OnSetFocus(self, event):\r\n\r\n treectrl = self._owner\r\n select = treectrl.GetSelection()\r\n\r\n # If the window is associated to an item that currently is selected\r\n # (has focus) we don't kill the focus. Otherwise we do it.\r\n if select != self:\r\n treectrl._hasFocus = False\r\n else:\r\n treectrl._hasFocus = True\r\n \r\n event.Skip()",
"def set_form_readonly_fields(formset, read_only_fields):\n for form in formset:\n for field in form.fields:\n print(field)\n if any(field in s for s in read_only_fields):\n print(field)\n form.fields[field].widget.attrs['disabled'] = True",
"def find_focus_field(self):\n fields = self.get_current_fields()\n found_names = []\n for field_name, field in fields.items():\n has_focus = field.widget.attrs.get('autofocus', None)\n if has_focus:\n found_names.append(field_name)\n return found_names",
"def OnSetFocus(self, event):\r\n\r\n treectrl = self._wnd.GetParent()\r\n select = treectrl.GetSelection()\r\n\r\n # If the window is associated to an item that currently is selected\r\n # (has focus) we don't kill the focus. Otherwise we do it.\r\n if select != self:\r\n treectrl._hasFocus = False\r\n else:\r\n treectrl._hasFocus = True\r\n \r\n event.Skip()"
] | [
"0.6319066",
"0.59794223",
"0.59114265",
"0.59114265",
"0.59114265",
"0.59114265",
"0.58348966",
"0.5777872",
"0.5764797",
"0.5763939",
"0.5720473",
"0.56244254",
"0.5585515",
"0.55759245",
"0.55622715",
"0.5553491",
"0.55013245",
"0.54972106",
"0.5487783",
"0.5430203",
"0.53828543",
"0.5349344",
"0.5349344",
"0.5349344",
"0.5349344",
"0.5346062",
"0.5199895",
"0.51841575",
"0.5167232",
"0.50879055"
] | 0.77404433 | 0 |
After fields have been formed, get_critical_field should return from fields, not from base_fields. | def test_get_critical_from_existing_fields(self):
name = 'generic_field'
opts = {'names': (name, ), 'alt_field': '', 'computed': False}
expected_field = self.form.fields.get(name, None)
actual_name, actual_field = self.form.get_critical_field(opts['names'])
self.assertEqual(name, actual_name)
self.assertEqual(expected_field, actual_field) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_init_get_critical_for_needed(self):\n # needed_names = [nf for nf in ('country_display', 'country_flag') if nf not in self.form.base_fields]\n # for name in needed_names: name, field = self.get_critical_field(name, name)\n # original_get_critical_field = self.form.get_critical_field\n # self.form.get_critical_field = self.get_critical_field_signal\n print(\"================ TEST INIT GET CRITICAL FOR NEEDED ==================\")\n print(self.form.get_critical_field.__name__)\n # print(getattr(self, 'get_critical_call', 'NOT FOUND'))\n # print(getattr(self.form, 'get_critical_call', 'NOT FOUND'))\n name = 'country_display'\n expected = {'names': name, 'alt_name': name}\n field = self.form.fields.get(name, None) or self.form.computed_fields(name, None)\n response = self.form.get_critical_field(name, name)\n actual = getattr(self, 'get_critical_call', 'NOT FOUND')\n print(\"----------------------------------------\")\n print(response)\n print(expected)\n print(actual)\n # self.assertDictEqual(expected, actual)\n self.assertEqual((name, field), response)\n\n # self.get_critical_field = original_get_critical_field",
"def test_callable_name_get_critical_field(self):\n special = self.get_generic_name\n name, field = self.form.get_critical_field(special)\n expected_name = special()\n expected_field = self.form.fields[expected_name]\n self.assertEqual(expected_name, name)\n self.assertEqual(expected_field, field)",
"def test_raise_on_missing_critical(self):\n name_for_field = 'absent_field'\n field_opts = {'names': (name_for_field, 'absent'), 'alt_field': '', 'computed': False}\n critical_fields = {'absent_field': field_opts}\n with self.assertRaises(ImproperlyConfigured):\n self.form.fields_for_critical(critical_fields)",
"def on_get_field(self, ins, const, obj):\n pass",
"def getFieldInfo(fieldnum):\n try:\n info = _getCampaignDict()[\"c{0}\".format(fieldnum)]\n # Print warning messages if necessary\n if \"preliminary\" in info and info[\"preliminary\"] == \"True\":\n logger.warning(\"Warning: the position of field {0} is preliminary. \"\n \"Do not use this position for your final \"\n \"target selection!\".format(fieldnum))\n return info\n except KeyError:\n raise ValueError(\"Field {0} not set in this version \"\n \"of the code\".format(fieldnum))",
"def get_context_data(self, project_id, category_id, field_id,\n *args, **kwargs):\n field = Field.objects.as_admin(\n self.request.user,\n project_id,\n category_id,\n field_id\n )\n return super(FieldMixin, self).get_context_data(\n project=field.category.project,\n category=field.category,\n field=field,\n is_display_field=(field == field.category.display_field),\n is_expiry_field=(field == field.category.expiry_field),\n *args,\n **kwargs\n )",
"def _get(self, field):\n return super(_Classifier, self)._get(field)",
"def test_use_existing_computed_field_dict(self):\n if isinstance(self.form.computed_fields, list):\n self.form.computed_fields = self.form.get_computed_fields(self.form.computed_fields)\n self.form.fields.update(self.form.computed_fields) # only names in fields included in get_computed_field_names.\n result_names = self.form.get_computed_field_names([], self.form.fields)\n\n self.assertIsInstance(self.form.computed_fields, dict)\n self.assertIn('test_field', result_names)",
"def get_missing_field(self, name):\n source = getattr(self.form, 'removed_fields', {})\n if issubclass(self.form.__class__, ComputedFieldsMixIn):\n source = self.form.computed_fields\n field = source.pop(name, None)\n return field",
"def test_entities__Entity__getRawField__3(entity_with_field, field):\n assert field == entity_with_field.getRawField(field.__name__)",
"def test_raise_on_corrupt_computed_fields(self):\n initial = self.form.computed_fields\n self.form.computed_fields = 'This is a broken value'\n with self.assertRaises(ImproperlyConfigured):\n self.form.get_computed_field_names([], self.form.fields)\n self.form.computed_fields = None\n with self.assertRaises(ImproperlyConfigured):\n self.form.get_computed_field_names([], self.form.fields)\n self.form.computed_fields = initial",
"def test_clean_dependent_fields(self):\n data = self.report_data.copy()\n new_primary_complaint = 'housing'\n data.update({'primary_complaint': new_primary_complaint})\n form = ReportEditForm(data, instance=self.report)\n\n self.assertTrue(form.is_valid())\n self.assertTrue('public_or_private_employer' in form.changed_data)\n self.assertTrue('employer_size' not in form.changed_data)\n for field in Report.PRIMARY_COMPLAINT_DEPENDENT_FIELDS['workplace']:\n self.assertTrue(form.cleaned_data[field] == \"\")",
"def test_fields_updated_with_computed(self):\n pass",
"def test_defining_only_or_defer_on_nonexistant_fields_fails(self):",
"def test_init_update_computed_field_names(self):\n original_request = self.request\n original_form = self.form\n computed = getattr(self.form, 'computed_fields', None)\n get_form = self.make_form_request()\n computed_fields = getattr(get_form, 'computed_fields', None)\n\n self.assertIsNotNone(computed)\n self.assertIsNotNone(computed_fields)\n self.assertIsNotNone(self.form.country_field_name)\n self.assertIn(self.form.country_field_name, computed_fields)\n\n self.request = original_request\n self.form = original_form",
"def critical(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"critical\")",
"def test_get_method(self):\n field = self.base_field\n sch = SchemaField(field)\n self.assertTrue(hasattr(sch, 'get'))\n self.assertEqual(field.get('Name'), sch.get('Name'))\n self.assertEqual(field.get('constraints'), sch.get('constraints'))\n self.assertEqual(None, sch.get('bad_keys'))\n self.assertEqual('default', sch.get('bad_keys', 'default'))",
"def get_field(self, field):\r\n if field not in self.fields:\r\n raise ValueError(\"Invalid field: {}. Must be one of: {}\"\r\n .format(field, self.fields))\r\n sub = set(meta[field] for meta in self.data)\r\n return sub",
"def test_manage_tos_field(self):\n name = self.form.name_for_tos or 'tos_field'\n initial_is_off = self.form.tos_required is False\n found = self.form.fields.get(name, None)\n original_critical = deepcopy(self.form.critical_fields)\n self.form.tos_required = True\n expected = deepcopy(original_critical)\n name = getattr(self.form, 'name_for_tos', None) or ''\n tos_opts = {'names': (name, ), 'alt_field': 'tos_field', 'computed': False}\n tos_opts.update({'name': 'tos_field', 'field': self.form_class.tos_field})\n expected.update(name_for_tos=tos_opts)\n initial_kwargs = {}\n returned_kwargs = self.form.setup_critical_fields(**initial_kwargs)\n actual = self.form.critical_fields\n\n self.assertTrue(initial_is_off)\n self.assertIsNone(found)\n self.assertDictEqual(initial_kwargs, returned_kwargs)\n self.assertDictEqual(expected, actual)\n\n self.form.fields.pop('tos_field', None)\n self.form.tos_required = False\n self.form.critical_fields = original_critical\n reset_kwargs = self.form.setup_critical_fields(**initial_kwargs)\n self.assertDictEqual({}, reset_kwargs)",
"def test_field_compute_method_called_in_clean_computed_fields(self):\n name = 'test_field'\n expected = 'compute_confirmed'\n self.form.test_value = expected\n modified = self.form.test_func(expected)\n original_func = deepcopy(self.form.test_func)\n def pass_through(value): return value\n self.form.test_func = pass_through\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n original_errors = deepcopy(self.form._errors)\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n self.form.cleaned_data = getattr(self.form, 'cleaned_data', {}) # mimic full_clean: cleaned_data is present\n compute_errors = self.form._clean_computed_fields()\n actual = self.form.cleaned_data.get(name, None)\n\n self.assertFalse(compute_errors)\n self.assertEqual(expected, actual)\n\n self.form.test_func = original_func\n restored = self.form.test_func(expected)\n self.assertEqual(modified, restored)\n self.form._errors = original_errors",
"def get_field(self):\n raise DomainError('there is no field associated with %s' % self)",
"def get_field(self):\n raise DomainError('there is no field associated with %s' % self)",
"def _validate_fields(self, change_fields):\n pass",
"def get_field(self, field):\n return self.extra_fields[field]",
"def test_entities__Entity__getField__3(entity_with_field, schemaized_field):\n assert (schemaized_field ==\n entity_with_field.getField(schemaized_field.__name__))",
"def test_get_fields_and_lookups_invalid_lookup(self):\n with self.assertRaises(exceptions.FieldError):\n utils.get_fields_and_lookups(Protected, 'protector__date__hour')",
"def __getattr__(self, fieldname):\n if fieldname in self.record.keys():\n return getattr(self.record, fieldname, '')\n elif fieldname in ['fullname', 'normalized_fullname']:\n return getattr(self, fieldname, '')\n elif fieldname == 'references':\n return self.get_references()\n elif fieldname == 'aanstellingen':\n return self.get_aanstellingen()\n else:\n raise AttributeError",
"def _prepare_entity(self, model_name, entity, fields_id=None):\n logger.debug(\"Preparing %s entity %s\" % (model_name, entity))\n model_pool = self.pool.get(model_name)\n\n if not fields_id:\n fields_id = []\n\n # Before create entity hook\n entity = self._call_hook(model_name, \"before_create_entity\", entity=entity)\n if not entity:\n return entity # Empty, no need to check it, return it\n\n # Check required\n def _check_required():\n model_columns = {}\n required_fields_not_found = []\n model_columns.update(model_pool._columns)\n for inherit_model_name in model_pool._inherits.keys():\n inherit_model_obj = self.pool.get(inherit_model_name)\n model_columns.update(inherit_model_obj._columns)\n for field in model_columns.keys():\n if model_columns[field].required and field not in fields_id:\n if field not in entity.keys():\n if field in model_pool.default_get(self.cr, self.uid, [field]):\n # There is a default value, ignore\n continue\n required_fields_not_found.append(field)\n logger.warn(\"Required field %s not found for %s\" % (field, model_name))\n else:\n value = entity.get(field)\n if value is None or value is False:\n fieldType = model_pool._columns[field]._type\n if fieldType not in ('boolean'):\n required_fields_not_found.append(field)\n logger.warn(\"Required field %s is False or None for %s\" % (field, model_name))\n return required_fields_not_found\n\n required_fields_not_found = _check_required()\n if required_fields_not_found:\n raise Exception(\"Required field(s) not found\")\n else:\n for field in entity.keys():\n fieldType = model_pool._columns[str(field)]._type\n if fieldType in ('one2many', 'many2many'):\n sub_model = model_pool._columns[str(field)]._obj or False\n values = []\n\n # Put in fields_id the name of the fields used for reference between models,\n # to be able to ignore them while checking required fields (because they will not be\n # filled yet\n if fieldType == 'one2many':\n fields_id = model_pool._columns[str(field)]._fields_id or []\n elif fieldType == 'many2many':\n fields_id = []\n if model_pool._columns[str(field)]._id1:\n fields_id.append(model_pool._columns[str(field)]._id1)\n if model_pool._columns[str(field)]._id2:\n fields_id.append(model_pool._columns[str(field)]._id2)\n\n if not isinstance(fields_id, list):\n fields_id = [fields_id]\n\n for sub_entity_dict in entity[field]:\n if not isinstance(sub_entity_dict, dict):\n logger.warning(\"Cannot verify %s/%s values, not dictionary : %s\" % (model_name, field, sub_entity_dict))\n values.append(sub_entity_dict)\n continue\n sub_dict = self._prepare_entity(sub_model, sub_entity_dict, fields_id=fields_id)\n values.append((0, 0, sub_dict))\n entity[field] = values\n\n elif fieldType in ('many2one'):\n if entity[field] and isinstance(entity[field], dict):\n sub_model = model_pool._columns[str(field)]._obj or False\n sub_dict = self._prepare_entity(sub_model, entity[field])\n new_id = self._create_entity(sub_model, sub_dict)\n entity[field] = new_id\n\n logger.debug(\"Entity prepared %s entity %s\" % (model_name, entity))\n return entity",
"def _get_field(self, field_name: str):\n backcompat_prefix = \"extra__grpc__\"\n if field_name.startswith(\"extra__\"):\n raise ValueError(\n f\"Got prefixed name {field_name}; please remove the '{backcompat_prefix}' prefix \"\n \"when using this method.\"\n )\n if field_name in self.extras:\n return self.extras[field_name]\n prefixed_name = f\"{backcompat_prefix}{field_name}\"\n if prefixed_name in self.extras:\n return self.extras[prefixed_name]\n raise KeyError(f\"Param {field_name} not found in extra dict\")",
"def get_ref(self, field):\n if field in self.aux_field_names and not getattr(self, field):\n field = '{}_aux'.format(field)\n return getattr(self, field)"
] | [
"0.7689682",
"0.6882508",
"0.6560968",
"0.6231871",
"0.6030528",
"0.560576",
"0.55169",
"0.5483224",
"0.5480227",
"0.5467454",
"0.5449506",
"0.5420746",
"0.53925157",
"0.53286016",
"0.5262026",
"0.524784",
"0.5220723",
"0.5216728",
"0.5207069",
"0.51940817",
"0.51895905",
"0.51895905",
"0.5172533",
"0.51523757",
"0.5139528",
"0.5126236",
"0.5069559",
"0.50526947",
"0.50416017",
"0.50128305"
] | 0.7971704 | 0 |
If attach_critical_validators cannot access either fields or base_fields, it should raise as needed. | def test_raise_attach_broken(self):
orig_fields = deepcopy(self.form.fields)
orig_base_fields = deepcopy(self.form.base_fields)
self.form.fields = None
self.form.base_fields = None
with self.assertRaises(ImproperlyConfigured):
self.form.attach_critical_validators()
self.form.fields = orig_fields
self.form.base_fields = orig_base_fields | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_raise_on_missing_critical(self):\n name_for_field = 'absent_field'\n field_opts = {'names': (name_for_field, 'absent'), 'alt_field': '', 'computed': False}\n critical_fields = {'absent_field': field_opts}\n with self.assertRaises(ImproperlyConfigured):\n self.form.fields_for_critical(critical_fields)",
"def _validate(self):\n fields, schema = self.__dict__, self._def.default\n extra_fields = fields.viewkeys() - schema.viewkeys()\n if len(extra_fields) > 0:\n raise AttributeError('Fields found that are not in the schema: %r' % (list(extra_fields)))\n for key in fields.iterkeys():\n if type(fields[key]) is not type(schema[key]):\n raise AttributeError('Invalid %s for field \"%s\", should be %s' %\n (type(fields[key]), key, type(schema[key])))",
"def test_defining_only_or_defer_on_nonexistant_fields_fails(self):",
"def _validate_fields(self, change_fields):\n pass",
"def test_get_critical_from_existing_fields(self):\n name = 'generic_field'\n opts = {'names': (name, ), 'alt_field': '', 'computed': False}\n expected_field = self.form.fields.get(name, None)\n actual_name, actual_field = self.form.get_critical_field(opts['names'])\n self.assertEqual(name, actual_name)\n self.assertEqual(expected_field, actual_field)",
"def test_init_get_critical_for_needed(self):\n # needed_names = [nf for nf in ('country_display', 'country_flag') if nf not in self.form.base_fields]\n # for name in needed_names: name, field = self.get_critical_field(name, name)\n # original_get_critical_field = self.form.get_critical_field\n # self.form.get_critical_field = self.get_critical_field_signal\n print(\"================ TEST INIT GET CRITICAL FOR NEEDED ==================\")\n print(self.form.get_critical_field.__name__)\n # print(getattr(self, 'get_critical_call', 'NOT FOUND'))\n # print(getattr(self.form, 'get_critical_call', 'NOT FOUND'))\n name = 'country_display'\n expected = {'names': name, 'alt_name': name}\n field = self.form.fields.get(name, None) or self.form.computed_fields(name, None)\n response = self.form.get_critical_field(name, name)\n actual = getattr(self, 'get_critical_call', 'NOT FOUND')\n print(\"----------------------------------------\")\n print(response)\n print(expected)\n print(actual)\n # self.assertDictEqual(expected, actual)\n self.assertEqual((name, field), response)\n\n # self.get_critical_field = original_get_critical_field",
"def test_raise_on_corrupt_computed_fields(self):\n initial = self.form.computed_fields\n self.form.computed_fields = 'This is a broken value'\n with self.assertRaises(ImproperlyConfigured):\n self.form.get_computed_field_names([], self.form.fields)\n self.form.computed_fields = None\n with self.assertRaises(ImproperlyConfigured):\n self.form.get_computed_field_names([], self.form.fields)\n self.form.computed_fields = initial",
"def test_validators_attach(self):\n field_name = 'generic_field'\n expected = validators.validate_confusables\n field = self.form.fields.get(field_name, None)\n all_validators = field.validators if field else []\n self.assertIn(expected, all_validators)",
"def validate(self) -> None:\n\n if self.field not in self.model.table_fields:\n raise ValueError(f\"Value field {self.field} not present in {self.model.table}\")\n\n if self.pivot:\n if self.pivot not in self.model.table_fields:\n raise ValueError(\n f\"Pivot field {self.pivot} not present in {self.model.table}\"\n )\n\n if self.connector:\n if self.connector not in self.model.table_fields:\n raise ValueError(\n f\"Connector field {self.connector} not present in {self.model.table}\"\n )\n\n for field in self.selectors:\n if field not in self.model.table_fields:\n raise ValueError(f\"Selector field {field} not present in {self.model.table}\")",
"def enforce_required_fields(self, attrs):\n if self.instance is not None:\n return\n # missing_items = {\n # field_name: self.missing_message\n # for field_name in self.fields\n # if field_name not in attrs\n # }\n # if missing_items:\n # raise ValidationError(missing_items, code='required')",
"def _custom_validate_fields(self, issues):\n\n common_section = 'basicinfo'\n\n if self.address is None or self.address == '':\n issues.create(section=common_section,\n field='address',\n code='required')\n\n if self.phone is None or self.phone == '':\n issues.create(section=common_section,\n field='phone',\n code='required')\n elif not phonenumber.to_python(self.phone).is_valid():\n issues.create(section=common_section,\n field='phone',\n code='invalid')\n\n if self.psu_email is None or self.psu_email == '':\n issues.create(section=common_section,\n field='psu_email',\n code='required')\n else:\n try:\n EmailValidator()(self.psu_email)\n if not self.psu_email.endswith('@psu.edu'):\n issues.create(section=common_section,\n field='psu_email',\n code='prohibited')\n except ValidationError:\n issues.create(section=common_section,\n field='psu_email',\n code='invalid')\n\n if self.preferred_email == '':\n # preferred_email is assumed to be psu_email if blank\n pass\n else:\n try:\n EmailValidator()(self.preferred_email)\n except ValidationError:\n issues.create(section=common_section,\n field='preferred_email',\n code='invalid')\n\n if self.psu_id is None or self.psu_id == '':\n issues.create(section=common_section,\n field='psu_id',\n code='required')\n elif not re.match(r'^9\\d{8}$', self.psu_id):\n issues.create(section=common_section,\n field='psu_id',\n code='invalid')\n\n if self.major is None or self.major == '':\n issues.create(section=common_section,\n field='major',\n code='required')\n\n if self.semester_initiated is None:\n issues.create(section=common_section,\n field='semester_initiated',\n code='required')\n elif self.semester_initiated > Semester(self.due_at.date()):\n issues.create(section=common_section,\n field='semester_initiated',\n code='invalid')\n elif self.semester_initiated < Semester(('Spring', 1928)):\n issues.create(section=common_section,\n field='semester_initiated',\n code='invalid')\n\n if self.semester_graduating is None:\n issues.create(section=common_section,\n field='semester_graduating',\n code='required')\n elif self.semester_graduating < Semester(self.due_at.date()):\n issues.create(section=common_section,\n field='semester_graduating',\n code='invalid')\n elif self.semester_graduating > Semester(('Fall', 2099)):\n issues.create(section=common_section,\n field='semester_graduating',\n code='invalid')\n\n if self.cumulative_gpa == None:\n issues.create(section=common_section,\n field='cumulative_gpa',\n code='required')\n elif (self.cumulative_gpa < 0.0 or self.cumulative_gpa > 4.0):\n issues.create(section=common_section,\n field='cumulative_gpa',\n code='invalid')\n\n if self.semester_gpa == None:\n issues.create(section=common_section,\n field='semester_gpa',\n code='required')\n elif (self.semester_gpa < 0.0 or self.semester_gpa > 4.0):\n issues.create(section=common_section,\n field='semester_gpa',\n code='invalid')",
"def run_validation(self, data=empty):\n\n if data is not empty:\n unknown = set(data) - set(self.fields)\n if unknown:\n errors = ['Unknown field: {}'.format(f) for f in unknown]\n raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: errors})\n return super().run_validation(data)",
"def test_raises_on_missing_needed_fields(self):\n test_name = \"impossible_creature_not_present\"\n self.form.constructor_fields = [*self.form.constructor_fields, test_name]\n message = \"The fields for email, username, and constructor must be set in fields. \"\n self.assertNotIn(test_name, self.form.base_fields)\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.confirm_required_fields()",
"def check_for_empties():\n if hasattr(self.instance, 'fields_required_for_publish'):\n errors_for_empties = {\n field_name: try_adding_error_to_field(\n field_name, field_value)\n for (field_name, field_value) in self.data.items()\n if (len(field_value) == 0 or field_value == 'null') and field_name in self.instance.fields_required_for_publish\n }",
"def test_validation_errors_assigned_in_clean_computed_fields(self):\n name = 'test_field'\n message = \"This is the test error on test_field. \"\n response = ValidationError(message)\n expected_compute_errors = ErrorDict({name: response}) # similar to return of _clean_computed_fields\n original_func = deepcopy(self.form.test_func)\n def make_error(value): raise response\n self.form.test_func = make_error\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n self.form.cleaned_data = getattr(self.form, 'cleaned_data', {}) # mimic full_clean: cleaned_data is present\n actual_compute_errors = self.form._clean_computed_fields()\n\n self.assertDictEqual(expected_compute_errors, actual_compute_errors)\n self.form.test_func = original_func",
"def __validate():\n # TODO: implement",
"def run_validation(self, data=empty):\n\n # no idea why there is no such built in feature in DRF\n if data is not empty:\n unknown = set(data) - set(self.fields)\n if unknown:\n errors = ['Unknown field: {}'.format(f) for f in unknown]\n raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: errors})\n return super().run_validation(data)",
"def __validate(self):\n pass",
"def _validate(self):\n pass",
"def _Validate(self):\n # There's some possible conflict with LABEL and ISSUE_DATE\n # If the date exists but the label isn't defined, this property\n # will be ignored\n if (\"ISSUE_DATE\" in self) != (\"LABEL\" in self):\n with IgnoreKeyError:\n del self[\"ISSUE_DATE\"]\n with IgnoreKeyError:\n del self[\"LABEL\"]\n # Also check that both disc and discs exists or neither do\n if self.discs > 1 and \"PART_NUMBER\" not in self:\n raise DiscConfigurationError(\"Number of discs is set but disc number not known\")\n if \"PART_NUMBER\" in self and self.discs < 2:\n raise DiscConfigurationError(\"Disc number is set but number of discs is not known\")\n # Ensure that the original medium is set, if it hasn't been set yet then assume CD\n if \"ORIGINAL_MEDIUM\" not in self:\n self[\"ORIGINAL_MEDIUM\"] = \"CD\"\n elif self[\"ORIGINAL_MEDIUM\"] not in arguments.MEDIUM_CHOICES:\n logging.critical(\"Invalid medium: '%s' - must be one of %s\",\n self['ORIGINAL_MEDIUM'], arguments.MEDIUM_CHOICES)\n raise ValueError(f\"Invalid medium: '{self['ORIGINAL_MEDIUM']}' - must be one of {arguments.MEDIUM_CHOICES}\")\n # At this point it is necessary to require that all the metadata is present\n # These were setup in the constructor as ``None`` so they do exist, but they\n # must have been overridden as non-``None`` values\n # ``required_tags`` holds tag keys which map onto descriptions for error output\n required_tags = {\"TITLE\": \"title\",\n \"ARTIST\": \"artist\",\n \"GENRE\": \"genre\",\n \"DATE_RECORDED\": \"year\"}\n for tag in required_tags:\n if self[tag] is None:\n raise TagNotFoundError(f\"Incomplete metadata - missing {required_tags[tag]}\")\n for key, value in self.items():\n self[key] = value.strip()",
"def validate(self):\n if (self.email_address is None) or (self.name is None):\n raise IOError(\n \"Invalid address detected. Address and name must be given.\"\n )\n if len(self.misc) > 8:\n raise IOError(\n \"Invalid address detected. Too many misc descriptors.\"\n )",
"def test_get_fields_and_lookups_invalid_lookup(self):\n with self.assertRaises(exceptions.FieldError):\n utils.get_fields_and_lookups(Protected, 'protector__date__hour')",
"def _add_error_checks(self, other):\n raise NotImplementedError()",
"def _validate_configurations(self) -> None:\n if self.__exception:\n raise self.__exception",
"def __call__(self, data=None):\n data_combiner = DataCombiner(self.instance, data)\n\n meta = self.instance._meta\n errors = defaultdict(list)\n\n # direct required fields\n for field_name in self.REQUIRED_FIELDS:\n field = meta.get_field(field_name)\n\n if isinstance(field, models.ManyToManyField):\n value = data_combiner.get_value_to_many(field_name)\n else:\n value = data_combiner.get_value(field_name)\n\n if not value:\n errors[field_name] = [self.message]\n\n # extra validators\n extra_errors = self._run_extra_validators(data)\n for field, field_errors in extra_errors.items():\n errors[field] += field_errors\n\n if errors:\n raise ValidationError(errors)",
"def _add_error_checks(self, other):\n pass",
"def test_set_non_dictionary_based_field(self):\n self.assertRaises(TypeError, self._p.set_fields, '')",
"def validate(self):\n for fieldname in getattr(self, '_body_fields', []):\n val_name = 'validate_{fieldname}'.format(fieldname=fieldname)\n field = getattr(self, fieldname)\n val = getattr(self, val_name, None)\n if val is not None:\n val()\n elif isinstance(\n field,\n BaseAgaveResource\n ):\n field.validate()",
"def _check_exc(self):\n if self._exc is not None:\n raise self._exc",
"def __call__(self):\n if any(assignee.actual_time is None for assignee in self.order.assignees.all()):\n raise ValidationError({\n api_settings.NON_FIELD_ERRORS_KEY: self.message,\n })"
] | [
"0.64744073",
"0.6031441",
"0.58538336",
"0.5842086",
"0.58299446",
"0.57440895",
"0.56509054",
"0.56192964",
"0.56120896",
"0.5591077",
"0.5500736",
"0.5477261",
"0.54311866",
"0.5412474",
"0.5382877",
"0.5351321",
"0.5345596",
"0.5325084",
"0.5323807",
"0.53185827",
"0.53163004",
"0.5270276",
"0.5261344",
"0.5260273",
"0.5240711",
"0.52270097",
"0.5216929",
"0.5215547",
"0.52033925",
"0.52031225"
] | 0.776859 | 0 |
Confirm tos_field is only present when configured to add the field. | def test_manage_tos_field(self):
name = self.form.name_for_tos or 'tos_field'
initial_is_off = self.form.tos_required is False
found = self.form.fields.get(name, None)
original_critical = deepcopy(self.form.critical_fields)
self.form.tos_required = True
expected = deepcopy(original_critical)
name = getattr(self.form, 'name_for_tos', None) or ''
tos_opts = {'names': (name, ), 'alt_field': 'tos_field', 'computed': False}
tos_opts.update({'name': 'tos_field', 'field': self.form_class.tos_field})
expected.update(name_for_tos=tos_opts)
initial_kwargs = {}
returned_kwargs = self.form.setup_critical_fields(**initial_kwargs)
actual = self.form.critical_fields
self.assertTrue(initial_is_off)
self.assertIsNone(found)
self.assertDictEqual(initial_kwargs, returned_kwargs)
self.assertDictEqual(expected, actual)
self.form.fields.pop('tos_field', None)
self.form.tos_required = False
self.form.critical_fields = original_critical
reset_kwargs = self.form.setup_critical_fields(**initial_kwargs)
self.assertDictEqual({}, reset_kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_tos_setup(self):\n self.assertTrue(self.form.tos_required)\n self.assertIsNotNone(self.form.name_for_tos)\n self.assertIsNotNone(self.form.fields.get(self.form.name_for_tos, None))",
"def clean_tos(self):\r\n if self.cleaned_data.get('tos', False):\r\n return self.cleaned_data['tos']\r\n raise forms.ValidationError(_(u'You must agree to the terms to register'))",
"def clean_tos(self):\n if self.cleaned_data.get('tos', False):\n return self.cleaned_data['tos']\n raise forms.ValidationError(_(u'You must agree to the terms to register'))",
"def clean_tos(self):\n if self.cleaned_data.get('tos', True):\n return self.cleaned_data['tos']\n raise forms.ValidationError(_(u'Please consider the Terms of Service.'))",
"def clean_agrees_to_tos(field_name):\n\n @check_field_is_empty(field_name)\n def wrapper(self):\n \"\"\"Decorator wrapper method.\n \"\"\"\n agrees_to_tos = self.cleaned_data.get(field_name)\n\n if not site_logic.getToS(site_logic.getSingleton()):\n return agrees_to_tos\n\n # Site settings specify a site-wide ToS, so agreement is *required*\n if agrees_to_tos:\n return True\n\n # there was no agreement made so raise an error\n raise forms.ValidationError(\n 'The site-wide Terms of Service must be accepted to participate'\n ' on this site.')\n\n return wrapper",
"def check_for_empties():\n if hasattr(self.instance, 'fields_required_for_publish'):\n errors_for_empties = {\n field_name: try_adding_error_to_field(\n field_name, field_value)\n for (field_name, field_value) in self.data.items()\n if (len(field_value) == 0 or field_value == 'null') and field_name in self.instance.fields_required_for_publish\n }",
"def checkFeeValidity(self, event):\n\n if self.widget_insert_page[\"agency\"].tk_var.get() != \"None\":\n return self.checkEmptyField(event=event)",
"def xtest_form_has_fields(self):\n expected = ['name', 'cpf', 'email', 'phone']\n form = SubscriptionForm()\n self.assertSequenceEqual(expected, list(form.fields))",
"def _onchange_field(self):\n if not self.secretary_contact_id:\n return\n if self.partner_type in ['dr', 'patient', 'secretary']:\n self.update({\n 'secretary_contact_id': False\n })",
"def test_form_has_fields(self):\r\n self.form = SubscriptionForm()\r\n expect = ['name', 'cpf', 'email', 'phone']\r\n self.assertSequenceEqual(expect, list(self.form.fields))",
"def _check_required_fields(self):\n assert self.title\n assert self.format",
"def no_payment_required(self):",
"def trivialFieldChecker(self, event):\n\n self.widget_insert_page_item[event.widget].is_good_flag = True",
"def test_raises_on_missing_needed_fields(self):\n test_name = \"impossible_creature_not_present\"\n self.form.constructor_fields = [*self.form.constructor_fields, test_name]\n message = \"The fields for email, username, and constructor must be set in fields. \"\n self.assertNotIn(test_name, self.form.base_fields)\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.confirm_required_fields()",
"def is_required(self, field):\n return field.scheme.is_required and not field.scheme.is_pk",
"def test_legal_address_is_complete(empty_field):\n address = LegalAddressFactory.create(country=\"US\")\n if empty_field:\n setattr(address, empty_field, \"\")\n assert address.is_complete is False\n else:\n assert address.is_complete is True",
"def has_field(self, field):\n return field in self.extra_fields",
"def is_field(self, proof = True):\n return True",
"def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.fields['first_name'].required = False\n self.fields['last_name'].required = False\n self.fields['institution'].required = False\n self.fields['institution_logo'].required = False\n self.fields['allow_notifications'].required = False",
"def _populate_always_present_fields(self, field):\n defaults = [\n (\"label\", \"\"),\n (\"instructions\", \"\"),\n (\"placeholder\", \"\"),\n (\"defaultValue\", \"\"),\n (\"restrictions\", {}),\n (\"errorMessages\", {}),\n ]\n field.update({\n key: value\n for key, value in defaults if key not in field\n })",
"def testFTISetup(self):\n self.failUnless(self.portal.portal_types['FSDPerson'].Title() != \"AT Content Type\")",
"def test_raise_missing_flag_field(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_flag = self.form.USERNAME_FLAG_FIELD\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n original_errors = getattr(self.form, '_errors', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.USERNAME_FLAG_FIELD = 'Not a valid field name'\n self.form.cleaned_data = {self.form.name_for_user: 'test_username', self.form.name_for_email: 'test_email'}\n # self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n self.form._errors = None if original_errors is None else original_errors.copy()\n\n with self.assertRaises(ImproperlyConfigured):\n self.form.configure_username_confirmation()\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.USERNAME_FLAG_FIELD = original_flag\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors\n if original_cleaned_data is None:\n del self.form.cleaned_data\n if original_errors is None:\n del self.form._errors",
"def soft_assert_cannot_update_predefined_field(soft_assert, obj):\n field_element = factory.get_cls_webui_service(objects.get_plural(\n obj.type))().open_info_page_of_obj(obj).predefined_field\n field_element.inline_edit.open()\n soft_assert.expect(not field_element.input.exist,\n \"There should be no input field.\")",
"def test_setup(self):\n self.assertEqual(self.form._meta.model.USERNAME_FIELD, self.form.name_for_user)\n self.assertEqual(self.form._meta.model.get_email_field_name(), self.form.name_for_email)\n self.assertIn(self.form._meta.model.get_email_field_name(), self.form.fields)\n self.assertNotIn('email_field', self.form.fields)",
"def _custom_validate_fields(self, issues):\n\n common_section = 'basicinfo'\n\n if self.address is None or self.address == '':\n issues.create(section=common_section,\n field='address',\n code='required')\n\n if self.phone is None or self.phone == '':\n issues.create(section=common_section,\n field='phone',\n code='required')\n elif not phonenumber.to_python(self.phone).is_valid():\n issues.create(section=common_section,\n field='phone',\n code='invalid')\n\n if self.psu_email is None or self.psu_email == '':\n issues.create(section=common_section,\n field='psu_email',\n code='required')\n else:\n try:\n EmailValidator()(self.psu_email)\n if not self.psu_email.endswith('@psu.edu'):\n issues.create(section=common_section,\n field='psu_email',\n code='prohibited')\n except ValidationError:\n issues.create(section=common_section,\n field='psu_email',\n code='invalid')\n\n if self.preferred_email == '':\n # preferred_email is assumed to be psu_email if blank\n pass\n else:\n try:\n EmailValidator()(self.preferred_email)\n except ValidationError:\n issues.create(section=common_section,\n field='preferred_email',\n code='invalid')\n\n if self.psu_id is None or self.psu_id == '':\n issues.create(section=common_section,\n field='psu_id',\n code='required')\n elif not re.match(r'^9\\d{8}$', self.psu_id):\n issues.create(section=common_section,\n field='psu_id',\n code='invalid')\n\n if self.major is None or self.major == '':\n issues.create(section=common_section,\n field='major',\n code='required')\n\n if self.semester_initiated is None:\n issues.create(section=common_section,\n field='semester_initiated',\n code='required')\n elif self.semester_initiated > Semester(self.due_at.date()):\n issues.create(section=common_section,\n field='semester_initiated',\n code='invalid')\n elif self.semester_initiated < Semester(('Spring', 1928)):\n issues.create(section=common_section,\n field='semester_initiated',\n code='invalid')\n\n if self.semester_graduating is None:\n issues.create(section=common_section,\n field='semester_graduating',\n code='required')\n elif self.semester_graduating < Semester(self.due_at.date()):\n issues.create(section=common_section,\n field='semester_graduating',\n code='invalid')\n elif self.semester_graduating > Semester(('Fall', 2099)):\n issues.create(section=common_section,\n field='semester_graduating',\n code='invalid')\n\n if self.cumulative_gpa == None:\n issues.create(section=common_section,\n field='cumulative_gpa',\n code='required')\n elif (self.cumulative_gpa < 0.0 or self.cumulative_gpa > 4.0):\n issues.create(section=common_section,\n field='cumulative_gpa',\n code='invalid')\n\n if self.semester_gpa == None:\n issues.create(section=common_section,\n field='semester_gpa',\n code='required')\n elif (self.semester_gpa < 0.0 or self.semester_gpa > 4.0):\n issues.create(section=common_section,\n field='semester_gpa',\n code='invalid')",
"def test_registered_pin_required(self):\n self.contact.pin = '1234'\n self.contact.save()\n msg = self._send(self.reg_conn, '1')\n self.assertEqual(len(msg.responses), 1)\n self.assertEqual(msg.responses[0].text,\n self.app.pin_required)",
"def test_registered_pin_required(self):\n self.contact.pin = '1234'\n self.contact.save()\n msg = self._send(self.reg_conn, '1')\n self.assertEqual(len(msg.responses), 1)\n self.assertEqual(msg.responses[0].text,\n self.app.pin_required)",
"def link_check(form, field):\n if form.registrable.data and len(field.data)==0:\n raise validators.ValidationError('link should is required when the forum is registrable')",
"def get_is_new_customer_custom_fields(self): \n return self.is_new_customer_custom_fields",
"def __custom_tpcp_validation__(cls):\n return"
] | [
"0.67858636",
"0.62866366",
"0.62055016",
"0.61811095",
"0.5965814",
"0.5193065",
"0.5122631",
"0.4904365",
"0.4875286",
"0.48735622",
"0.48606914",
"0.48399997",
"0.4826527",
"0.48137578",
"0.47887945",
"0.47836968",
"0.47045",
"0.46824843",
"0.4672949",
"0.46623525",
"0.46555507",
"0.46518007",
"0.46498215",
"0.46334237",
"0.46316707",
"0.4629011",
"0.4629011",
"0.46281648",
"0.46277136",
"0.46192184"
] | 0.7094289 | 0 |
Confirm the form was instantiated with tos_required. | def test_tos_setup(self):
self.assertTrue(self.form.tos_required)
self.assertIsNotNone(self.form.name_for_tos)
self.assertIsNotNone(self.form.fields.get(self.form.name_for_tos, None)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean_tos(self):\r\n if self.cleaned_data.get('tos', False):\r\n return self.cleaned_data['tos']\r\n raise forms.ValidationError(_(u'You must agree to the terms to register'))",
"def clean_tos(self):\n if self.cleaned_data.get('tos', False):\n return self.cleaned_data['tos']\n raise forms.ValidationError(_(u'You must agree to the terms to register'))",
"def i_check_that_the_form_has_been_subimtted():\n driver.find_element_by_id(\"submit_message\").click()\n assert \"Contact Confirmation\" in driver.title",
"def test_manage_tos_field(self):\n name = self.form.name_for_tos or 'tos_field'\n initial_is_off = self.form.tos_required is False\n found = self.form.fields.get(name, None)\n original_critical = deepcopy(self.form.critical_fields)\n self.form.tos_required = True\n expected = deepcopy(original_critical)\n name = getattr(self.form, 'name_for_tos', None) or ''\n tos_opts = {'names': (name, ), 'alt_field': 'tos_field', 'computed': False}\n tos_opts.update({'name': 'tos_field', 'field': self.form_class.tos_field})\n expected.update(name_for_tos=tos_opts)\n initial_kwargs = {}\n returned_kwargs = self.form.setup_critical_fields(**initial_kwargs)\n actual = self.form.critical_fields\n\n self.assertTrue(initial_is_off)\n self.assertIsNone(found)\n self.assertDictEqual(initial_kwargs, returned_kwargs)\n self.assertDictEqual(expected, actual)\n\n self.form.fields.pop('tos_field', None)\n self.form.tos_required = False\n self.form.critical_fields = original_critical\n reset_kwargs = self.form.setup_critical_fields(**initial_kwargs)\n self.assertDictEqual({}, reset_kwargs)",
"def form_valid(self, form):\n form.instance.term = Term.objects.get_current_term()\n messages.success(self.request, '{req_type} requirement created!'.format(\n req_type=self.display_req_type))\n return super(\n ManualCandidateRequirementCreateView, self).form_valid(form)",
"def clean_tos(self):\n if self.cleaned_data.get('tos', True):\n return self.cleaned_data['tos']\n raise forms.ValidationError(_(u'Please consider the Terms of Service.'))",
"def test_choice_form_required(self):\n form = VoteForm({})\n self.assertFalse(form.is_valid())\n self.assertIn('choice', form.errors)\n self.assertIn('required', \"\\n\".join(form.errors.get('choice')))",
"def test_individual_donation_required(self):\n form_data = self.form_data()\n form = DonationPaymentForm(data=form_data)\n self.assertTrue(form.is_valid())",
"def form_valid(self, form):\n\n ModelAccountVerification.objects.send_verification_email(form.user,\n verification_type=\n ModelAccountVerification.VERIFICATION_TYPES[1][0])\n\n messages.info(self.request, \"Email sent successfully to the {0}\".format(form.user.email))\n\n return HttpResponseRedirect(self.success_url)",
"def form_valid(self, form):\n self.object = form.save()\n self.send_verify_email()\n return super().form_valid(form)",
"def form_CheckboxRequired(request):\n schema = schemaish.Structure()\n schema.add('checkbox', schemaish.Boolean(validator=validatish.Required()))\n\n form = formish.Form(schema, 'form')\n return form",
"def form_valid(self, form):\n redirect_url = self.accept_consent_request(None)\n return HttpResponseRedirect(redirect_url)",
"def test_form_has_fields(self):\r\n self.form = SubscriptionForm()\r\n expect = ['name', 'cpf', 'email', 'phone']\r\n self.assertSequenceEqual(expect, list(self.form.fields))",
"def test_custom_required(self):\n for data in ({}, {'payment_amount': ''}):\n form = DonationAmountForm(data=data)\n self.assertFalse(form.is_valid())\n errors = form.errors.as_data()\n self.assertTrue('payment_amount' in errors)\n self.assertEqual('required', errors['payment_amount'][0].code)",
"def ConfirmForm_factory():\n\n subscription_fields = get_subscription_fields()\n\n class ConfirmForm(NgLoadSuccessMessageMixin, NgSuccessMessageMixin, NgModelFormMixin, NgFormValidationMixin, Bootstrap3ModelForm):\n \"email and sig are obtained from a url and embedded in the form data hidden for posts\"\n email = fields.EmailField(required=True, widget=widgets.HiddenInput)\n sig = fields.CharField(min_length=20, required=True, widget=widgets.HiddenInput)\n\n form_name = 'confirm_form'\n scope_prefix = 'confirm_data'\n required_css_class = 'djng-field-required'\n success_message = _(\"Subscriptions updated\")\n loadsuccess_message = _(\"Email address confirmed\")\n\n class Meta:\n model = CustomerModel\n fields = ['email', 'sig'] + subscription_fields\n\n @classmethod\n def get_url(cls):\n \"\"\"Returns the url for the form submission\"\"\"\n return reverse('shop_subscribe:confirm')\n\n def __init__(self, request=None, instance=None, *args, **kwargs):\n \"\"\"\n Always called with a Customer instance, not User.\n \"\"\"\n if request is None:\n raise ValueError(\"Request must not be None\")\n if instance:\n raise ValueError(\"Pass in 'request' instead of 'instance'\")\n\n try:\n customer, initial = get_customer_from_emailsignature(request)\n except BadSignature:\n # if no/bad url params are given, uses a blank form\n customer, initial = None, None\n\n super(ConfirmForm, self).__init__(instance=customer, initial=initial, *args, **kwargs)\n\n confirm_error = _(\"Could not confirm the supplied email address.\")\n def clean(self):\n \"\"\"\n Checks the email signature.\n is_valid or full_clean won't check initial values unless data has been passed in\n \"\"\"\n cleaned_data = super(ConfirmForm, self).clean() or self.cleaned_data\n try:\n unsign(cleaned_data)\n return cleaned_data\n except BadSignature:\n raise ValidationError(self.confirm_error)\n\n return ConfirmForm",
"def form_valid(self, form):\n # Switching between temporary registration and main registration is easy with the is_active attribute.\n # The withdrawal process will also improve if you only set is_active to False.\n user = form.save(commit=False)\n user.is_active = False\n user.save()\n\n # Send activation URL\n current_site = get_current_site(self.request)\n domain = current_site.domain\n context = {\n 'protocol': 'https' if self.request.is_secure() else 'http',\n 'domain': domain,\n 'token': dumps(user.pk),\n 'user': user,\n }\n\n subject = render_to_string('register/mail_template/create/subject.txt', context)\n message = render_to_string('register/mail_template/create/message.txt', context)\n\n user.email_user(subject, message)\n return redirect('register:user_create_done')",
"def test_has_form(self):\n form = self.resp.context['form']\n self.assertIsInstance(form, SubscriptionForm)",
"def test_individual_requirements(self):\n form_data = self.form_data(\n clear=['payer_name'], organization_name='Big Corporation',\n organization_contact='Mr A. Suit')\n form = DonationPaymentForm(data=form_data)\n self.assertFalse(form.is_valid())\n\n form_data['payer_name'] = 'Bob'\n form = DonationPaymentForm(data=form_data)\n self.assertTrue(form.is_valid())\n self.assertFalse('organization_name' in form.cleaned_data)\n self.assertFalse('organization_contact' in form.cleaned_data)",
"def __init__(self, request=None, instance=None, *args, **kwargs):\n if request is None:\n raise ValueError(\"Request must not be None\")\n if instance:\n raise ValueError(\"Pass in 'request' instead of 'instance'\")\n\n try:\n customer, initial = get_customer_from_emailsignature(request)\n except BadSignature:\n # if no/bad url params are given, uses a blank form\n customer, initial = None, None\n\n super(ConfirmForm, self).__init__(instance=customer, initial=initial, *args, **kwargs)",
"def test_checkout_form_prefilled(self):\n self.login_test_user()\n self.fill_session_cart()\n response = self.client.get(self.CHECKOUT_URL)\n form_fields_w_values = response.context['form'].initial\n self.assertEqual(len(form_fields_w_values.items()),\n len(self.CHECKOUT_FIELDS))\n for k, v in form_fields_w_values.items():\n self.assertEqual(v, self.user_for_tests[k])",
"def form_valid(self, form):\n if form.warnings:\n # save the post data and move them to confirmation step\n self.dump_post_data_to_session()\n return redirect(self.confirmation_url)\n else:\n return super().form_valid(form)",
"def form_valid(self, form):\n vehicle = self.request.POST['vin']\n self.success_url += vehicle\n\n form.save()\n InspectionRequest.objects.get_or_create(\n vehicle=Vehicle.objects.get(vin=vehicle),\n seller=Seller.objects.get(email=self.request.user.email),\n request_date=datetime.datetime.now())\n send_email()\n messages.add_message(\n self.request, messages.SUCCESS,\n \"You've successfully added a vehicle \" +\n \"and requested an inspection for \"\n + form.instance.__str__() + \". \" +\n \"You will be contacted by a NoLemon administrator \" +\n \"within 1 business days to confirm your request.\")\n return HttpResponseRedirect(self.success_url)",
"def form_valid(self, form):\n return super().form_valid(form)",
"def form_valid(self, form):\n response = super().form_valid(form)\n success_template_name = self.get_success_template_name()\n if self.request.is_turbo and success_template_name:\n context = self.get_success_context_data()\n response = TemplateResponse(self.request, success_template_name, context)\n return response",
"def test_form_when_project_is_awaiting_approval(self):\n form = ProjectUserMembershipCreationForm(\n initial={\n 'user': self.project_applicant,\n },\n data={\n 'project_code': self.project_code,\n },\n )\n self.assertFalse(form.is_valid())\n self.assertEqual(\n form.errors['project_code'],\n ['The project is currently awaiting approval.'],\n )",
"def checkFeeValidity(self, event):\n\n if self.widget_insert_page[\"agency\"].tk_var.get() != \"None\":\n return self.checkEmptyField(event=event)",
"def _check_required_fields(self):\n assert self.title\n assert self.format",
"def get_form_class(self):\n if self.survey.get_requires_payment():\n return AuthorizenetSurveyPurchaseForm\n return super(AuthorizenetSurveyPurchaseCreate, self).get_form_class()",
"def test_must_inform_email_or_phone(self):\r\n form = self.make_validated_form(email='', phone='')\r\n self.assertListEqual(['__all__'], list(form.errors))",
"def test_has_form(self):\n form = self.response.context['form']\n self.assertIsInstance(form, UserForm)"
] | [
"0.6649071",
"0.65329856",
"0.6442008",
"0.6201706",
"0.6105612",
"0.6058894",
"0.5942685",
"0.5837317",
"0.5744072",
"0.57023823",
"0.5676579",
"0.5644132",
"0.5597428",
"0.5588718",
"0.557048",
"0.5566174",
"0.55490893",
"0.55310315",
"0.5505443",
"0.5505102",
"0.5501673",
"0.5490267",
"0.5469538",
"0.54658455",
"0.54536873",
"0.54294163",
"0.5416011",
"0.54111516",
"0.5386941",
"0.53774357"
] | 0.71034855 | 0 |
The get_computed_field_names method should include the names when computed_fields is already determined. | def test_use_existing_computed_field_dict(self):
if isinstance(self.form.computed_fields, list):
self.form.computed_fields = self.form.get_computed_fields(self.form.computed_fields)
self.form.fields.update(self.form.computed_fields) # only names in fields included in get_computed_field_names.
result_names = self.form.get_computed_field_names([], self.form.fields)
self.assertIsInstance(self.form.computed_fields, dict)
self.assertIn('test_field', result_names) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_field_names() -> Sequence[str]:\n raise NotImplementedError",
"def field_names(self):\n ...",
"def test_init_update_computed_field_names(self):\n original_request = self.request\n original_form = self.form\n computed = getattr(self.form, 'computed_fields', None)\n get_form = self.make_form_request()\n computed_fields = getattr(get_form, 'computed_fields', None)\n\n self.assertIsNotNone(computed)\n self.assertIsNotNone(computed_fields)\n self.assertIsNotNone(self.form.country_field_name)\n self.assertIn(self.form.country_field_name, computed_fields)\n\n self.request = original_request\n self.form = original_form",
"def field_names(self):\n return self.base_field_names() + list(self.data.keys())",
"def get_field_names(self, declared_fields, info):\n return self._requested_fields",
"def _compute_name(self):\n for rec in self:\n rec.name = rec._get_computed_name(rec.lastname, rec.firstname)",
"def get_loaded_field_names_cb(self, target, model, fields):\n names = [f.name for f in fields if not getattr(f, \"not_in_db\", False)]\n for field in fields:\n if getattr(field, \"not_in_db\", False):\n names += [f.name for f in field.fields]\n\n target[model] = set(names)",
"def get_default_field_names(self, declared_fields, model_info):\n return (\n list(declared_fields.keys()) +\n list(model_info.fields.keys())\n )",
"def field_names(self):\n if not self._field_names:\n self._field_names.update(self.properties.keys())\n\n self._field_names = [attr for attr in self._field_names if not attr.startswith(\"_\")]\n\n return self._field_names",
"def test_raise_on_corrupt_computed_fields(self):\n initial = self.form.computed_fields\n self.form.computed_fields = 'This is a broken value'\n with self.assertRaises(ImproperlyConfigured):\n self.form.get_computed_field_names([], self.form.fields)\n self.form.computed_fields = None\n with self.assertRaises(ImproperlyConfigured):\n self.form.get_computed_field_names([], self.form.fields)\n self.form.computed_fields = initial",
"def get_field_names(self):\n return {rv[0] for rv in self.iter_fields()}",
"def get_field_names(self):\n return self._keys",
"def _field_names(self):\n return [self._sanitize_field_name(field_name)\n for field_name in self._all_fields]",
"def stored_field_names(self):\r\n \r\n bn = self._by_name\r\n return [name for name in self._names if bn[name].stored]",
"def test_fields_updated_with_computed(self):\n pass",
"def _fields_names(cls) -> List:\n return list(field.name for field in dataclasses.fields(cls))",
"def field_names(self):\r\n return self._names",
"def get_field_names(cls):\n return cls._meta.get_field_names()",
"def getAccessedFieldNames(self):\n pass",
"def fieldNames(self):\n return self.__fieldNames",
"def base_field_names(self):\n return self._base_field_names()",
"def get_fields(cls):\n return map(lambda x: getattr(cls, x), cls.get_field_names())",
"def GetAllFields(self, run_unsafe=False):\n\n if not (self.inherited_fields_expanded or run_unsafe):\n raise RuntimeError(f'Type {self.typename} has not been expanded')\n if self._all_fields is None:\n tmp = self.local_field_names.copy()\n tmp.update(self.inherited_field_names)\n if run_unsafe:\n return tmp\n self._all_fields = tmp\n return self._all_fields",
"def get_fields(dgid, metadata=None, computed_columns=None):\n # NOTE: metadata does not contain computed_columns yet\n if metadata is None:\n conn = get_database_connection(dgid)\n metadata = get_metadata(conn)\n\n # Used to evaluate computed columns\n unify_computed_columns(computed_columns)\n columns = list(metadata.keys())\n select_expr_as = [get_field_name(column, metadata) for column in columns]\n databases = [\"datagrid\"]\n\n if computed_columns:\n # Only passed in when calling from endpoint\n update_state(computed_columns, metadata, databases, columns, select_expr_as)\n # Now metadata has computed columns\n\n fields = {}\n for column in metadata:\n datatype = metadata[column][\"type\"]\n field_name = get_field_name(column, metadata)\n qbtype = datatype_to_qbtype(datatype)\n if qbtype is None:\n continue\n\n if datatype in [\"FLOAT\", \"INTEGER\", \"ROW_ID\"]:\n fields[field_name] = {\n \"label\": column,\n \"field\": field_name,\n \"type\": qbtype,\n \"tooltip\": \"The '%s' column (type '%s') from the data grid\"\n % (column, qbtype),\n }\n # name, datatype, min, max, avg, variance, total, stddev, other\n if (metadata[column][\"minimum\"] is not None) and (\n metadata[column][\"minimum\"] is not None\n ):\n min_value = metadata[column][\"minimum\"]\n max_value = metadata[column][\"maximum\"]\n fields[field_name][\"fieldSettings\"] = {\n \"min\": min_value,\n \"max\": max_value,\n }\n fields[field_name][\"valueSources\"] = [\"value\", \"field\"]\n\n elif datatype == \"DATETIME\":\n field_exp = \"datetime(%s, 'unixepoch')\" % field_name\n fields[field_exp] = {\n \"label\": column,\n \"field\": field_name,\n \"type\": qbtype,\n \"tooltip\": \"The '%s' column (type '%s') from the data grid\"\n % (column, qbtype),\n }\n if (metadata[column][\"minimum\"] is not None) and (\n metadata[column][\"minimum\"] is not None\n ):\n min_value = metadata[column][\"minimum\"]\n max_value = metadata[column][\"maximum\"]\n fields[field_exp][\"fieldSettings\"] = {\n \"min\": min_value,\n \"max\": max_value,\n # \"dateFormat\": \"DD-MM-YYYY\",\n # \"timeFormat\":\n # \"valueFormat\":\n }\n fields[field_exp][\"valueSources\"] = [\n \"value\",\n \"field\",\n \"func\",\n ] # adds Now, and Relative\n\n elif datatype == \"BOOLEAN\":\n fields[field_name] = {\n \"label\": column,\n \"field\": field_name,\n \"type\": qbtype,\n \"tooltip\": \"The '%s' column (type '%s') from the data grid\"\n % (column, qbtype),\n }\n fields[field_name][\"fieldSettings\"] = {\n \"labelYes\": \"True\",\n \"labelNo\": \"False\",\n }\n fields[field_name][\"valueSources\"] = [\"value\", \"field\"]\n\n elif datatype == \"TEXT\":\n fields[field_name] = {\n \"label\": column,\n \"field\": field_name,\n \"type\": qbtype,\n \"tooltip\": \"The '%s' column (type '%s') from the data grid\"\n % (column, qbtype),\n }\n fields[field_name][\"valueSources\"] = [\"value\", \"field\"]\n\n elif datatype == \"JSON\":\n # Asset metadata columns are named\n # 'COLUMN_NAME.metadata' or 'COLUMN_NAME--metadata'\n fields[field_name] = {\n \"label\": column.replace(\".metadata\", \"\").replace(\"--metadata\", \"\"),\n \"field\": field_name,\n \"tooltip\": \"The '%s' column (type 'JSON') from the data grid\"\n % (column,),\n \"type\": \"!struct\",\n \"subfields\": {},\n }\n subfields = ast.literal_eval(metadata[column][\"other\"])\n # Only filterable keys are in subfields\n for key in subfields:\n # Query Builder filter types: \"text\", \"number\", \"boolean\", or \"list-of-text\"\n qbtype = subfields[key][\"type\"]\n if qbtype == \"list-of-text\":\n field_exp = \"json_extract(%s, '$.%s')\" % (field_name, key)\n fields[field_name][\"subfields\"][field_exp] = {\n \"type\": \"text\",\n \"label\": key,\n \"field\": field_name,\n \"tableName\": \"1\", # special signal for JSON queries in our QueryBuilder\n \"operators\": [\"like\"],\n }\n else:\n field_exp = \"json_extract(%s, '$.%s')\" % (field_name, key)\n fields[field_name][\"subfields\"][field_exp] = {\n \"type\": qbtype,\n \"label\": key,\n \"field\": field_name,\n \"tableName\": \"1\", # special signal for JSON queries in our QueryBuilder\n }\n if \"values\" in subfields[key]:\n fields[field_name][\"subfields\"][field_exp][\"type\"] = \"select\"\n fields[field_name][\"subfields\"][field_exp][\"fieldSettings\"] = {\n \"listValues\": sorted(subfields[key][\"values\"])\n }\n\n return fields",
"def get_fieldnames(self):\n fieldnames = self._fields.keys()\n fieldnames.remove('time')\n fieldnames.remove('lon')\n fieldnames.remove('lat')\n return fieldnames",
"def _get_fields(self):\n fields = self.table[0]\n fields = filter(None.__ne__, fields)\n return list(map(str.lower, fields))",
"def test_get_field_names():\n assert set(get_field_names(AuditModel)) == {\n \"data_before\",\n \"data_after\",\n \"acting_user\",\n \"created_on\",\n \"updated_on\",\n }",
"def _fetch_fields(self, old_or_new, target_fields):\r\n \r\n returned_fields = []\r\n for target_field in target_fields:\r\n if target_field in [\",\", \"\\t\"]:\r\n returned_fields.append(target_field)\r\n else:\r\n try:\r\n returned_fields.append(str(getattr(old_or_new, target_field)))\r\n except:\r\n returned_fields.append(\"-\") \r\n return returned_fields",
"def _member_field_names_for_protect(self, protect):\n result = []\n fields = self.MEMBER_DEFAULT_FIELDS.copy()\n fields.update((k,v) for k,v in self.SUPPLEMENTARY_FIELDS.iteritems() if (v['OBJECT'] == 'MEMBER'))\n for (name, spec) in fields.iteritems():\n if spec['PROTECT'] == protect:\n result.append(name)\n return result",
"def get_renamed_input_fields(self):\n return self.renamed_input_fields"
] | [
"0.63844585",
"0.62912333",
"0.62794363",
"0.62603986",
"0.62363034",
"0.6190328",
"0.61855924",
"0.6114373",
"0.6040428",
"0.6024961",
"0.60116583",
"0.6000503",
"0.599157",
"0.5962834",
"0.5922235",
"0.59012467",
"0.5882769",
"0.5877933",
"0.5828314",
"0.5807871",
"0.57651204",
"0.5680359",
"0.56239635",
"0.55606806",
"0.553346",
"0.551736",
"0.54916793",
"0.54769486",
"0.5466599",
"0.54223406"
] | 0.7097615 | 0 |
The computed_field_names method raises ImproperlyConfigured when computed_fields is an unexpected type. | def test_raise_on_corrupt_computed_fields(self):
initial = self.form.computed_fields
self.form.computed_fields = 'This is a broken value'
with self.assertRaises(ImproperlyConfigured):
self.form.get_computed_field_names([], self.form.fields)
self.form.computed_fields = None
with self.assertRaises(ImproperlyConfigured):
self.form.get_computed_field_names([], self.form.fields)
self.form.computed_fields = initial | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_use_existing_computed_field_dict(self):\n if isinstance(self.form.computed_fields, list):\n self.form.computed_fields = self.form.get_computed_fields(self.form.computed_fields)\n self.form.fields.update(self.form.computed_fields) # only names in fields included in get_computed_field_names.\n result_names = self.form.get_computed_field_names([], self.form.fields)\n\n self.assertIsInstance(self.form.computed_fields, dict)\n self.assertIn('test_field', result_names)",
"def field_names(self):\n ...",
"def get_field_names() -> Sequence[str]:\n raise NotImplementedError",
"def get_loaded_field_names_cb(self, target, model, fields):\n names = [f.name for f in fields if not getattr(f, \"not_in_db\", False)]\n for field in fields:\n if getattr(field, \"not_in_db\", False):\n names += [f.name for f in field.fields]\n\n target[model] = set(names)",
"def test_init_update_computed_field_names(self):\n original_request = self.request\n original_form = self.form\n computed = getattr(self.form, 'computed_fields', None)\n get_form = self.make_form_request()\n computed_fields = getattr(get_form, 'computed_fields', None)\n\n self.assertIsNotNone(computed)\n self.assertIsNotNone(computed_fields)\n self.assertIsNotNone(self.form.country_field_name)\n self.assertIn(self.form.country_field_name, computed_fields)\n\n self.request = original_request\n self.form = original_form",
"def get_default_field_names(self, declared_fields, model_info):\n return (\n list(declared_fields.keys()) +\n list(model_info.fields.keys())\n )",
"def test_fields_updated_with_computed(self):\n pass",
"def get_field_names(self, declared_fields, info):\n return self._requested_fields",
"def test_get_critical_from_existing_fields(self):\n name = 'generic_field'\n opts = {'names': (name, ), 'alt_field': '', 'computed': False}\n expected_field = self.form.fields.get(name, None)\n actual_name, actual_field = self.form.get_critical_field(opts['names'])\n self.assertEqual(name, actual_name)\n self.assertEqual(expected_field, actual_field)",
"def test_get_field_names():\n assert set(get_field_names(AuditModel)) == {\n \"data_before\",\n \"data_after\",\n \"acting_user\",\n \"created_on\",\n \"updated_on\",\n }",
"def _check_name_composing_fields(cls, **_kwargs: Any) -> List[checks.CheckMessage]:\n if not cls.name_composing_fields:\n return [\n checks.Warning(\n \"You must specify the fields that make up the name by \"\n \"listing them in name_composing_fields.\",\n obj=cls.__name__\n )\n ]\n errors = []\n for field in cls.name_composing_fields:\n try:\n get_fields_and_lookups(cls, field)\n except (exceptions.FieldDoesNotExist, exceptions.FieldError) as e:\n errors.append(\n checks.Error(\n \"Attribute 'name_composing_fields' contains invalid item: \"\n \"'%s'. %s\" % (field, e),\n obj=cls\n )\n )\n return errors",
"def _fields_names(cls) -> List:\n return list(field.name for field in dataclasses.fields(cls))",
"def field_names(self):\n return self.base_field_names() + list(self.data.keys())",
"def get_field_names(cls):\n return cls._meta.get_field_names()",
"def base_field_names(self):\n return self._base_field_names()",
"def _field_names(self):\n return [self._sanitize_field_name(field_name)\n for field_name in self._all_fields]",
"def get_field_names(self):\n return self._keys",
"def field_names(self):\n if not self._field_names:\n self._field_names.update(self.properties.keys())\n\n self._field_names = [attr for attr in self._field_names if not attr.startswith(\"_\")]\n\n return self._field_names",
"def test_validation_errors_assigned_in_clean_computed_fields(self):\n name = 'test_field'\n message = \"This is the test error on test_field. \"\n response = ValidationError(message)\n expected_compute_errors = ErrorDict({name: response}) # similar to return of _clean_computed_fields\n original_func = deepcopy(self.form.test_func)\n def make_error(value): raise response\n self.form.test_func = make_error\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n self.form.cleaned_data = getattr(self.form, 'cleaned_data', {}) # mimic full_clean: cleaned_data is present\n actual_compute_errors = self.form._clean_computed_fields()\n\n self.assertDictEqual(expected_compute_errors, actual_compute_errors)\n self.form.test_func = original_func",
"def get_fields(dgid, metadata=None, computed_columns=None):\n # NOTE: metadata does not contain computed_columns yet\n if metadata is None:\n conn = get_database_connection(dgid)\n metadata = get_metadata(conn)\n\n # Used to evaluate computed columns\n unify_computed_columns(computed_columns)\n columns = list(metadata.keys())\n select_expr_as = [get_field_name(column, metadata) for column in columns]\n databases = [\"datagrid\"]\n\n if computed_columns:\n # Only passed in when calling from endpoint\n update_state(computed_columns, metadata, databases, columns, select_expr_as)\n # Now metadata has computed columns\n\n fields = {}\n for column in metadata:\n datatype = metadata[column][\"type\"]\n field_name = get_field_name(column, metadata)\n qbtype = datatype_to_qbtype(datatype)\n if qbtype is None:\n continue\n\n if datatype in [\"FLOAT\", \"INTEGER\", \"ROW_ID\"]:\n fields[field_name] = {\n \"label\": column,\n \"field\": field_name,\n \"type\": qbtype,\n \"tooltip\": \"The '%s' column (type '%s') from the data grid\"\n % (column, qbtype),\n }\n # name, datatype, min, max, avg, variance, total, stddev, other\n if (metadata[column][\"minimum\"] is not None) and (\n metadata[column][\"minimum\"] is not None\n ):\n min_value = metadata[column][\"minimum\"]\n max_value = metadata[column][\"maximum\"]\n fields[field_name][\"fieldSettings\"] = {\n \"min\": min_value,\n \"max\": max_value,\n }\n fields[field_name][\"valueSources\"] = [\"value\", \"field\"]\n\n elif datatype == \"DATETIME\":\n field_exp = \"datetime(%s, 'unixepoch')\" % field_name\n fields[field_exp] = {\n \"label\": column,\n \"field\": field_name,\n \"type\": qbtype,\n \"tooltip\": \"The '%s' column (type '%s') from the data grid\"\n % (column, qbtype),\n }\n if (metadata[column][\"minimum\"] is not None) and (\n metadata[column][\"minimum\"] is not None\n ):\n min_value = metadata[column][\"minimum\"]\n max_value = metadata[column][\"maximum\"]\n fields[field_exp][\"fieldSettings\"] = {\n \"min\": min_value,\n \"max\": max_value,\n # \"dateFormat\": \"DD-MM-YYYY\",\n # \"timeFormat\":\n # \"valueFormat\":\n }\n fields[field_exp][\"valueSources\"] = [\n \"value\",\n \"field\",\n \"func\",\n ] # adds Now, and Relative\n\n elif datatype == \"BOOLEAN\":\n fields[field_name] = {\n \"label\": column,\n \"field\": field_name,\n \"type\": qbtype,\n \"tooltip\": \"The '%s' column (type '%s') from the data grid\"\n % (column, qbtype),\n }\n fields[field_name][\"fieldSettings\"] = {\n \"labelYes\": \"True\",\n \"labelNo\": \"False\",\n }\n fields[field_name][\"valueSources\"] = [\"value\", \"field\"]\n\n elif datatype == \"TEXT\":\n fields[field_name] = {\n \"label\": column,\n \"field\": field_name,\n \"type\": qbtype,\n \"tooltip\": \"The '%s' column (type '%s') from the data grid\"\n % (column, qbtype),\n }\n fields[field_name][\"valueSources\"] = [\"value\", \"field\"]\n\n elif datatype == \"JSON\":\n # Asset metadata columns are named\n # 'COLUMN_NAME.metadata' or 'COLUMN_NAME--metadata'\n fields[field_name] = {\n \"label\": column.replace(\".metadata\", \"\").replace(\"--metadata\", \"\"),\n \"field\": field_name,\n \"tooltip\": \"The '%s' column (type 'JSON') from the data grid\"\n % (column,),\n \"type\": \"!struct\",\n \"subfields\": {},\n }\n subfields = ast.literal_eval(metadata[column][\"other\"])\n # Only filterable keys are in subfields\n for key in subfields:\n # Query Builder filter types: \"text\", \"number\", \"boolean\", or \"list-of-text\"\n qbtype = subfields[key][\"type\"]\n if qbtype == \"list-of-text\":\n field_exp = \"json_extract(%s, '$.%s')\" % (field_name, key)\n fields[field_name][\"subfields\"][field_exp] = {\n \"type\": \"text\",\n \"label\": key,\n \"field\": field_name,\n \"tableName\": \"1\", # special signal for JSON queries in our QueryBuilder\n \"operators\": [\"like\"],\n }\n else:\n field_exp = \"json_extract(%s, '$.%s')\" % (field_name, key)\n fields[field_name][\"subfields\"][field_exp] = {\n \"type\": qbtype,\n \"label\": key,\n \"field\": field_name,\n \"tableName\": \"1\", # special signal for JSON queries in our QueryBuilder\n }\n if \"values\" in subfields[key]:\n fields[field_name][\"subfields\"][field_exp][\"type\"] = \"select\"\n fields[field_name][\"subfields\"][field_exp][\"fieldSettings\"] = {\n \"listValues\": sorted(subfields[key][\"values\"])\n }\n\n return fields",
"def objectFields(self):\n raise NotImplementedError",
"def fieldNames(self):\n return self.__fieldNames",
"def get_fields(cls):\n return map(lambda x: getattr(cls, x), cls.get_field_names())",
"def get_field_names_for_model(self, model):\n return [field.name for field in model._meta.fields if field.name != \"id\" and not\n (field.get_internal_type() == \"DateTimeField\" and\n (field.auto_now is True or field.auto_now_add is True))]",
"def get_field_names(self):\n return {rv[0] for rv in self.iter_fields()}",
"def field_names(self):\r\n return self._names",
"def _member_field_names_for_protect(self, protect):\n result = []\n fields = self.MEMBER_DEFAULT_FIELDS.copy()\n fields.update((k,v) for k,v in self.SUPPLEMENTARY_FIELDS.iteritems() if (v['OBJECT'] == 'MEMBER'))\n for (name, spec) in fields.iteritems():\n if spec['PROTECT'] == protect:\n result.append(name)\n return result",
"def test_callable_name_get_critical_field(self):\n special = self.get_generic_name\n name, field = self.form.get_critical_field(special)\n expected_name = special()\n expected_field = self.form.fields[expected_name]\n self.assertEqual(expected_name, name)\n self.assertEqual(expected_field, field)",
"def getAccessedFieldNames(self):\n pass",
"def get_fields(self):\n fields = super(GeoModelSerializer, self).get_fields()\n # Set the geometry field name when it's undeclared.\n if not self.Meta.geom_field:\n for name, field in fields.items():\n if isinstance(field, GeometryField):\n self.Meta.geom_field = name\n break\n return fields"
] | [
"0.6899859",
"0.6546997",
"0.63082385",
"0.6138751",
"0.6072802",
"0.605996",
"0.60209787",
"0.58762425",
"0.58004105",
"0.5780629",
"0.56937295",
"0.5666892",
"0.5624716",
"0.5612041",
"0.5541064",
"0.5533395",
"0.55333376",
"0.54615456",
"0.5437734",
"0.54309964",
"0.54275113",
"0.54004127",
"0.5399287",
"0.53847146",
"0.5377009",
"0.5356714",
"0.5311032",
"0.52912426",
"0.5263787",
"0.5205116"
] | 0.69892365 | 0 |
Raises ImproperlyConfigured for missing cleaned_data on targeted field_names in constructing values. | def test_construct_values_raises_for_missing_cleaned_data(self):
constructor_fields = ('first', 'second', 'last', )
if hasattr(self.form, 'cleaned_data'):
del self.form.cleaned_data
message = "This method can only be evaluated after 'cleaned_data' has been populated. "
with self.assertRaisesMessage(ImproperlyConfigured, message):
self.form.construct_value_from_values(constructor_fields) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_construct_values_raises_missing_cleaned_no_error(self):\n constructor_fields = ('first', 'second', 'last', )\n values = ['FirstValue', 'SecondValue', 'LastValue']\n cleaned_data = getattr(self.form, 'cleaned_data', {})\n cleaned_data.update(dict(zip(constructor_fields[:-1], values[:-1])))\n self.form.cleaned_data = cleaned_data\n err = \"This computed value can only be evaluated after fields it depends on have been cleaned. \"\n err += \"The field order must have the computed field after fields used for its value. \"\n with self.assertRaisesMessage(ImproperlyConfigured, err):\n self.form.construct_value_from_values(constructor_fields)",
"def test_construct_values_raises_for_missing_fields(self):\n message = \"There must me one or more field names to compute a value. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.construct_value_from_values()\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.construct_value_from_values('')\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.construct_value_from_values([])",
"def test_construct_values_raises_on_invalid_normalize(self):\n constructor_fields = ('first', 'second', 'last', )\n values = ['first_value', 'second_value', 'last_value']\n cleaned_data = getattr(self.form, 'cleaned_data', {})\n cleaned_data.update(dict(zip(constructor_fields, values)))\n self.form.cleaned_data = cleaned_data\n normalize = 'not a valid normalize function'\n message = \"The normalize parameter must be a callable or None. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.construct_value_from_values(constructor_fields, normalize=normalize)",
"def test_cleaned_data_worked(self):\n pass",
"def test_raise_on_corrupt_computed_fields(self):\n initial = self.form.computed_fields\n self.form.computed_fields = 'This is a broken value'\n with self.assertRaises(ImproperlyConfigured):\n self.form.get_computed_field_names([], self.form.fields)\n self.form.computed_fields = None\n with self.assertRaises(ImproperlyConfigured):\n self.form.get_computed_field_names([], self.form.fields)\n self.form.computed_fields = initial",
"def test_raises_on_constructor_fields_error(self):\n self.form.constructor_fields = None\n message = \"Expected a list of field name strings for constructor_fields. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.confirm_required_fields()",
"def test_construct_values_skips_already_caught_errors(self):\n constructor_fields = ('first', 'second', 'last', )\n values = ['FirstValue', 'SecondValue', 'LastValue']\n expected = None # Normal is: '_'.join(ea for ea in values if ea).casefold()\n cleaned_data = getattr(self.form, 'cleaned_data', {})\n cleaned_data.update(dict(zip(constructor_fields[:-1], values[:-1])))\n self.form.cleaned_data = cleaned_data\n original_errors = deepcopy(self.form._errors)\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n self.form.add_error('last', 'An error for testing')\n actual = self.form.construct_value_from_values(constructor_fields)\n\n self.assertIsNone(actual)\n self.assertEqual(expected, actual)\n\n self.form._errors = original_errors",
"def test_raises_on_missing_needed_fields(self):\n test_name = \"impossible_creature_not_present\"\n self.form.constructor_fields = [*self.form.constructor_fields, test_name]\n message = \"The fields for email, username, and constructor must be set in fields. \"\n self.assertNotIn(test_name, self.form.base_fields)\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.confirm_required_fields()",
"def test_construct_values_no_join_artifact_if_empty_value(self):\n constructor_fields = ('first', 'second', 'last', )\n values = ['FirstValue', 'SecondValue', 'LastValue']\n values[1] = ''\n expected = '_'.join(ea for ea in values if ea).casefold()\n cleaned_data = getattr(self.form, 'cleaned_data', {})\n cleaned_data.update(dict(zip(constructor_fields, values)))\n self.form.cleaned_data = cleaned_data\n actual = self.form.construct_value_from_values(constructor_fields)\n\n self.assertEqual('', self.form.cleaned_data['second'])\n self.assertEqual(expected, actual)\n self.assertEqual('firstvalue_lastvalue', actual)",
"def _replace_fields(self):\n for name, value in self._cleaned_data.items():\n setattr(self, name, value)",
"def clean(self):\n cleaned_data = super(ManageLearnersForm, self).clean()\n\n # Here we take values from `data` (and not `cleaned_data`) as we need raw values - field clean methods\n # might \"invalidate\" the value and set it to None, while all we care here is if it was provided at all or not\n email_or_username = self.data.get(self.Fields.EMAIL_OR_USERNAME, None)\n bulk_upload_csv = self.files.get(self.Fields.BULK_UPLOAD, None)\n\n if not email_or_username and not bulk_upload_csv:\n raise ValidationError(ValidationMessages.NO_FIELDS_SPECIFIED)\n\n if email_or_username and bulk_upload_csv:\n raise ValidationError(ValidationMessages.BOTH_FIELDS_SPECIFIED)\n\n if email_or_username:\n mode = self.Modes.MODE_SINGULAR\n else:\n mode = self.Modes.MODE_BULK\n\n cleaned_data[self.Fields.MODE] = mode\n cleaned_data[self.Fields.NOTIFY] = self.clean_notify()\n\n self._validate_course()\n self._validate_program()\n\n if self.data.get(self.Fields.PROGRAM, None) and self.data.get(self.Fields.COURSE, None):\n raise ValidationError(ValidationMessages.COURSE_AND_PROGRAM_ERROR)\n\n return cleaned_data",
"def test_prep_fields(self):\n pass",
"def _clean(self):\n self.cleaned_data = super().clean()\n # Use bound data to set the value if we both have bound and initial data.\n if self.is_bound and self.initial:\n self._set_and_validate_data(self.data)\n return\n else:\n # Set values according to bound data\n if self.is_bound:\n self._set_and_validate_data(self.data)\n return\n # Set values according to initial data\n if self.initial:\n self._set_and_validate_data(self.initial)\n return",
"def test_set_non_dictionary_based_field(self):\n self.assertRaises(TypeError, self._p.set_fields, '')",
"def test_clean_dependent_fields(self):\n data = self.report_data.copy()\n new_primary_complaint = 'housing'\n data.update({'primary_complaint': new_primary_complaint})\n form = ReportEditForm(data, instance=self.report)\n\n self.assertTrue(form.is_valid())\n self.assertTrue('public_or_private_employer' in form.changed_data)\n self.assertTrue('employer_size' not in form.changed_data)\n for field in Report.PRIMARY_COMPLAINT_DEPENDENT_FIELDS['workplace']:\n self.assertTrue(form.cleaned_data[field] == \"\")",
"def test_raise_on_missing_critical(self):\n name_for_field = 'absent_field'\n field_opts = {'names': (name_for_field, 'absent'), 'alt_field': '', 'computed': False}\n critical_fields = {'absent_field': field_opts}\n with self.assertRaises(ImproperlyConfigured):\n self.form.fields_for_critical(critical_fields)",
"def test_construct_values_as_expected(self):\n constructor_fields = ('first', 'second', 'last', )\n values = ['FirstValue', 'SecondValue', 'LastValue']\n expected = '_**_'.join(ea for ea in values if ea).casefold()\n cleaned_data = getattr(self.form, 'cleaned_data', {})\n cleaned_data.update(dict(zip(constructor_fields, values)))\n self.form.cleaned_data = cleaned_data\n actual = self.form.construct_value_from_values(constructor_fields, '_**_')\n simple = self.form.construct_value_from_values(constructor_fields)\n\n self.assertEqual(expected, actual)\n self.assertEqual('firstvalue_**_secondvalue_**_lastvalue', actual)\n self.assertEqual('_'.join(values).casefold(), simple)\n self.assertEqual('firstvalue_secondvalue_lastvalue', simple)",
"def test_raise_attach_broken(self):\n orig_fields = deepcopy(self.form.fields)\n orig_base_fields = deepcopy(self.form.base_fields)\n self.form.fields = None\n self.form.base_fields = None\n with self.assertRaises(ImproperlyConfigured):\n self.form.attach_critical_validators()\n self.form.fields = orig_fields\n self.form.base_fields = orig_base_fields",
"def test_constructor_fields_used_when_email_fails(self):\n self.form.name_for_user = self.form._meta.model.USERNAME_FIELD\n self.form.name_for_email = self.form._meta.model.get_email_field_name()\n existing_email = self.user.email\n new_info = {'first_name': \"Newbie\", 'last_name': \"Newsome\", 'email': existing_email}\n original_data = self.form.data\n test_data = original_data.copy()\n test_data.update(new_info)\n test_data._mutable = False\n self.form.data = test_data\n self.form.is_bound = True\n self.form.cleaned_data = new_info.copy()\n names = (new_info[field_name] for field_name in self.form.constructor_fields)\n expected = '_'.join(names).casefold()\n UserModel = get_user_model()\n cur_user = self.user\n found_user = UserModel.objects.get(username=cur_user.username)\n\n self.assertEqual(cur_user, found_user)\n for key, value in new_info.items():\n self.assertIn(key, self.form.cleaned_data)\n if key in (self.form.name_for_user, self.form.name_for_email):\n continue\n self.assertNotEqual(getattr(self.user, key, None), value)\n result = self.form.username_from_email_or_names(self.form.name_for_user, self.form.name_for_email)\n self.assertEqual(expected, result)\n\n self.form.data = original_data\n del self.form.cleaned_data",
"def test_clean_moves_computed_fields_to_fields(self):\n name = 'test_field'\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n computed_names = list(self.form.computed_fields.keys())\n field_names = list(self.form.fields.keys())\n field_data = {f_name: f\"input_{f_name}_{i}\" for i, f_name in enumerate(field_names)}\n field_data.update({name: f\"value_{f_name}_{i}\" for i, f_name in enumerate(computed_names)})\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy() # mimic full_clean\n populated_cleaned_data = deepcopy(original_cleaned_data or {})\n populated_cleaned_data.update(field_data)\n self.form.cleaned_data = populated_cleaned_data.copy() # ensure cleaned_data is present (mimic full_clean)\n final_cleaned_data = self.form.clean()\n\n self.assertIn(name, computed_names)\n self.assertNotIn(name, field_names)\n self.assertEqual(1, len(computed_names))\n self.assertIn(name, self.form.fields)\n self.assertNotEqual(original_cleaned_data, final_cleaned_data)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def test_raises_set_alt_data(self):\n name, value = 'generic_field', 'alt_data_value'\n field = self.form.fields.get(name, None)\n self.assertIsNotNone(field, \"Unable to find the expected field in current fields. \")\n data = {name: (field, value)}\n\n with self.assertRaises(ImproperlyConfigured):\n self.form.set_alt_data(data=data, name=name, field=field, value=value)",
"def clean(self):\n cleaned_data = super().clean()\n cleaned_data = {key: field for key, field in cleaned_data.items()\n if field is not None}\n return cleaned_data",
"def test_raise_missing_flag_field(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_flag = self.form.USERNAME_FLAG_FIELD\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n original_errors = getattr(self.form, '_errors', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.USERNAME_FLAG_FIELD = 'Not a valid field name'\n self.form.cleaned_data = {self.form.name_for_user: 'test_username', self.form.name_for_email: 'test_email'}\n # self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n self.form._errors = None if original_errors is None else original_errors.copy()\n\n with self.assertRaises(ImproperlyConfigured):\n self.form.configure_username_confirmation()\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.USERNAME_FLAG_FIELD = original_flag\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors\n if original_cleaned_data is None:\n del self.form.cleaned_data\n if original_errors is None:\n del self.form._errors",
"def test_raises_if_initial_fieldsets_error(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }), )\n position_missing_fieldsets = deepcopy(test_fieldsets)\n del position_missing_fieldsets[1][1]['position']\n fields_missing_fieldsets = deepcopy(test_fieldsets)\n del fields_missing_fieldsets[0][1]['fields']\n message = \"There must be 'fields' and 'position' in each fieldset. \"\n self.form.fieldsets = position_missing_fieldsets\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets()\n self.form.fieldsets = fields_missing_fieldsets\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets()\n\n self.form.fieldsets = original_fieldsets",
"def test_cleaned_data_for_compute_success(self):\n name = 'test_field'\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n computed_names = list(self.form.computed_fields.keys())\n field_names = list(self.form.fields.keys())\n field_data = {f_name: f\"input_{f_name}_{i}\" for i, f_name in enumerate(field_names)}\n field_data.update({name: f\"value_{f_name}_{i}\" for i, f_name in enumerate(computed_names)})\n original_errors = deepcopy(self.form._errors)\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n original_cleaned_data = deepcopy(getattr(self.form, 'cleaned_data', None))\n populated_cleaned_data = deepcopy(original_cleaned_data or {})\n populated_cleaned_data.update(field_data)\n self.form.cleaned_data = populated_cleaned_data.copy() # ensure cleaned_data is present (mimic full_clean)\n final_cleaned_data = self.form.clean()\n\n self.assertIn(name, computed_names)\n self.assertNotIn(name, field_names)\n self.assertIn(name, populated_cleaned_data)\n self.assertIn(name, final_cleaned_data)\n self.assertNotEqual(original_cleaned_data, final_cleaned_data)\n\n if original_cleaned_data is None:\n del self.form.cleaned_data\n else:\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors",
"def test_clean_uses_computed(self):\n original_request = self.request\n original_form = self.form\n original_cleaned = getattr(self.form, 'cleaned_data', None)\n self.form = self.make_form_request()\n name = self.form.country_field_name\n initial = self.form.base_fields[name].initial\n cleaned = {'country_flag': True, name: initial}\n self.form.cleaned_data = cleaned\n\n self.assertNotIn(name, self.form.fields)\n self.assertIn(name, self.form.computed_fields)\n with self.assertRaisesMessage(ValidationError, \"You can input your address. \"):\n clean_flag = self.form.clean_country_flag()\n self.form.cleaned_data[name] = ''\n clean_flag = self.form.clean_country_flag()\n self.assertEqual(True, clean_flag)\n\n self.request = original_request\n self.form = original_form\n self.form.cleaned_data = original_cleaned\n if original_cleaned is None:\n del self.form.cleaned_data",
"def clean(self):\n cleaned_data = super().clean()\n if all(val == \"\" for val in cleaned_data.values()):\n raise ValidationError(\"You must fill at least one field!\")\n\n return cleaned_data",
"def test_cleaned_data_for_compute_error(self):\n name = 'test_field'\n message = \"This is the test error on test_field. \"\n original_errors = deepcopy(self.form._errors)\n response = ValidationError(message)\n original_func = deepcopy(self.form.test_func)\n def make_error(value): raise response\n self.form.test_func = make_error\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n computed_names = list(self.form.computed_fields.keys())\n field_names = list(self.form.fields.keys())\n field_data = {f_name: f\"input_{f_name}_{i}\" for i, f_name in enumerate(field_names)}\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n original_cleaned_data = deepcopy(getattr(self.form, 'cleaned_data', None))\n populated_cleaned_data = deepcopy(original_cleaned_data or {})\n populated_cleaned_data.update(field_data)\n populated_cleaned_data.update({name: f\"value_{f_name}_{i}\" for i, f_name in enumerate(computed_names)})\n self.form.cleaned_data = populated_cleaned_data.copy() # ensure cleaned_data is present (mimic full_clean)\n\n with self.assertRaises(ValidationError):\n self.form.clean()\n final_cleaned_data = self.form.cleaned_data\n self.assertIn(name, computed_names)\n self.assertNotIn(name, field_names)\n self.assertIn(name, populated_cleaned_data)\n self.assertNotIn(name, final_cleaned_data)\n self.assertNotEqual(original_cleaned_data, final_cleaned_data)\n self.assertNotEqual(populated_cleaned_data, final_cleaned_data)\n\n if original_cleaned_data is None:\n del self.form.cleaned_data\n else:\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors\n self.form.test_func = original_func",
"def run_validation(self, data=empty):\n\n # no idea why there is no such built in feature in DRF\n if data is not empty:\n unknown = set(data) - set(self.fields)\n if unknown:\n errors = ['Unknown field: {}'.format(f) for f in unknown]\n raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: errors})\n return super().run_validation(data)",
"def run_validation(self, data=empty):\n\n if data is not empty:\n unknown = set(data) - set(self.fields)\n if unknown:\n errors = ['Unknown field: {}'.format(f) for f in unknown]\n raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: errors})\n return super().run_validation(data)"
] | [
"0.7303688",
"0.72501993",
"0.6480992",
"0.6454684",
"0.64145434",
"0.625035",
"0.62435514",
"0.6242395",
"0.62124324",
"0.6206833",
"0.61525655",
"0.60815203",
"0.60424536",
"0.6004057",
"0.59829277",
"0.5976123",
"0.59505343",
"0.59443766",
"0.5935263",
"0.5930225",
"0.5912762",
"0.5888397",
"0.58336616",
"0.57808006",
"0.57344455",
"0.5712698",
"0.56982553",
"0.5678195",
"0.56671995",
"0.5660658"
] | 0.7748659 | 0 |
Return None from construct_value_from_values method if the relevant fields already have recorded errors. | def test_construct_values_skips_already_caught_errors(self):
constructor_fields = ('first', 'second', 'last', )
values = ['FirstValue', 'SecondValue', 'LastValue']
expected = None # Normal is: '_'.join(ea for ea in values if ea).casefold()
cleaned_data = getattr(self.form, 'cleaned_data', {})
cleaned_data.update(dict(zip(constructor_fields[:-1], values[:-1])))
self.form.cleaned_data = cleaned_data
original_errors = deepcopy(self.form._errors)
if self.form._errors is None:
self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict
self.form.add_error('last', 'An error for testing')
actual = self.form.construct_value_from_values(constructor_fields)
self.assertIsNone(actual)
self.assertEqual(expected, actual)
self.form._errors = original_errors | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_construct_values_raises_missing_cleaned_no_error(self):\n constructor_fields = ('first', 'second', 'last', )\n values = ['FirstValue', 'SecondValue', 'LastValue']\n cleaned_data = getattr(self.form, 'cleaned_data', {})\n cleaned_data.update(dict(zip(constructor_fields[:-1], values[:-1])))\n self.form.cleaned_data = cleaned_data\n err = \"This computed value can only be evaluated after fields it depends on have been cleaned. \"\n err += \"The field order must have the computed field after fields used for its value. \"\n with self.assertRaisesMessage(ImproperlyConfigured, err):\n self.form.construct_value_from_values(constructor_fields)",
"def _validate_on_value(self, value: Any) -> None:\n if not self._is_nullable and value is None:\n msg = \"Non-nullable field cannot have None value\"\n if self._resolve_field_name() is not None:\n msg += f\" (field name = '{self._resolve_field_name()}')\"\n raise FieldValueValidationError(msg)",
"def test_construct_values_raises_for_missing_fields(self):\n message = \"There must me one or more field names to compute a value. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.construct_value_from_values()\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.construct_value_from_values('')\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.construct_value_from_values([])",
"def invalid_values_provider(self):\n\n if self.instance_invalid_values is not None:\n return self.instance_invalid_values\n\n if self.class_invalid_values is not None:\n return self.class_invalid_values\n\n return None",
"def validate(self, value):\n if value is None:\n msg = message_factory.get_message('vapi.data.validate.mismatch',\n self.type,\n 'None')\n return [msg]\n return None",
"def validate(self, value):\n errors = DataDefinition.validate(self, value)\n if errors:\n return errors\n\n if value.value is None:\n # None is a valid value for optional\n pass\n elif value.is_set():\n errors = self.element_type.validate(value.value)\n if errors:\n msg = message_factory.get_message('vapi.data.optional.validate')\n return [msg] + errors\n\n return None",
"def validate(self, value):\r\n if value is None:\r\n if self.has_default:\r\n return self.get_default()\r\n elif self.required:\r\n raise ValidationError('{} - None values are not allowed'.format(self.column_name or self.db_field))\r\n return value",
"def validate(self, value):\r\n if value is None:\r\n if self.has_default:\r\n return self.get_default()\r\n elif self.required:\r\n raise ValidationError('{} - None values are not allowed'.format(self.column_name or self.db_field))\r\n return value",
"def test_construct_values_raises_for_missing_cleaned_data(self):\n constructor_fields = ('first', 'second', 'last', )\n if hasattr(self.form, 'cleaned_data'):\n del self.form.cleaned_data\n message = \"This method can only be evaluated after 'cleaned_data' has been populated. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.construct_value_from_values(constructor_fields)",
"def validate(self, value):\n if value is None:\n msg = message_factory.get_message('vapi.data.validate.mismatch',\n self.type,\n 'None')\n return [msg]\n\n if value.type != Type.ERROR:\n msg = message_factory.get_message('vapi.data.validate.mismatch',\n self.type,\n value.type)\n return [msg]\n\n return None",
"def validate(self):\n if self.value is None and self.allow_empty:\n return self.value\n if self.value is None:\n raise Missing(f\"{self.name} is required\")\n if not type(self.value) == self.typ:\n raise ValidationError(\n f\"{self.name} should be {self.typ}. \"\n f\"Found {self.value}.\"\n )\n return self.value",
"def validate(self):\n self.valid = True\n\n if self._value is None and self._strict:\n self.valid = False\n raise self.MissingFieldData\n\n elif self._value is not None:\n self._type_specific_validation()",
"def temp_validator(cls, value, field):\n if value == \"U\":\n LOGGER.warning(\"{field.name} value is 'U'. Setting to None.\")\n return None\n return value",
"def test_get_error_data_when_no_errors(self):\n field_setup = None\n error_names = ['non-field_name', 'not_a_field']\n prepared_info = self.setup_error_data(field_setup, error_names)\n for row in prepared_info:\n self.assertEqual(row['expected'], row['actual'])",
"def non_field_errors(self):\n result = self.errors.get(NON_FIELD_ERRORS, None)\n if not result:\n result = self.errors[NON_FIELD_ERRORS] = self.error_class()\n return result",
"def _get_value(self, instance):\n field_name = self._get_field_name(instance)\n if not instance.has_key(field_name):\n if self.required:\n raise EmptyRequiredField(\"'%s' is required but is empty.\"\n % field_name)\n else:\n instance[field_name] = self._get_default()\n value = instance[field_name]\n if self._get_callback:\n value = self._get_callback(value)\n return value",
"def invalid_values(self):\n\n return self._get_value(self.invalid_values_provider)",
"def convert_values(self, value, field):\n if value is None:\n return None\n if field and field.get_internal_type() == 'DateTimeField':\n if isinstance(value, string_types) and value:\n value = parse_datetime(value)\n return value\n elif field and field.get_internal_type() == 'DateField':\n if isinstance(value, datetime.datetime):\n value = value.date() # extract date\n elif isinstance(value, string_types):\n value = parse_date(value)\n elif field and field.get_internal_type() == 'TimeField':\n if (isinstance(value, datetime.datetime) and value.year == 1900 and value.month == value.day == 1):\n value = value.time() # extract time\n elif isinstance(value, string_types):\n # If the value is a string, parse it using parse_time.\n value = parse_time(value)\n # Some cases (for example when select_related() is used) aren't\n # caught by the DateField case above and date fields arrive from\n # the DB as datetime instances.\n # Implement a workaround stealing the idea from the Oracle\n # backend. It's not perfect so the same warning applies (i.e. if a\n # query results in valid date+time values with the time part set\n # to midnight, this workaround can surprise us by converting them\n # to the datetime.date Python type).\n elif isinstance(value, datetime.datetime) and value.hour == value.minute == value.second == value.microsecond == 0:\n value = value.date()\n # Force floats to the correct type\n elif value is not None and field and field.get_internal_type() == 'FloatField':\n value = float(value)\n return value",
"def warn_on_missing_correlated_fields(cls, values):\n accumulated_warnings = []\n for field_set in CORRELATED_STRUCTURE_FIELDS:\n missing_fields = {f for f in field_set if values.get(f) is None}\n if missing_fields and len(missing_fields) != len(field_set):\n accumulated_warnings += [\n f\"Structure with values {values} is missing fields {missing_fields} which are required if {field_set - missing_fields} are present.\"\n ]\n\n for warn in accumulated_warnings:\n warnings.warn(warn, MissingExpectedField)\n\n return values",
"def _check_value(value, field):\n if not value:\n return False\n\n if field.get('date', False):\n # Get date format\n date_format = field.get('date_format', False) or json_pattern_part.get('date_format', False) or self.master_json_pattern.get('date_format', False)\n if date_format:\n value = datetime.strptime(value, date_format)\n\n if field.get('name'):\n field_name = field.get('name')\n # Get the type of the column and cast if necessary\n field_type = model_obj._columns[field_name]._type\n if field_type == 'integer':\n try:\n value = int(value)\n except (TypeError, ValueError), e:\n logger.warning(\"Cannot convert value of integer field to int : %s for field %s\" % (value, field_name))\n logger.warning(e)\n logger.warn(\"Cannot convert value of integer field to int : %s for field %s\" % (value, field_name))\n elif field_type == 'float':\n try:\n value = float(value)\n except (TypeError, ValueError), e:\n logger.warning(\"Cannot convert value of float field to float : %s for field %s\" % (value, field_name))\n logger.warning(e)\n logger.warn(\"Cannot convert value of float field to float : %s for field %s\" % (value, field_name))\n return value",
"def test_construct_values_raises_on_invalid_normalize(self):\n constructor_fields = ('first', 'second', 'last', )\n values = ['first_value', 'second_value', 'last_value']\n cleaned_data = getattr(self.form, 'cleaned_data', {})\n cleaned_data.update(dict(zip(constructor_fields, values)))\n self.form.cleaned_data = cleaned_data\n normalize = 'not a valid normalize function'\n message = \"The normalize parameter must be a callable or None. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.construct_value_from_values(constructor_fields, normalize=normalize)",
"def resolve_value(self, info, issue_error):\n del info\n assert self is None, \"Root `self` expected to be `None`!\"\n if issue_error:\n raise RuntimeError(Query.VALUE)\n return Query.VALUE",
"def getInvalidValue(self, cls, fieldName):\n field = self.getAvroSchema(cls, fieldName)\n typ = field.type\n if isinstance(typ, avro.schema.UnionSchema):\n typ = typ.schemas[1]\n if isinstance(typ, avro.schema.MapSchema):\n ret = [\"string\"]\n elif isinstance(typ, avro.schema.ArraySchema):\n ret = 42.0\n elif isinstance(typ, avro.schema.EnumSchema):\n ret = \"NO ENUM COULD HAVE THIS NAME\"\n elif isinstance(typ, avro.schema.RecordSchema):\n ret = 42\n elif typ.type in self.badValueMap:\n ret = self.badValueMap[typ.type]\n else:\n raise Exception(\"schema assumptions violated\")\n return ret",
"def _value_for(self, object, name, value):\n try:\n return self.value_for(value)\n except TraitError:\n self.error(object, name, value)",
"def _value_for(self, object, name, value):\n try:\n return self.value_for(value)\n except TraitError:\n self.error(object, name, value)",
"def _validateTs(dErrors, sName, sValue):\n (sValue, sError) = ModelDataBase.validateTs(sValue, fAllowNull = True);\n if sError is not None:\n dErrors[sName] = sError;\n return sValue;",
"def validate(self, source_value):\n errors = defaultdict(list)\n\n for field in self.get_mapping().fields:\n value = get_attribute(source_value, field.name)\n try:\n field.is_valid(value)\n except ValidationError as e:\n errors[field.name].append(e.message)\n\n if errors:\n raise ValidationError(errors)\n else:\n return super(Nested, self).validate(source_value)",
"def toFieldValue(self, value):\n if value is NO_VALUE:\n return self.field.missing_value\n\n if self.widget.subform is None:\n #creepy situation when the widget is hanging in nowhere\n obj = self.createObject(value)\n else:\n if self.widget.subform.ignoreContext:\n obj = self.createObject(value)\n else:\n dm = zope.component.getMultiAdapter(\n (self.widget.context, self.field), IDataManager)\n try:\n obj = dm.get()\n except KeyError:\n obj = {} # self.createObject(value)\n except AttributeError:\n obj = {} # self.createObject(value)\n\n if obj is None or obj == self.field.missing_value:\n #if still None create one, otherwise following will burp\n obj = {}\n\n # don't need to adapt our schema since the dictionary converter\n # will deal with that (never mind how dict do not get adapted).\n\n # obj = self.schema(obj)\n\n names = []\n for name in zope.schema.getFieldNames(self.schema):\n try:\n dm = zope.component.getMultiAdapter(\n (obj, self.schema[name]), IDataManager)\n oldval = dm.query()\n if (oldval != value[name]\n or zope.schema.interfaces.IObject.providedBy(\n self.schema[name])\n ):\n dm.set(value[name])\n names.append(name)\n except KeyError:\n pass\n\n # XXX workaround for JSON import\n try:\n obj = scrub_json_unicode_to_string(obj)\n except:\n # Not really our problem... although it will be nice if\n # we can reset this and then notify end user.\n pass\n\n if names:\n zope.event.notify(\n zope.lifecycleevent.ObjectModifiedEvent(obj,\n zope.lifecycleevent.Attributes(self.schema, *names)))\n return obj",
"def date_errors(self):\r\n try:\r\n _date_errors = self._validate_date(self.sourceDateCol)\r\n return _date_errors\r\n except:\r\n return None",
"def _value_if_not_fixed(o, d):\n if o.fixed:\n return ()\n return (\"value\",)"
] | [
"0.6116071",
"0.60984635",
"0.6093518",
"0.6014954",
"0.58889604",
"0.5845769",
"0.582053",
"0.582053",
"0.5777755",
"0.57416",
"0.5740918",
"0.5679536",
"0.5651429",
"0.5633327",
"0.5632272",
"0.5578322",
"0.55700237",
"0.5566271",
"0.5543094",
"0.5540367",
"0.55272776",
"0.54712385",
"0.5466322",
"0.5461767",
"0.5461767",
"0.5452267",
"0.54342073",
"0.54235494",
"0.54133874",
"0.5401108"
] | 0.6645747 | 0 |
Return None from construct_value_from_values method if the relevant fields already have recorded errors. | def test_construct_values_raises_missing_cleaned_no_error(self):
constructor_fields = ('first', 'second', 'last', )
values = ['FirstValue', 'SecondValue', 'LastValue']
cleaned_data = getattr(self.form, 'cleaned_data', {})
cleaned_data.update(dict(zip(constructor_fields[:-1], values[:-1])))
self.form.cleaned_data = cleaned_data
err = "This computed value can only be evaluated after fields it depends on have been cleaned. "
err += "The field order must have the computed field after fields used for its value. "
with self.assertRaisesMessage(ImproperlyConfigured, err):
self.form.construct_value_from_values(constructor_fields) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_construct_values_skips_already_caught_errors(self):\n constructor_fields = ('first', 'second', 'last', )\n values = ['FirstValue', 'SecondValue', 'LastValue']\n expected = None # Normal is: '_'.join(ea for ea in values if ea).casefold()\n cleaned_data = getattr(self.form, 'cleaned_data', {})\n cleaned_data.update(dict(zip(constructor_fields[:-1], values[:-1])))\n self.form.cleaned_data = cleaned_data\n original_errors = deepcopy(self.form._errors)\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n self.form.add_error('last', 'An error for testing')\n actual = self.form.construct_value_from_values(constructor_fields)\n\n self.assertIsNone(actual)\n self.assertEqual(expected, actual)\n\n self.form._errors = original_errors",
"def _validate_on_value(self, value: Any) -> None:\n if not self._is_nullable and value is None:\n msg = \"Non-nullable field cannot have None value\"\n if self._resolve_field_name() is not None:\n msg += f\" (field name = '{self._resolve_field_name()}')\"\n raise FieldValueValidationError(msg)",
"def test_construct_values_raises_for_missing_fields(self):\n message = \"There must me one or more field names to compute a value. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.construct_value_from_values()\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.construct_value_from_values('')\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.construct_value_from_values([])",
"def invalid_values_provider(self):\n\n if self.instance_invalid_values is not None:\n return self.instance_invalid_values\n\n if self.class_invalid_values is not None:\n return self.class_invalid_values\n\n return None",
"def validate(self, value):\n if value is None:\n msg = message_factory.get_message('vapi.data.validate.mismatch',\n self.type,\n 'None')\n return [msg]\n return None",
"def validate(self, value):\n errors = DataDefinition.validate(self, value)\n if errors:\n return errors\n\n if value.value is None:\n # None is a valid value for optional\n pass\n elif value.is_set():\n errors = self.element_type.validate(value.value)\n if errors:\n msg = message_factory.get_message('vapi.data.optional.validate')\n return [msg] + errors\n\n return None",
"def validate(self, value):\r\n if value is None:\r\n if self.has_default:\r\n return self.get_default()\r\n elif self.required:\r\n raise ValidationError('{} - None values are not allowed'.format(self.column_name or self.db_field))\r\n return value",
"def validate(self, value):\r\n if value is None:\r\n if self.has_default:\r\n return self.get_default()\r\n elif self.required:\r\n raise ValidationError('{} - None values are not allowed'.format(self.column_name or self.db_field))\r\n return value",
"def test_construct_values_raises_for_missing_cleaned_data(self):\n constructor_fields = ('first', 'second', 'last', )\n if hasattr(self.form, 'cleaned_data'):\n del self.form.cleaned_data\n message = \"This method can only be evaluated after 'cleaned_data' has been populated. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.construct_value_from_values(constructor_fields)",
"def validate(self):\n if self.value is None and self.allow_empty:\n return self.value\n if self.value is None:\n raise Missing(f\"{self.name} is required\")\n if not type(self.value) == self.typ:\n raise ValidationError(\n f\"{self.name} should be {self.typ}. \"\n f\"Found {self.value}.\"\n )\n return self.value",
"def validate(self, value):\n if value is None:\n msg = message_factory.get_message('vapi.data.validate.mismatch',\n self.type,\n 'None')\n return [msg]\n\n if value.type != Type.ERROR:\n msg = message_factory.get_message('vapi.data.validate.mismatch',\n self.type,\n value.type)\n return [msg]\n\n return None",
"def validate(self):\n self.valid = True\n\n if self._value is None and self._strict:\n self.valid = False\n raise self.MissingFieldData\n\n elif self._value is not None:\n self._type_specific_validation()",
"def temp_validator(cls, value, field):\n if value == \"U\":\n LOGGER.warning(\"{field.name} value is 'U'. Setting to None.\")\n return None\n return value",
"def test_get_error_data_when_no_errors(self):\n field_setup = None\n error_names = ['non-field_name', 'not_a_field']\n prepared_info = self.setup_error_data(field_setup, error_names)\n for row in prepared_info:\n self.assertEqual(row['expected'], row['actual'])",
"def non_field_errors(self):\n result = self.errors.get(NON_FIELD_ERRORS, None)\n if not result:\n result = self.errors[NON_FIELD_ERRORS] = self.error_class()\n return result",
"def _get_value(self, instance):\n field_name = self._get_field_name(instance)\n if not instance.has_key(field_name):\n if self.required:\n raise EmptyRequiredField(\"'%s' is required but is empty.\"\n % field_name)\n else:\n instance[field_name] = self._get_default()\n value = instance[field_name]\n if self._get_callback:\n value = self._get_callback(value)\n return value",
"def convert_values(self, value, field):\n if value is None:\n return None\n if field and field.get_internal_type() == 'DateTimeField':\n if isinstance(value, string_types) and value:\n value = parse_datetime(value)\n return value\n elif field and field.get_internal_type() == 'DateField':\n if isinstance(value, datetime.datetime):\n value = value.date() # extract date\n elif isinstance(value, string_types):\n value = parse_date(value)\n elif field and field.get_internal_type() == 'TimeField':\n if (isinstance(value, datetime.datetime) and value.year == 1900 and value.month == value.day == 1):\n value = value.time() # extract time\n elif isinstance(value, string_types):\n # If the value is a string, parse it using parse_time.\n value = parse_time(value)\n # Some cases (for example when select_related() is used) aren't\n # caught by the DateField case above and date fields arrive from\n # the DB as datetime instances.\n # Implement a workaround stealing the idea from the Oracle\n # backend. It's not perfect so the same warning applies (i.e. if a\n # query results in valid date+time values with the time part set\n # to midnight, this workaround can surprise us by converting them\n # to the datetime.date Python type).\n elif isinstance(value, datetime.datetime) and value.hour == value.minute == value.second == value.microsecond == 0:\n value = value.date()\n # Force floats to the correct type\n elif value is not None and field and field.get_internal_type() == 'FloatField':\n value = float(value)\n return value",
"def invalid_values(self):\n\n return self._get_value(self.invalid_values_provider)",
"def _check_value(value, field):\n if not value:\n return False\n\n if field.get('date', False):\n # Get date format\n date_format = field.get('date_format', False) or json_pattern_part.get('date_format', False) or self.master_json_pattern.get('date_format', False)\n if date_format:\n value = datetime.strptime(value, date_format)\n\n if field.get('name'):\n field_name = field.get('name')\n # Get the type of the column and cast if necessary\n field_type = model_obj._columns[field_name]._type\n if field_type == 'integer':\n try:\n value = int(value)\n except (TypeError, ValueError), e:\n logger.warning(\"Cannot convert value of integer field to int : %s for field %s\" % (value, field_name))\n logger.warning(e)\n logger.warn(\"Cannot convert value of integer field to int : %s for field %s\" % (value, field_name))\n elif field_type == 'float':\n try:\n value = float(value)\n except (TypeError, ValueError), e:\n logger.warning(\"Cannot convert value of float field to float : %s for field %s\" % (value, field_name))\n logger.warning(e)\n logger.warn(\"Cannot convert value of float field to float : %s for field %s\" % (value, field_name))\n return value",
"def warn_on_missing_correlated_fields(cls, values):\n accumulated_warnings = []\n for field_set in CORRELATED_STRUCTURE_FIELDS:\n missing_fields = {f for f in field_set if values.get(f) is None}\n if missing_fields and len(missing_fields) != len(field_set):\n accumulated_warnings += [\n f\"Structure with values {values} is missing fields {missing_fields} which are required if {field_set - missing_fields} are present.\"\n ]\n\n for warn in accumulated_warnings:\n warnings.warn(warn, MissingExpectedField)\n\n return values",
"def test_construct_values_raises_on_invalid_normalize(self):\n constructor_fields = ('first', 'second', 'last', )\n values = ['first_value', 'second_value', 'last_value']\n cleaned_data = getattr(self.form, 'cleaned_data', {})\n cleaned_data.update(dict(zip(constructor_fields, values)))\n self.form.cleaned_data = cleaned_data\n normalize = 'not a valid normalize function'\n message = \"The normalize parameter must be a callable or None. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.construct_value_from_values(constructor_fields, normalize=normalize)",
"def resolve_value(self, info, issue_error):\n del info\n assert self is None, \"Root `self` expected to be `None`!\"\n if issue_error:\n raise RuntimeError(Query.VALUE)\n return Query.VALUE",
"def getInvalidValue(self, cls, fieldName):\n field = self.getAvroSchema(cls, fieldName)\n typ = field.type\n if isinstance(typ, avro.schema.UnionSchema):\n typ = typ.schemas[1]\n if isinstance(typ, avro.schema.MapSchema):\n ret = [\"string\"]\n elif isinstance(typ, avro.schema.ArraySchema):\n ret = 42.0\n elif isinstance(typ, avro.schema.EnumSchema):\n ret = \"NO ENUM COULD HAVE THIS NAME\"\n elif isinstance(typ, avro.schema.RecordSchema):\n ret = 42\n elif typ.type in self.badValueMap:\n ret = self.badValueMap[typ.type]\n else:\n raise Exception(\"schema assumptions violated\")\n return ret",
"def _value_for(self, object, name, value):\n try:\n return self.value_for(value)\n except TraitError:\n self.error(object, name, value)",
"def _value_for(self, object, name, value):\n try:\n return self.value_for(value)\n except TraitError:\n self.error(object, name, value)",
"def _validateTs(dErrors, sName, sValue):\n (sValue, sError) = ModelDataBase.validateTs(sValue, fAllowNull = True);\n if sError is not None:\n dErrors[sName] = sError;\n return sValue;",
"def validate(self, source_value):\n errors = defaultdict(list)\n\n for field in self.get_mapping().fields:\n value = get_attribute(source_value, field.name)\n try:\n field.is_valid(value)\n except ValidationError as e:\n errors[field.name].append(e.message)\n\n if errors:\n raise ValidationError(errors)\n else:\n return super(Nested, self).validate(source_value)",
"def toFieldValue(self, value):\n if value is NO_VALUE:\n return self.field.missing_value\n\n if self.widget.subform is None:\n #creepy situation when the widget is hanging in nowhere\n obj = self.createObject(value)\n else:\n if self.widget.subform.ignoreContext:\n obj = self.createObject(value)\n else:\n dm = zope.component.getMultiAdapter(\n (self.widget.context, self.field), IDataManager)\n try:\n obj = dm.get()\n except KeyError:\n obj = {} # self.createObject(value)\n except AttributeError:\n obj = {} # self.createObject(value)\n\n if obj is None or obj == self.field.missing_value:\n #if still None create one, otherwise following will burp\n obj = {}\n\n # don't need to adapt our schema since the dictionary converter\n # will deal with that (never mind how dict do not get adapted).\n\n # obj = self.schema(obj)\n\n names = []\n for name in zope.schema.getFieldNames(self.schema):\n try:\n dm = zope.component.getMultiAdapter(\n (obj, self.schema[name]), IDataManager)\n oldval = dm.query()\n if (oldval != value[name]\n or zope.schema.interfaces.IObject.providedBy(\n self.schema[name])\n ):\n dm.set(value[name])\n names.append(name)\n except KeyError:\n pass\n\n # XXX workaround for JSON import\n try:\n obj = scrub_json_unicode_to_string(obj)\n except:\n # Not really our problem... although it will be nice if\n # we can reset this and then notify end user.\n pass\n\n if names:\n zope.event.notify(\n zope.lifecycleevent.ObjectModifiedEvent(obj,\n zope.lifecycleevent.Attributes(self.schema, *names)))\n return obj",
"def date_errors(self):\r\n try:\r\n _date_errors = self._validate_date(self.sourceDateCol)\r\n return _date_errors\r\n except:\r\n return None",
"def _value_if_not_fixed(o, d):\n if o.fixed:\n return ()\n return (\"value\",)"
] | [
"0.6646825",
"0.6098643",
"0.60949165",
"0.6014171",
"0.58864",
"0.58449906",
"0.582161",
"0.582161",
"0.5779063",
"0.5741431",
"0.5738686",
"0.5678554",
"0.56530637",
"0.5630864",
"0.5628875",
"0.5584341",
"0.55723536",
"0.5568853",
"0.55446196",
"0.55417526",
"0.5529097",
"0.54735255",
"0.54668516",
"0.5464585",
"0.5464585",
"0.5452399",
"0.54334563",
"0.5429722",
"0.5409355",
"0.5405516"
] | 0.6117588 | 1 |
A computed field's custom compute method is called when appropriate in the _clean_computed_fields method. | def test_field_compute_method_called_in_clean_computed_fields(self):
name = 'test_field'
expected = 'compute_confirmed'
self.form.test_value = expected
modified = self.form.test_func(expected)
original_func = deepcopy(self.form.test_func)
def pass_through(value): return value
self.form.test_func = pass_through
if isinstance(self.form.computed_fields, (list, tuple)):
self.form.computed_fields = self.form.get_computed_fields([name])
original_errors = deepcopy(self.form._errors)
if self.form._errors is None:
self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict
self.form.cleaned_data = getattr(self.form, 'cleaned_data', {}) # mimic full_clean: cleaned_data is present
compute_errors = self.form._clean_computed_fields()
actual = self.form.cleaned_data.get(name, None)
self.assertFalse(compute_errors)
self.assertEqual(expected, actual)
self.form.test_func = original_func
restored = self.form.test_func(expected)
self.assertEqual(modified, restored)
self.form._errors = original_errors | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_field_clean_method_called_in_clean_computed_fields(self):\n name = 'test_field'\n expected = 'clean_confirmed'\n original_func = deepcopy(self.form.test_func)\n def replace_value(value): return expected\n self.form.test_func = replace_value\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n field = self.form.computed_fields.get(name) # getattr(self.form, name)\n # initial_value = self.get_initial_for_field(field, name)\n value = getattr(self.form, 'compute_%s' % name)()\n value = field.clean(value)\n original_errors = deepcopy(self.form._errors)\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n cleaned_data = getattr(self.form, 'cleaned_data', {})\n cleaned_data.update({name: value}) # make sure the original cleaned_data for the field is set.\n self.form.cleaned_data = cleaned_data # ensure cleaned_data is present (mimic full_clean)\n compute_errors = self.form._clean_computed_fields()\n actual = self.form.cleaned_data.get(name, None)\n\n self.assertFalse(compute_errors)\n self.assertEqual(expected, actual)\n self.assertNotEqual(expected, value)\n self.assertNotEqual(expected, self.form.test_value)\n\n self.form.test_func = original_func\n self.form._errors = original_errors",
"def test_fields_updated_with_computed(self):\n pass",
"def test_cleaned_data_modified_by_clean_computed_fields(self):\n name = 'test_field'\n field = self.form.computed_fields.get(name) # getattr(self.form, name) for BoundField instance for Field.\n value = self.form.compute_test_field()\n value = field.clean(value)\n expected = self.form.test_func(value)\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n original_errors = deepcopy(self.form._errors)\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n self.form.cleaned_data = getattr(self.form, 'cleaned_data', {}) # mimic full_clean: cleaned_data is present\n original = self.form.cleaned_data.get(name, None)\n compute_errors = self.form._clean_computed_fields()\n actual = self.form.cleaned_data.get(name, '')\n\n self.assertFalse(compute_errors)\n self.assertNotEqual(original, actual)\n self.assertNotEqual(original, expected)\n self.assertEqual(expected, actual)\n\n self.form._errors = original_errors",
"def test_validation_errors_assigned_in_clean_computed_fields(self):\n name = 'test_field'\n message = \"This is the test error on test_field. \"\n response = ValidationError(message)\n expected_compute_errors = ErrorDict({name: response}) # similar to return of _clean_computed_fields\n original_func = deepcopy(self.form.test_func)\n def make_error(value): raise response\n self.form.test_func = make_error\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n self.form.cleaned_data = getattr(self.form, 'cleaned_data', {}) # mimic full_clean: cleaned_data is present\n actual_compute_errors = self.form._clean_computed_fields()\n\n self.assertDictEqual(expected_compute_errors, actual_compute_errors)\n self.form.test_func = original_func",
"def compute(self):\n if self._computed:\n return\n\n self._compute()\n self._computed = True",
"def test_clean_moves_computed_fields_to_fields(self):\n name = 'test_field'\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n computed_names = list(self.form.computed_fields.keys())\n field_names = list(self.form.fields.keys())\n field_data = {f_name: f\"input_{f_name}_{i}\" for i, f_name in enumerate(field_names)}\n field_data.update({name: f\"value_{f_name}_{i}\" for i, f_name in enumerate(computed_names)})\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy() # mimic full_clean\n populated_cleaned_data = deepcopy(original_cleaned_data or {})\n populated_cleaned_data.update(field_data)\n self.form.cleaned_data = populated_cleaned_data.copy() # ensure cleaned_data is present (mimic full_clean)\n final_cleaned_data = self.form.clean()\n\n self.assertIn(name, computed_names)\n self.assertNotIn(name, field_names)\n self.assertEqual(1, len(computed_names))\n self.assertIn(name, self.form.fields)\n self.assertNotEqual(original_cleaned_data, final_cleaned_data)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def compute_value(self, *args, **kwargs):\n\n return None",
"def compute(self, **kwargs):\n raise NotImplementedError",
"def isComputed(self) -> bool:\n ...",
"def test_use_existing_computed_field_dict(self):\n if isinstance(self.form.computed_fields, list):\n self.form.computed_fields = self.form.get_computed_fields(self.form.computed_fields)\n self.form.fields.update(self.form.computed_fields) # only names in fields included in get_computed_field_names.\n result_names = self.form.get_computed_field_names([], self.form.fields)\n\n self.assertIsInstance(self.form.computed_fields, dict)\n self.assertIn('test_field', result_names)",
"def test_validation_error_for_compute_error(self):\n name = 'test_field'\n message = \"This is the test error on test_field. \"\n response = ValidationError(message)\n original_errors = deepcopy(self.form._errors)\n expected_errors = ErrorDict() # similar to Form.full_clean\n expected_errors[name] = self.form.error_class()\n expected_errors[name].append(response) # similar to add_error(None, message) in _clean_computed...\n clean_message_on_compute_errors = \"Error occurred with the computed fields. \"\n clean_error_on_compute_errors = ValidationError(clean_message_on_compute_errors)\n expected_errors[NON_FIELD_ERRORS] = self.form.error_class(error_class='nonfield') # first add_error(None, err)\n expected_errors[NON_FIELD_ERRORS].append(clean_error_on_compute_errors) # similar to add_error(None, string)\n original_func = deepcopy(self.form.test_func)\n def make_error(value): raise response\n self.form.test_func = make_error\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.cleaned_data = getattr(self.form, 'cleaned_data', {}) # mimic full_clean: cleaned_data is present\n self.form._clean_form() # adds to Form._error if ValidationError raised by Form.clean.\n\n self.assertNotEqual(original_errors, self.form._errors)\n self.assertEqual(expected_errors, self.form._errors)\n\n if original_cleaned_data is None:\n del self.form.cleaned_data\n else:\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors\n self.form.test_func = original_func",
"def calc_field_equation(self, calc_field_equation):\n\n self._calc_field_equation = calc_field_equation",
"def calc_field_equation(self, calc_field_equation):\n\n self._calc_field_equation = calc_field_equation",
"def test_clean_uses_computed(self):\n original_request = self.request\n original_form = self.form\n original_cleaned = getattr(self.form, 'cleaned_data', None)\n self.form = self.make_form_request()\n name = self.form.country_field_name\n initial = self.form.base_fields[name].initial\n cleaned = {'country_flag': True, name: initial}\n self.form.cleaned_data = cleaned\n\n self.assertNotIn(name, self.form.fields)\n self.assertIn(name, self.form.computed_fields)\n with self.assertRaisesMessage(ValidationError, \"You can input your address. \"):\n clean_flag = self.form.clean_country_flag()\n self.form.cleaned_data[name] = ''\n clean_flag = self.form.clean_country_flag()\n self.assertEqual(True, clean_flag)\n\n self.request = original_request\n self.form = original_form\n self.form.cleaned_data = original_cleaned\n if original_cleaned is None:\n del self.form.cleaned_data",
"def _do_compute(self, var_map):\n raise Exception(\"Not implemented. Subclass responsibility\")",
"def test_cleaned_data_for_compute_success(self):\n name = 'test_field'\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n computed_names = list(self.form.computed_fields.keys())\n field_names = list(self.form.fields.keys())\n field_data = {f_name: f\"input_{f_name}_{i}\" for i, f_name in enumerate(field_names)}\n field_data.update({name: f\"value_{f_name}_{i}\" for i, f_name in enumerate(computed_names)})\n original_errors = deepcopy(self.form._errors)\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n original_cleaned_data = deepcopy(getattr(self.form, 'cleaned_data', None))\n populated_cleaned_data = deepcopy(original_cleaned_data or {})\n populated_cleaned_data.update(field_data)\n self.form.cleaned_data = populated_cleaned_data.copy() # ensure cleaned_data is present (mimic full_clean)\n final_cleaned_data = self.form.clean()\n\n self.assertIn(name, computed_names)\n self.assertNotIn(name, field_names)\n self.assertIn(name, populated_cleaned_data)\n self.assertIn(name, final_cleaned_data)\n self.assertNotEqual(original_cleaned_data, final_cleaned_data)\n\n if original_cleaned_data is None:\n del self.form.cleaned_data\n else:\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors",
"def compute(self, *args):\n return _ITKCostFunctionsPython.itkMultipleValuedVnlCostFunctionAdaptor_compute(self, *args)",
"def make_field(self):\n def field_func(m):\n return self.hext + field.demagnetization(m, self.Nd)\n self.field = field_func",
"def test_raise_on_corrupt_computed_fields(self):\n initial = self.form.computed_fields\n self.form.computed_fields = 'This is a broken value'\n with self.assertRaises(ImproperlyConfigured):\n self.form.get_computed_field_names([], self.form.fields)\n self.form.computed_fields = None\n with self.assertRaises(ImproperlyConfigured):\n self.form.get_computed_field_names([], self.form.fields)\n self.form.computed_fields = initial",
"def compute(self, *args):\n\n pass",
"def compute(self, **kwargs: Any) -> Any:\n raise NotImplementedError(\"Inheriting class must implement this method.\")",
"def EvaluateFields(self, *float, **kwargs):\n ...",
"def precalculate():\n pass",
"def precalculate():\n pass",
"def test_cleaned_data_for_compute_error(self):\n name = 'test_field'\n message = \"This is the test error on test_field. \"\n original_errors = deepcopy(self.form._errors)\n response = ValidationError(message)\n original_func = deepcopy(self.form.test_func)\n def make_error(value): raise response\n self.form.test_func = make_error\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n computed_names = list(self.form.computed_fields.keys())\n field_names = list(self.form.fields.keys())\n field_data = {f_name: f\"input_{f_name}_{i}\" for i, f_name in enumerate(field_names)}\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n original_cleaned_data = deepcopy(getattr(self.form, 'cleaned_data', None))\n populated_cleaned_data = deepcopy(original_cleaned_data or {})\n populated_cleaned_data.update(field_data)\n populated_cleaned_data.update({name: f\"value_{f_name}_{i}\" for i, f_name in enumerate(computed_names)})\n self.form.cleaned_data = populated_cleaned_data.copy() # ensure cleaned_data is present (mimic full_clean)\n\n with self.assertRaises(ValidationError):\n self.form.clean()\n final_cleaned_data = self.form.cleaned_data\n self.assertIn(name, computed_names)\n self.assertNotIn(name, field_names)\n self.assertIn(name, populated_cleaned_data)\n self.assertNotIn(name, final_cleaned_data)\n self.assertNotEqual(original_cleaned_data, final_cleaned_data)\n self.assertNotEqual(populated_cleaned_data, final_cleaned_data)\n\n if original_cleaned_data is None:\n del self.form.cleaned_data\n else:\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors\n self.form.test_func = original_func",
"def __call__(self, collection, field):\n pass",
"def compute(self, verbose: bool = False, lineage: bool = False) -> Any:\n raise NotImplementedError",
"def compute(*args, **kwargs):\n args = [value(a) for a in args]\n return base.compute(*args, **kwargs)",
"def make_field(self):\n uniaxial = self.u[0]*self.u[1]*self.u[2] != 0\n cubic = self.c1[0]*self.c1[1]*self.c1[2]*self.c2[0]*self.c2[1]*self.c2[2] != 0\n @nb.njit\n def field_func(m):\n heff = self.hext + field.demagnetization(m, self.Nd)\n if uniaxial:\n heff += field.uniaxial_anisotropy(m, self.u, self.hu1, self.hu2)\n if cubic:\n heff += field.cubic_anisotropy(m, self.c1, self.c2, self.c3, self.hc1, self.hc2)\n return heff\n self.field = field_func",
"def _compute_amount(self):\n raise NotImplementedError()"
] | [
"0.68851066",
"0.66450715",
"0.63397217",
"0.6169532",
"0.5776098",
"0.5741612",
"0.5698317",
"0.56844103",
"0.5668421",
"0.5624036",
"0.5601307",
"0.551413",
"0.551413",
"0.5464949",
"0.5451739",
"0.5447752",
"0.5444789",
"0.5438681",
"0.54166895",
"0.54082006",
"0.5313347",
"0.5310052",
"0.52967054",
"0.52967054",
"0.5261055",
"0.5251249",
"0.52340674",
"0.5230633",
"0.52127594",
"0.519899"
] | 0.74964064 | 0 |
A computed field's custom clean method is called when appropriate in the _clean_computed_fields method. | def test_field_clean_method_called_in_clean_computed_fields(self):
name = 'test_field'
expected = 'clean_confirmed'
original_func = deepcopy(self.form.test_func)
def replace_value(value): return expected
self.form.test_func = replace_value
if isinstance(self.form.computed_fields, (list, tuple)):
self.form.computed_fields = self.form.get_computed_fields([name])
field = self.form.computed_fields.get(name) # getattr(self.form, name)
# initial_value = self.get_initial_for_field(field, name)
value = getattr(self.form, 'compute_%s' % name)()
value = field.clean(value)
original_errors = deepcopy(self.form._errors)
if self.form._errors is None:
self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict
cleaned_data = getattr(self.form, 'cleaned_data', {})
cleaned_data.update({name: value}) # make sure the original cleaned_data for the field is set.
self.form.cleaned_data = cleaned_data # ensure cleaned_data is present (mimic full_clean)
compute_errors = self.form._clean_computed_fields()
actual = self.form.cleaned_data.get(name, None)
self.assertFalse(compute_errors)
self.assertEqual(expected, actual)
self.assertNotEqual(expected, value)
self.assertNotEqual(expected, self.form.test_value)
self.form.test_func = original_func
self.form._errors = original_errors | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_field_compute_method_called_in_clean_computed_fields(self):\n name = 'test_field'\n expected = 'compute_confirmed'\n self.form.test_value = expected\n modified = self.form.test_func(expected)\n original_func = deepcopy(self.form.test_func)\n def pass_through(value): return value\n self.form.test_func = pass_through\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n original_errors = deepcopy(self.form._errors)\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n self.form.cleaned_data = getattr(self.form, 'cleaned_data', {}) # mimic full_clean: cleaned_data is present\n compute_errors = self.form._clean_computed_fields()\n actual = self.form.cleaned_data.get(name, None)\n\n self.assertFalse(compute_errors)\n self.assertEqual(expected, actual)\n\n self.form.test_func = original_func\n restored = self.form.test_func(expected)\n self.assertEqual(modified, restored)\n self.form._errors = original_errors",
"def test_cleaned_data_modified_by_clean_computed_fields(self):\n name = 'test_field'\n field = self.form.computed_fields.get(name) # getattr(self.form, name) for BoundField instance for Field.\n value = self.form.compute_test_field()\n value = field.clean(value)\n expected = self.form.test_func(value)\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n original_errors = deepcopy(self.form._errors)\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n self.form.cleaned_data = getattr(self.form, 'cleaned_data', {}) # mimic full_clean: cleaned_data is present\n original = self.form.cleaned_data.get(name, None)\n compute_errors = self.form._clean_computed_fields()\n actual = self.form.cleaned_data.get(name, '')\n\n self.assertFalse(compute_errors)\n self.assertNotEqual(original, actual)\n self.assertNotEqual(original, expected)\n self.assertEqual(expected, actual)\n\n self.form._errors = original_errors",
"def test_clean_moves_computed_fields_to_fields(self):\n name = 'test_field'\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n computed_names = list(self.form.computed_fields.keys())\n field_names = list(self.form.fields.keys())\n field_data = {f_name: f\"input_{f_name}_{i}\" for i, f_name in enumerate(field_names)}\n field_data.update({name: f\"value_{f_name}_{i}\" for i, f_name in enumerate(computed_names)})\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy() # mimic full_clean\n populated_cleaned_data = deepcopy(original_cleaned_data or {})\n populated_cleaned_data.update(field_data)\n self.form.cleaned_data = populated_cleaned_data.copy() # ensure cleaned_data is present (mimic full_clean)\n final_cleaned_data = self.form.clean()\n\n self.assertIn(name, computed_names)\n self.assertNotIn(name, field_names)\n self.assertEqual(1, len(computed_names))\n self.assertIn(name, self.form.fields)\n self.assertNotEqual(original_cleaned_data, final_cleaned_data)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def test_validation_errors_assigned_in_clean_computed_fields(self):\n name = 'test_field'\n message = \"This is the test error on test_field. \"\n response = ValidationError(message)\n expected_compute_errors = ErrorDict({name: response}) # similar to return of _clean_computed_fields\n original_func = deepcopy(self.form.test_func)\n def make_error(value): raise response\n self.form.test_func = make_error\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n self.form.cleaned_data = getattr(self.form, 'cleaned_data', {}) # mimic full_clean: cleaned_data is present\n actual_compute_errors = self.form._clean_computed_fields()\n\n self.assertDictEqual(expected_compute_errors, actual_compute_errors)\n self.form.test_func = original_func",
"def test_clean_uses_computed(self):\n original_request = self.request\n original_form = self.form\n original_cleaned = getattr(self.form, 'cleaned_data', None)\n self.form = self.make_form_request()\n name = self.form.country_field_name\n initial = self.form.base_fields[name].initial\n cleaned = {'country_flag': True, name: initial}\n self.form.cleaned_data = cleaned\n\n self.assertNotIn(name, self.form.fields)\n self.assertIn(name, self.form.computed_fields)\n with self.assertRaisesMessage(ValidationError, \"You can input your address. \"):\n clean_flag = self.form.clean_country_flag()\n self.form.cleaned_data[name] = ''\n clean_flag = self.form.clean_country_flag()\n self.assertEqual(True, clean_flag)\n\n self.request = original_request\n self.form = original_form\n self.form.cleaned_data = original_cleaned\n if original_cleaned is None:\n del self.form.cleaned_data",
"def clean(self, *args, **kwargs):\n self.is_cleaned = True",
"def custom_cleaning_before_rules(dc):\n pass",
"def autostrip(cls):\r\n fields = [(key, value)\r\n for key, value in cls.base_fields.iteritems()\r\n if isinstance(value, CharField)]\r\n for field_name, field_object in fields:\r\n def get_clean_func(original_clean):\r\n return lambda value: original_clean(value and value.strip())\r\n clean_func = get_clean_func(getattr(field_object, 'clean'))\r\n setattr(field_object, 'clean', clean_func)\r\n return cls",
"def test_fields_updated_with_computed(self):\n pass",
"def autostrip(cls):\n fields = [(key, value) for key, value in cls.base_fields.iteritems()\n if isinstance(value, forms.CharField)]\n for field_name, field_object in fields:\n def get_clean_func(original_clean):\n return lambda value: original_clean(value and value.strip())\n clean_func = get_clean_func(getattr(field_object, 'clean'))\n setattr(field_object, 'clean', clean_func)\n return cls",
"def clean(self, field_path=None):\n cleaned = self._collection.clean(field_path)\n return self.set_collection(cleaned)",
"def clean(self):\n return",
"def _clean(self):\n self.cleaned_data = super().clean()\n # Use bound data to set the value if we both have bound and initial data.\n if self.is_bound and self.initial:\n self._set_and_validate_data(self.data)\n return\n else:\n # Set values according to bound data\n if self.is_bound:\n self._set_and_validate_data(self.data)\n return\n # Set values according to initial data\n if self.initial:\n self._set_and_validate_data(self.initial)\n return",
"def clean_fields(self, *args, **kwargs):\n if self.ipi_name:\n self.ipi_name = self.ipi_name.zfill(11)\n if self.ipi_base:\n self.ipi_base = self.ipi_base.replace(\".\", \"\").upper()\n self.ipi_base = re.sub(\n r\"(I).?(\\d{9}).?(\\d)\", r\"\\1-\\2-\\3\", self.ipi_base\n )\n return super().clean_fields(*args, **kwargs)",
"def full_clean(self):\n self._errors = ErrorDict()\n if not self.is_bound: # Stop further processing.\n return\n self.cleaned_data = {}\n if self.empty_permitted and not self.has_changed():\n self.cleaned_data = None\n return\n for name, field in self.fields.items():\n self.clean_field(name, field)\n try:\n self.cleaned_data = self.clean()\n except ValidationError, e:\n self._errors[NON_FIELD_ERRORS] = e.messages\n if self._errors:\n delattr(self, 'cleaned_data')",
"def clean_fields(self, *args, **kwargs):\n if self.saan:\n self.saan = self.saan.upper() # only in CWR, uppercase anyway\n super().clean_fields(*args, **kwargs)",
"def test_cleaned_data_for_compute_error(self):\n name = 'test_field'\n message = \"This is the test error on test_field. \"\n original_errors = deepcopy(self.form._errors)\n response = ValidationError(message)\n original_func = deepcopy(self.form.test_func)\n def make_error(value): raise response\n self.form.test_func = make_error\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n computed_names = list(self.form.computed_fields.keys())\n field_names = list(self.form.fields.keys())\n field_data = {f_name: f\"input_{f_name}_{i}\" for i, f_name in enumerate(field_names)}\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n original_cleaned_data = deepcopy(getattr(self.form, 'cleaned_data', None))\n populated_cleaned_data = deepcopy(original_cleaned_data or {})\n populated_cleaned_data.update(field_data)\n populated_cleaned_data.update({name: f\"value_{f_name}_{i}\" for i, f_name in enumerate(computed_names)})\n self.form.cleaned_data = populated_cleaned_data.copy() # ensure cleaned_data is present (mimic full_clean)\n\n with self.assertRaises(ValidationError):\n self.form.clean()\n final_cleaned_data = self.form.cleaned_data\n self.assertIn(name, computed_names)\n self.assertNotIn(name, field_names)\n self.assertIn(name, populated_cleaned_data)\n self.assertNotIn(name, final_cleaned_data)\n self.assertNotEqual(original_cleaned_data, final_cleaned_data)\n self.assertNotEqual(populated_cleaned_data, final_cleaned_data)\n\n if original_cleaned_data is None:\n del self.form.cleaned_data\n else:\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors\n self.form.test_func = original_func",
"def clean(cls, value):\n return",
"def test_cleaned_data_for_compute_success(self):\n name = 'test_field'\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n computed_names = list(self.form.computed_fields.keys())\n field_names = list(self.form.fields.keys())\n field_data = {f_name: f\"input_{f_name}_{i}\" for i, f_name in enumerate(field_names)}\n field_data.update({name: f\"value_{f_name}_{i}\" for i, f_name in enumerate(computed_names)})\n original_errors = deepcopy(self.form._errors)\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n original_cleaned_data = deepcopy(getattr(self.form, 'cleaned_data', None))\n populated_cleaned_data = deepcopy(original_cleaned_data or {})\n populated_cleaned_data.update(field_data)\n self.form.cleaned_data = populated_cleaned_data.copy() # ensure cleaned_data is present (mimic full_clean)\n final_cleaned_data = self.form.clean()\n\n self.assertIn(name, computed_names)\n self.assertNotIn(name, field_names)\n self.assertIn(name, populated_cleaned_data)\n self.assertIn(name, final_cleaned_data)\n self.assertNotEqual(original_cleaned_data, final_cleaned_data)\n\n if original_cleaned_data is None:\n del self.form.cleaned_data\n else:\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors",
"def clean_empty_field(field_name):\n\n @check_field_is_empty(field_name)\n def wrapper(self):\n \"\"\"Decorator wrapper method.\n \"\"\"\n return self.cleaned_data.get(field_name)\n\n return wrapper",
"def clean_form_with_field_errors(original_function, self):\n \n from django.core.exceptions import ValidationError\n try:\n self.cleaned_data = self.clean()\n except ValidationError, e:\n if hasattr(e, 'message_dict'):\n for field, error_strings in e.message_dict.items():\n self._errors[field] = self.error_class(error_strings)\n else:\n self._errors[NON_FIELD_ERRORS] = self.error_class(e.messages)",
"def clean(self):",
"def clean(self):\n\n pass",
"def clean(self, value):\n if not value:\n raise ValidationError(\n 'Error found in Form Field: Nothing to validate')\n\n data = dict((bf.name, value[i]) for i, bf in enumerate(self.form))\n self.form = form = self.form.__class__(data)\n if not form.is_valid():\n error_dict = list(form.errors.items())\n errors = striptags(\n \", \".join([\"%s (%s)\" % (v, k) for k, v in error_dict]))\n raise ValidationError('Error(s) found: %s' % errors)\n\n # This call will ensure compress is called as expected.\n return super(FormField, self).clean(value)",
"def _validate_fields(self, change_fields):\n pass",
"def test_raise_on_corrupt_computed_fields(self):\n initial = self.form.computed_fields\n self.form.computed_fields = 'This is a broken value'\n with self.assertRaises(ImproperlyConfigured):\n self.form.get_computed_field_names([], self.form.fields)\n self.form.computed_fields = None\n with self.assertRaises(ImproperlyConfigured):\n self.form.get_computed_field_names([], self.form.fields)\n self.form.computed_fields = initial",
"def test_validation_error_for_compute_error(self):\n name = 'test_field'\n message = \"This is the test error on test_field. \"\n response = ValidationError(message)\n original_errors = deepcopy(self.form._errors)\n expected_errors = ErrorDict() # similar to Form.full_clean\n expected_errors[name] = self.form.error_class()\n expected_errors[name].append(response) # similar to add_error(None, message) in _clean_computed...\n clean_message_on_compute_errors = \"Error occurred with the computed fields. \"\n clean_error_on_compute_errors = ValidationError(clean_message_on_compute_errors)\n expected_errors[NON_FIELD_ERRORS] = self.form.error_class(error_class='nonfield') # first add_error(None, err)\n expected_errors[NON_FIELD_ERRORS].append(clean_error_on_compute_errors) # similar to add_error(None, string)\n original_func = deepcopy(self.form.test_func)\n def make_error(value): raise response\n self.form.test_func = make_error\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.cleaned_data = getattr(self.form, 'cleaned_data', {}) # mimic full_clean: cleaned_data is present\n self.form._clean_form() # adds to Form._error if ValidationError raised by Form.clean.\n\n self.assertNotEqual(original_errors, self.form._errors)\n self.assertEqual(expected_errors, self.form._errors)\n\n if original_cleaned_data is None:\n del self.form.cleaned_data\n else:\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors\n self.form.test_func = original_func",
"def _clean(self):\n return self._cleaned_data",
"def clean(self):\n pass",
"def validate(self, value, clean=True):\n pass"
] | [
"0.7071876",
"0.6890784",
"0.65769166",
"0.6466059",
"0.6421546",
"0.615222",
"0.61434525",
"0.611279",
"0.61122304",
"0.609748",
"0.60897005",
"0.60114133",
"0.5843924",
"0.58362514",
"0.58310366",
"0.5709201",
"0.56689227",
"0.5666174",
"0.5666049",
"0.5630638",
"0.562274",
"0.5599824",
"0.55990237",
"0.5596965",
"0.5575963",
"0.5553364",
"0.55486226",
"0.55405086",
"0.5534014",
"0.5511265"
] | 0.7312061 | 0 |
Test output of _clean_computed_fields. Should be an ErrorDict with computed field name(s) as key(s). | def test_validation_errors_assigned_in_clean_computed_fields(self):
name = 'test_field'
message = "This is the test error on test_field. "
response = ValidationError(message)
expected_compute_errors = ErrorDict({name: response}) # similar to return of _clean_computed_fields
original_func = deepcopy(self.form.test_func)
def make_error(value): raise response
self.form.test_func = make_error
if isinstance(self.form.computed_fields, (list, tuple)):
self.form.computed_fields = self.form.get_computed_fields([name])
self.form.cleaned_data = getattr(self.form, 'cleaned_data', {}) # mimic full_clean: cleaned_data is present
actual_compute_errors = self.form._clean_computed_fields()
self.assertDictEqual(expected_compute_errors, actual_compute_errors)
self.form.test_func = original_func | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_clean_moves_computed_fields_to_fields(self):\n name = 'test_field'\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n computed_names = list(self.form.computed_fields.keys())\n field_names = list(self.form.fields.keys())\n field_data = {f_name: f\"input_{f_name}_{i}\" for i, f_name in enumerate(field_names)}\n field_data.update({name: f\"value_{f_name}_{i}\" for i, f_name in enumerate(computed_names)})\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy() # mimic full_clean\n populated_cleaned_data = deepcopy(original_cleaned_data or {})\n populated_cleaned_data.update(field_data)\n self.form.cleaned_data = populated_cleaned_data.copy() # ensure cleaned_data is present (mimic full_clean)\n final_cleaned_data = self.form.clean()\n\n self.assertIn(name, computed_names)\n self.assertNotIn(name, field_names)\n self.assertEqual(1, len(computed_names))\n self.assertIn(name, self.form.fields)\n self.assertNotEqual(original_cleaned_data, final_cleaned_data)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def test_use_existing_computed_field_dict(self):\n if isinstance(self.form.computed_fields, list):\n self.form.computed_fields = self.form.get_computed_fields(self.form.computed_fields)\n self.form.fields.update(self.form.computed_fields) # only names in fields included in get_computed_field_names.\n result_names = self.form.get_computed_field_names([], self.form.fields)\n\n self.assertIsInstance(self.form.computed_fields, dict)\n self.assertIn('test_field', result_names)",
"def test_raise_on_corrupt_computed_fields(self):\n initial = self.form.computed_fields\n self.form.computed_fields = 'This is a broken value'\n with self.assertRaises(ImproperlyConfigured):\n self.form.get_computed_field_names([], self.form.fields)\n self.form.computed_fields = None\n with self.assertRaises(ImproperlyConfigured):\n self.form.get_computed_field_names([], self.form.fields)\n self.form.computed_fields = initial",
"def test_cleaned_data_modified_by_clean_computed_fields(self):\n name = 'test_field'\n field = self.form.computed_fields.get(name) # getattr(self.form, name) for BoundField instance for Field.\n value = self.form.compute_test_field()\n value = field.clean(value)\n expected = self.form.test_func(value)\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n original_errors = deepcopy(self.form._errors)\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n self.form.cleaned_data = getattr(self.form, 'cleaned_data', {}) # mimic full_clean: cleaned_data is present\n original = self.form.cleaned_data.get(name, None)\n compute_errors = self.form._clean_computed_fields()\n actual = self.form.cleaned_data.get(name, '')\n\n self.assertFalse(compute_errors)\n self.assertNotEqual(original, actual)\n self.assertNotEqual(original, expected)\n self.assertEqual(expected, actual)\n\n self.form._errors = original_errors",
"def test_validation_error_for_compute_error(self):\n name = 'test_field'\n message = \"This is the test error on test_field. \"\n response = ValidationError(message)\n original_errors = deepcopy(self.form._errors)\n expected_errors = ErrorDict() # similar to Form.full_clean\n expected_errors[name] = self.form.error_class()\n expected_errors[name].append(response) # similar to add_error(None, message) in _clean_computed...\n clean_message_on_compute_errors = \"Error occurred with the computed fields. \"\n clean_error_on_compute_errors = ValidationError(clean_message_on_compute_errors)\n expected_errors[NON_FIELD_ERRORS] = self.form.error_class(error_class='nonfield') # first add_error(None, err)\n expected_errors[NON_FIELD_ERRORS].append(clean_error_on_compute_errors) # similar to add_error(None, string)\n original_func = deepcopy(self.form.test_func)\n def make_error(value): raise response\n self.form.test_func = make_error\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.cleaned_data = getattr(self.form, 'cleaned_data', {}) # mimic full_clean: cleaned_data is present\n self.form._clean_form() # adds to Form._error if ValidationError raised by Form.clean.\n\n self.assertNotEqual(original_errors, self.form._errors)\n self.assertEqual(expected_errors, self.form._errors)\n\n if original_cleaned_data is None:\n del self.form.cleaned_data\n else:\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors\n self.form.test_func = original_func",
"def test_cleaned_data_for_compute_error(self):\n name = 'test_field'\n message = \"This is the test error on test_field. \"\n original_errors = deepcopy(self.form._errors)\n response = ValidationError(message)\n original_func = deepcopy(self.form.test_func)\n def make_error(value): raise response\n self.form.test_func = make_error\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n computed_names = list(self.form.computed_fields.keys())\n field_names = list(self.form.fields.keys())\n field_data = {f_name: f\"input_{f_name}_{i}\" for i, f_name in enumerate(field_names)}\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n original_cleaned_data = deepcopy(getattr(self.form, 'cleaned_data', None))\n populated_cleaned_data = deepcopy(original_cleaned_data or {})\n populated_cleaned_data.update(field_data)\n populated_cleaned_data.update({name: f\"value_{f_name}_{i}\" for i, f_name in enumerate(computed_names)})\n self.form.cleaned_data = populated_cleaned_data.copy() # ensure cleaned_data is present (mimic full_clean)\n\n with self.assertRaises(ValidationError):\n self.form.clean()\n final_cleaned_data = self.form.cleaned_data\n self.assertIn(name, computed_names)\n self.assertNotIn(name, field_names)\n self.assertIn(name, populated_cleaned_data)\n self.assertNotIn(name, final_cleaned_data)\n self.assertNotEqual(original_cleaned_data, final_cleaned_data)\n self.assertNotEqual(populated_cleaned_data, final_cleaned_data)\n\n if original_cleaned_data is None:\n del self.form.cleaned_data\n else:\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors\n self.form.test_func = original_func",
"def test_cleaned_data_for_compute_success(self):\n name = 'test_field'\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n computed_names = list(self.form.computed_fields.keys())\n field_names = list(self.form.fields.keys())\n field_data = {f_name: f\"input_{f_name}_{i}\" for i, f_name in enumerate(field_names)}\n field_data.update({name: f\"value_{f_name}_{i}\" for i, f_name in enumerate(computed_names)})\n original_errors = deepcopy(self.form._errors)\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n original_cleaned_data = deepcopy(getattr(self.form, 'cleaned_data', None))\n populated_cleaned_data = deepcopy(original_cleaned_data or {})\n populated_cleaned_data.update(field_data)\n self.form.cleaned_data = populated_cleaned_data.copy() # ensure cleaned_data is present (mimic full_clean)\n final_cleaned_data = self.form.clean()\n\n self.assertIn(name, computed_names)\n self.assertNotIn(name, field_names)\n self.assertIn(name, populated_cleaned_data)\n self.assertIn(name, final_cleaned_data)\n self.assertNotEqual(original_cleaned_data, final_cleaned_data)\n\n if original_cleaned_data is None:\n del self.form.cleaned_data\n else:\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors",
"def test_field_clean_method_called_in_clean_computed_fields(self):\n name = 'test_field'\n expected = 'clean_confirmed'\n original_func = deepcopy(self.form.test_func)\n def replace_value(value): return expected\n self.form.test_func = replace_value\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n field = self.form.computed_fields.get(name) # getattr(self.form, name)\n # initial_value = self.get_initial_for_field(field, name)\n value = getattr(self.form, 'compute_%s' % name)()\n value = field.clean(value)\n original_errors = deepcopy(self.form._errors)\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n cleaned_data = getattr(self.form, 'cleaned_data', {})\n cleaned_data.update({name: value}) # make sure the original cleaned_data for the field is set.\n self.form.cleaned_data = cleaned_data # ensure cleaned_data is present (mimic full_clean)\n compute_errors = self.form._clean_computed_fields()\n actual = self.form.cleaned_data.get(name, None)\n\n self.assertFalse(compute_errors)\n self.assertEqual(expected, actual)\n self.assertNotEqual(expected, value)\n self.assertNotEqual(expected, self.form.test_value)\n\n self.form.test_func = original_func\n self.form._errors = original_errors",
"def test_fields_updated_with_computed(self):\n pass",
"def test_field_compute_method_called_in_clean_computed_fields(self):\n name = 'test_field'\n expected = 'compute_confirmed'\n self.form.test_value = expected\n modified = self.form.test_func(expected)\n original_func = deepcopy(self.form.test_func)\n def pass_through(value): return value\n self.form.test_func = pass_through\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n original_errors = deepcopy(self.form._errors)\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n self.form.cleaned_data = getattr(self.form, 'cleaned_data', {}) # mimic full_clean: cleaned_data is present\n compute_errors = self.form._clean_computed_fields()\n actual = self.form.cleaned_data.get(name, None)\n\n self.assertFalse(compute_errors)\n self.assertEqual(expected, actual)\n\n self.form.test_func = original_func\n restored = self.form.test_func(expected)\n self.assertEqual(modified, restored)\n self.form._errors = original_errors",
"def test_clean_uses_computed(self):\n original_request = self.request\n original_form = self.form\n original_cleaned = getattr(self.form, 'cleaned_data', None)\n self.form = self.make_form_request()\n name = self.form.country_field_name\n initial = self.form.base_fields[name].initial\n cleaned = {'country_flag': True, name: initial}\n self.form.cleaned_data = cleaned\n\n self.assertNotIn(name, self.form.fields)\n self.assertIn(name, self.form.computed_fields)\n with self.assertRaisesMessage(ValidationError, \"You can input your address. \"):\n clean_flag = self.form.clean_country_flag()\n self.form.cleaned_data[name] = ''\n clean_flag = self.form.clean_country_flag()\n self.assertEqual(True, clean_flag)\n\n self.request = original_request\n self.form = original_form\n self.form.cleaned_data = original_cleaned\n if original_cleaned is None:\n del self.form.cleaned_data",
"def test_init_update_computed_field_names(self):\n original_request = self.request\n original_form = self.form\n computed = getattr(self.form, 'computed_fields', None)\n get_form = self.make_form_request()\n computed_fields = getattr(get_form, 'computed_fields', None)\n\n self.assertIsNotNone(computed)\n self.assertIsNotNone(computed_fields)\n self.assertIsNotNone(self.form.country_field_name)\n self.assertIn(self.form.country_field_name, computed_fields)\n\n self.request = original_request\n self.form = original_form",
"def test_clean_returns_cleaned_data(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n new_cleaned_data = {self.form.name_for_user: 'test_value', self.form.name_for_email: 'test_value'}\n new_cleaned_data[self.form.USERNAME_FLAG_FIELD] = False\n self.form.cleaned_data = new_cleaned_data.copy()\n expected_fields = {**original_fields, **original_computed_fields}\n\n cleaned_data = self.form.clean()\n self.assertDictEqual(new_cleaned_data, cleaned_data)\n self.assertDictEqual(expected_fields, self.form.fields)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def test_get_critical_from_existing_fields(self):\n name = 'generic_field'\n opts = {'names': (name, ), 'alt_field': '', 'computed': False}\n expected_field = self.form.fields.get(name, None)\n actual_name, actual_field = self.form.get_critical_field(opts['names'])\n self.assertEqual(name, actual_name)\n self.assertEqual(expected_field, actual_field)",
"def test_required_fields_X_normalization(self):\n\n del self.validator.adata.uns[\"X_normalization\"]\n self.validator.validate_adata()\n self.assertEqual(\n self.validator.errors, [\"ERROR: 'X_normalization' in 'uns' is not present.\"]\n )",
"def test_construct_values_raises_missing_cleaned_no_error(self):\n constructor_fields = ('first', 'second', 'last', )\n values = ['FirstValue', 'SecondValue', 'LastValue']\n cleaned_data = getattr(self.form, 'cleaned_data', {})\n cleaned_data.update(dict(zip(constructor_fields[:-1], values[:-1])))\n self.form.cleaned_data = cleaned_data\n err = \"This computed value can only be evaluated after fields it depends on have been cleaned. \"\n err += \"The field order must have the computed field after fields used for its value. \"\n with self.assertRaisesMessage(ImproperlyConfigured, err):\n self.form.construct_value_from_values(constructor_fields)",
"def test_mutate_field(self):\n # Test adding a field\n with self.assertRaises(ValueError):\n self.email.add_field('', '')\n\n self.email.add_field(self.key, self.regex)\n\n found_key = False\n found_regex = r''\n for field in self.email.fields:\n if field['key'] == self.key:\n found_key = True\n found_regex = field['regex']\n\n self.assertTrue(found_key)\n self.assertEqual(found_regex, self.regex)\n\n # Test getting a field\n with self.assertRaises(LookupError):\n self.email.get_field('')\n\n field = self.email.get_field(self.key)\n self.assertEqual(\n field, {'key': self.key, 'regex': self.regex, 'value': []})\n\n # Test removing a field\n with self.assertRaises(LookupError):\n self.email.remove_field('')\n\n self.email.remove_field(self.key)\n\n found_key = False\n found_regex = r''\n for field in self.email.fields:\n if field['key'] == self.key:\n found_key = True\n found_regex = field['regex']\n\n self.assertFalse(found_key)\n self.assertNotEqual(found_regex, self.regex)",
"def _post_clean(self):\r\n super(NgModelFormMixin, self)._post_clean()\r\n if self._errors and self.prefix:\r\n self._errors = ErrorDict((self.add_prefix(name), value) for name, value in self._errors.items())",
"def test_no_empty_sets_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n ('Non_Fields', {\n 'position': 2,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 2)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_no_empty_rows_in_computed_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_a_field',\n ('last_name', 'another_field', ),\n ('first_name', 'non-field_name', ),\n 'generic_field',\n 'last',\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: remaining_fields.pop(name) for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 3)\n self.assertEqual(len(fieldsets[1][1]['rows']), 4)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def test_init_get_critical_for_needed(self):\n # needed_names = [nf for nf in ('country_display', 'country_flag') if nf not in self.form.base_fields]\n # for name in needed_names: name, field = self.get_critical_field(name, name)\n # original_get_critical_field = self.form.get_critical_field\n # self.form.get_critical_field = self.get_critical_field_signal\n print(\"================ TEST INIT GET CRITICAL FOR NEEDED ==================\")\n print(self.form.get_critical_field.__name__)\n # print(getattr(self, 'get_critical_call', 'NOT FOUND'))\n # print(getattr(self.form, 'get_critical_call', 'NOT FOUND'))\n name = 'country_display'\n expected = {'names': name, 'alt_name': name}\n field = self.form.fields.get(name, None) or self.form.computed_fields(name, None)\n response = self.form.get_critical_field(name, name)\n actual = getattr(self, 'get_critical_call', 'NOT FOUND')\n print(\"----------------------------------------\")\n print(response)\n print(expected)\n print(actual)\n # self.assertDictEqual(expected, actual)\n self.assertEqual((name, field), response)\n\n # self.get_critical_field = original_get_critical_field",
"def test_get_fields_and_lookups_invalid_lookup(self):\n with self.assertRaises(exceptions.FieldError):\n utils.get_fields_and_lookups(Protected, 'protector__date__hour')",
"def test_to_python_method_validation_errors(self):\n field = DecimalFractionField()\n with self.assertRaises(ValidationError):\n field.clean(\"abcd\")\n\n with self.assertRaises(ValidationError):\n field.clean(\"1 1 1/3\")\n\n with self.assertRaises(ValidationError):\n field.clean(\"1 1\")",
"def test_set_non_dictionary_based_field(self):\n self.assertRaises(TypeError, self._p.set_fields, '')",
"def test_computed_fieldsets_structure(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n self.form.make_fieldsets()\n fieldsets = self.form._fieldsets\n each_are_tuples = (isinstance(ea, tuple) for ea in fieldsets)\n correct_fieldset_labels = (isinstance(label, (str, type(None))) for label, opts in fieldsets)\n opts_are_dictionaries = (isinstance(opts, dict) for label, opts in fieldsets)\n required_keys = {'position', 'fields', 'field_names', 'rows', 'column_count', }\n optional_keys = {'classes', 'modifiers', 'row_data', }\n allowed_keys = required_keys | optional_keys\n opt_keys = set(flatten([list(opts.keys()) for lbl, opts, in fieldsets]))\n unaccepted_keys = [key for key in opt_keys if key not in allowed_keys]\n has_required = (all(key in opts for key in required_keys) for lbl, opts in fieldsets)\n self.assertIsInstance(fieldsets, list)\n self.assertTrue(all(each_are_tuples))\n self.assertTrue(all(correct_fieldset_labels))\n self.assertTrue(all(opts_are_dictionaries))\n self.assertEqual(len(unaccepted_keys), 0)\n self.assertFalse(unaccepted_keys)\n self.assertTrue(all(has_required))\n\n self.form.fieldsets = original_fieldsets",
"def test_col_data_errors(self):\n help_tag = 'span'\n help_text_br = False\n label_attrs = {}\n names = ('first', 'billing_address_1')\n name = names[0]\n errors = ErrorDict()\n message = \"This is the test error message\"\n err = ValidationError(message)\n errors[name] = self.form.error_class()\n errors[name].extend(err.error_list)\n expected = [errors[name], self.form.error_class()]\n original_errors = self.form._errors\n self.form._errors = errors\n actual = []\n for name in names:\n field = self.form.fields[name]\n response = self.form.collect_col_data(name, field, help_tag, help_text_br, label_attrs)\n actual.append(response.get('errors'))\n\n for expect, got in zip(expected, actual):\n self.assertEqual(expect, got)\n\n self.form._errors = original_errors",
"def check_returnable_fields(fields, result):\n returnable_fields = get_returnable_fields(result, verbose=False)\n for field in fields:\n if field not in returnable_fields:\n err_str = \"The field %s is not a returnable field for \" % (field)\n err_str += \"result %s\" % (result)\n raise ValueError(err_str)",
"def test_clean_dependent_fields(self):\n data = self.report_data.copy()\n new_primary_complaint = 'housing'\n data.update({'primary_complaint': new_primary_complaint})\n form = ReportEditForm(data, instance=self.report)\n\n self.assertTrue(form.is_valid())\n self.assertTrue('public_or_private_employer' in form.changed_data)\n self.assertTrue('employer_size' not in form.changed_data)\n for field in Report.PRIMARY_COMPLAINT_DEPENDENT_FIELDS['workplace']:\n self.assertTrue(form.cleaned_data[field] == \"\")",
"def test_prep_field_properties(self):\n original_data = self.form.data\n test_data = original_data.copy()\n # modify values in data\n test_data._mutable = False\n self.form.data = test_data\n original_fields = self.form.fields\n test_fields = original_fields.copy()\n # modify fields\n self.form.fields = test_fields\n test_fields_info = {name: field.__dict__.copy() for name, field in test_fields.items()}\n original_get_overrides = self.form.get_overrides\n def skip_overrides(): return {}\n self.form.get_overrides = skip_overrides\n original_alt_field_info = getattr(self.form, 'alt_field_info', None)\n self.form.alt_field_info = self.alt_field_info\n self.form.test_condition_response = True\n expected_fields_info = test_fields_info.copy()\n result_fields = self.form.prep_fields()\n result_fields_info = {name: field.__dict__.copy() for name, field in result_fields.items()}\n modified_info = self.alt_field_info['alt_test_feature']\n first_label = modified_info['first']['label']\n first_initial = modified_info['first']['initial']\n last_initial = modified_info['last']['initial']\n for name, opts in modified_info.items():\n expected_fields_info[name].update(opts)\n\n self.assertEqual(first_label, result_fields['first'].label)\n self.assertEqual(first_initial, result_fields['first'].initial)\n self.assertEqual(last_initial, result_fields['last'].initial)\n for key, val in expected_fields_info.items():\n self.assertEqual(val, result_fields_info[key])\n self.assertDictEqual(expected_fields_info, result_fields_info)\n\n self.form.test_condition_response = False\n self.form.alt_field_info = original_alt_field_info\n if original_alt_field_info is None:\n del self.form.alt_field_info\n self.form.fields = original_fields\n self.form.data = original_data\n self.form.get_overrides = original_get_overrides",
"def clean_form_with_field_errors(original_function, self):\n \n from django.core.exceptions import ValidationError\n try:\n self.cleaned_data = self.clean()\n except ValidationError, e:\n if hasattr(e, 'message_dict'):\n for field, error_strings in e.message_dict.items():\n self._errors[field] = self.error_class(error_strings)\n else:\n self._errors[NON_FIELD_ERRORS] = self.error_class(e.messages)"
] | [
"0.75391686",
"0.7532654",
"0.74328333",
"0.7366892",
"0.7289861",
"0.71061695",
"0.6932349",
"0.6904049",
"0.6860833",
"0.6812228",
"0.6632736",
"0.6465598",
"0.6200135",
"0.59107816",
"0.5845936",
"0.57832646",
"0.5644898",
"0.55574524",
"0.5552219",
"0.55437005",
"0.54993755",
"0.5474246",
"0.54346144",
"0.5431579",
"0.54232955",
"0.53999484",
"0.5384411",
"0.5375398",
"0.53204757",
"0.5311414"
] | 0.8140627 | 0 |
Raises ImproperlyConfigured if set_alt_data get both collection and single data input. | def test_raises_set_alt_data(self):
name, value = 'generic_field', 'alt_data_value'
field = self.form.fields.get(name, None)
self.assertIsNotNone(field, "Unable to find the expected field in current fields. ")
data = {name: (field, value)}
with self.assertRaises(ImproperlyConfigured):
self.form.set_alt_data(data=data, name=name, field=field, value=value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_set_alt_data_collection(self):\n names = list(self.test_data.keys())[1:-1]\n alt_values = {name: f\"alt_value_{name}\" for name in self.test_initial} # some, but not all, will be used.\n original_form_data = self.form.data\n test_data = self.test_data.copy()\n test_data.update({k: v for k, v in self.test_initial.items() if get_html_name(self.form, k) not in names})\n test_data._mutable = False\n self.form.data = test_data\n initial_data = test_data.copy()\n expected_result = {k: v for k, v in alt_values.items() if get_html_name(self.form, k) not in names}\n expected_data = test_data.copy()\n expected_data.update(expected_result)\n expect_updates = any(self.data_is_initial(name) for name in initial_data)\n test_input = {name: (self.form.fields[name], val) for name, val in alt_values.items()}\n result = self.form.set_alt_data(test_input)\n\n self.assertDictEqual(expected_result, result)\n self.assertDictEqual(expected_data, self.form.data)\n self.assertNotEqual(initial_data, self.form.data)\n self.assertTrue(expect_updates)\n self.assertIsNot(test_data, self.form.data)\n\n self.form.data = original_form_data",
"def test_set_alt_data_single(self):\n name, value = 'generic_field', 'alt_data_value'\n field = self.form.fields.get(name, None)\n self.assertIsNotNone(field, \"Unable to find the expected field in current fields. \")\n original_form_data = self.form.data\n test_data = self.test_data.copy()\n test_data.update({name: self.test_initial[name]})\n test_data._mutable = False\n self.form.data = test_data\n initial_data = test_data.copy()\n expected_data = test_data.copy()\n expected_data.update({name: value})\n initial_val = self.form.get_initial_for_field(field, name)\n html_name = self.form.add_prefix(name)\n data_val = field.widget.value_from_datadict(self.form.data, self.form.files, html_name)\n use_alt_value = not field.has_changed(initial_val, data_val)\n expected_value = value if use_alt_value else initial_data.get(name)\n expected_result = {name: value} if use_alt_value else {}\n result = self.form.set_alt_data(data=None, name=name, field=field, value=value)\n\n self.assertEqual(self.test_initial[name], initial_val)\n self.assertEqual(initial_data[name], data_val)\n self.assertEqual(expected_value, self.form.data[html_name])\n self.assertEqual(expected_value, field.initial)\n self.assertDictEqual(expected_result, result)\n for key in initial_data:\n self.assertEqual(expected_data[key], self.form.data[key])\n self.assertEqual(len(expected_data), len(self.form.data))\n self.assertTrue(use_alt_value)\n\n self.form.data = original_form_data",
"def test_set_alt_data_unchanged(self):\n original_form_data = self.form.data\n test_data = self.test_data.copy()\n test_data._mutable = False\n self.form.data = test_data\n initial_data = test_data.copy()\n alt_values = {name: f\"alt_value_{name}\" for name in self.test_initial}\n test_input = {name: (self.form.fields[name], val) for name, val in alt_values.items()}\n expect_updates = any(self.data_is_initial(name) for name in initial_data)\n result = self.form.set_alt_data(test_input)\n had_updates = any(self.form.data[name] != value for name, value in initial_data.items())\n\n self.assertFalse(expect_updates)\n self.assertFalse(had_updates)\n self.assertDictEqual({}, result)\n self.assertDictEqual(initial_data, self.form.data)\n self.assertIs(test_data, self.form.data)\n\n self.form.data = original_form_data",
"def test_set_alt_data_mutable(self):\n original_test_initial = self.test_initial\n original_form_data = self.form.data\n initial = self.test_initial\n test_data = self.test_data.copy()\n test_data.update({name: initial[name] for name in list(initial.keys())[1:-1]}) # two fields for alt_values\n test_data._mutable = False\n self.form.data = test_data\n initial_data = test_data.copy()\n alt_values = {name: f\"alt_value_{name}\" for name in initial} # some, but not all, will be used.\n unchanged_fields = {name: val for name, val in test_data.items() if val == initial[name]}\n expected_result = {name: alt_values[name] for name in unchanged_fields}\n expected_data = test_data.copy()\n expected_data.update(expected_result)\n expect_updates = any(self.data_is_initial(name) for name in initial_data)\n test_input = {name: (self.form.fields[name], val) for name, val in alt_values.items()}\n result = self.form.set_alt_data(test_input)\n had_updates = any(value != self.form.data[name] for name, value in initial_data.items())\n\n for name, val in expected_data.items():\n self.assertEqual(val, self.form.data[name])\n self.assertTrue(expect_updates)\n self.assertTrue(had_updates)\n self.assertFalse(getattr(self.form.data, '_mutable', True))\n self.assertDictEqual(expected_result, result)\n self.assertDictEqual(expected_data, self.form.data)\n\n self.form.data = original_form_data\n self.test_initial = original_test_initial",
"def f_set(self, data):\n raise NotImplementedError(\"Should have implemented this.\")",
"def test_set_use_collection_return(self) -> None:\n\n given = True\n\n actual = self.checker.set_use_collection(given)\n\n self.assertIsInstance(actual, CheckerBase)",
"def SetGeData(self, *args, **kwargs):\n pass",
"def test_set_use_collection_method(self) -> None:\n\n given = False\n expected = False\n\n self.checker.set_use_collection(given)\n\n actual = self.checker.use_collection\n\n self.assertEqual(expected, actual)",
"def populated_collection(self, empty_collection, plain_collection):\n raise NotImplementedError",
"def test_guess_and_set_use_collection_no_configuration(self) -> None:\n\n self.checker.guess_and_set_use_collection()\n actual = self.checker.use_collection\n expected = False\n\n self.assertEqual(expected, actual)",
"def __init__(self, collection, json_data = None):\n\n super(Entity, self).__init__(json_data)\n self.collection = collection\n self.return_error_code = True",
"def test_guess_and_set_use_collection(self) -> None:\n\n config_loader = ConfigLoader()\n config_loader.set_custom_config({\"lookup\": {\"collection\": True}}).start()\n\n self.checker.guess_and_set_use_collection()\n actual = self.checker.use_collection\n expected = True\n\n self.assertEqual(expected, actual)",
"def get_initial(self):\n\t\n\t#Getting the initial data and setting it\n initial = super(UpdateView, self).get_initial()\n\timage_ref = default_value.get_setting('compute', 'image_ref') \n flavor_ref = default_value.get_setting('compute', 'flavor_ref')\n initial.update({'test_id': self.kwargs['test_id'], 'image_ref': image_ref, 'flavor_ref': flavor_ref})\n return initial",
"def _process_data(self):\n assert not hasattr(self, 'changes'), '_process_data called twice.'\n assert hasattr(self, 'errors'), (\n '_process_data not called by is_valid().')\n r_by_t = Collection.resource_by_type\n\n # Create and load collection of new data\n new_collection = Collection()\n for rtype, items in self.data.items():\n resource_cls = r_by_t.get(rtype)\n if resource_cls:\n for seq, json_api_item in enumerate(items):\n item = json_api_item.copy()\n links = item.pop('links', {})\n item.update(links)\n resource = self.load_resource(resource_cls, item)\n resource._seq = seq\n new_collection.add(resource)\n\n # Create native representation of current feature data\n current_collection = Collection(DjangoResourceClient())\n feature_serializer = ViewFeatureSerializer(context=self.context)\n current_feature = feature_serializer.to_representation(self.feature)\n current_extra = current_feature.pop('_view_extra')\n del current_extra['meta']\n\n # Load feature into new and current collection\n current_feature_resource = self.load_resource(\n r_by_t['features'], current_feature)\n current_collection.add(current_feature_resource)\n current_feature.update(self.feature._in_extra)\n current_feature['id'] = str(current_feature['id'])\n resource_feature = self.load_resource(\n r_by_t['features'], current_feature)\n resource_feature._seq = None\n new_collection.add(resource_feature)\n\n # Populate collection of current data\n for rtype, items in current_extra.items():\n resource_cls = r_by_t[rtype]\n for item in items:\n resource = self.load_resource(resource_cls, item)\n current_collection.add(resource)\n\n # Add existing items not explicit in PUT content\n # This avoids 'delete' changes\n new_items = new_collection.get_all_by_data_id()\n for data_id, item in current_collection.get_all_by_data_id().items():\n if data_id not in new_items:\n rtype = item._resource_type\n resource = r_by_t[rtype]()\n json_api_rep = item.to_json_api()\n json_api_rep[rtype]['id'] = item.id.id\n resource.from_json_api(json_api_rep)\n resource._seq = None\n new_collection.add(resource)\n\n # Add existing items used in new collection to current collection\n # This avoids incorrect 'new' changes\n existing_items = current_collection.get_all_by_data_id()\n for data_id, item in new_collection.get_all_by_data_id().items():\n if item.id:\n item_id = item.id.id\n int_id = None\n existing_item = existing_items.get(data_id)\n try:\n int_id = int(item_id)\n except ValueError:\n pass\n if int_id and (existing_item is None):\n rtype = item._resource_type\n resource_cls = r_by_t[rtype]\n model_cls, serializer_cls = view_cls_by_name[rtype]\n obj = model_cls.objects.get(id=int_id)\n serializer = serializer_cls()\n data = serializer.to_representation(obj)\n resource = self.load_resource(resource_cls, data)\n current_collection.add(resource)\n\n # Load the diff\n self.changeset = CollectionChangeset(\n current_collection, new_collection)\n assert not self.changeset.changes.get('deleted'), (\n 'Existing items were not added, so deletions found:\\n%s'\n % self.changes['deleted'])",
"def set_data(self, data):\n\n pass",
"def test_patch_collection(self):\n pass",
"def update_original_data(self):\n pass",
"def __init__(self, json_data=None):\r\n super(NSPatset, self).__init__()\r\n self.options = {'name': '',\r\n 'comment': '',\r\n 'indextype': '',\r\n\t 'description': '',\r\n '__count': ''}\r\n \r\n self.resourcetype = NSPatset.get_resourcetype()\r\n \r\n if not (json_data is None):\r\n for key in json_data.keys():\r\n if key in self.options.keys():\r\n self.options[key] = json_data[key]",
"def _set_data(self, new_data):\n for name, field in self._get_fields().items():\n if name in new_data:\n try:\n setattr(self, f\"__{name}\", field.from_raw(new_data[name]))\n except (fields.ValidationError, ValueError):\n # should at least log validation and value errors\n # this can happen in case of e.g. fields type change\n pass",
"def _original_data(self, data: np.ndarray):\n if self._raw_data is None:\n self._raw_data = data",
"def test_set_use_collection_not_bool(self) -> None:\n\n given = [\"Hello\", \"World!\"]\n\n self.assertRaises(TypeError, lambda: self.checker.set_use_collection(given))",
"def bound_data_with_bug_19611_patch(original_function, self, data, initial):\n return initial",
"def test_dataloader_kwargs_replacement_with_iterable_dataset(mode):\n dataset = RandomIterableDataset(7, 100)\n dataloader = DataLoader(dataset, batch_size=32)\n dl_kwargs = _get_dataloader_init_kwargs(dataloader, dataloader.sampler, mode=mode)\n assert dl_kwargs[\"sampler\"] is None\n assert dl_kwargs[\"batch_sampler\"] is None\n assert dl_kwargs[\"batch_size\"] is dataloader.batch_size\n assert dl_kwargs[\"dataset\"] is dataloader.dataset\n assert dl_kwargs[\"collate_fn\"] is dataloader.collate_fn",
"def populated_collection(self, empty_collection, plain_collection):\n empty_collection.update(plain_collection)\n return empty_collection, plain_collection",
"def data_details_return(data, data_set):\r\n data.update(data_resources[data_set])\r\n return data",
"def expand_meta_parameters( trans, tool, incoming ):\n\n def classifier( input_key ):\n multirun_key = \"%s|__multirun__\" % input_key\n if multirun_key in incoming:\n multi_value = util.listify( incoming[ multirun_key ] )\n if len( multi_value ) > 1:\n return permutations.input_classification.MATCHED, multi_value\n else:\n if len( multi_value ) == 0:\n multi_value = None\n return permutations.input_classification.SINGLE, multi_value[ 0 ]\n else:\n return permutations.input_classification.SINGLE, incoming[ input_key ]\n\n from galaxy.dataset_collections import matching\n collections_to_match = matching.CollectionsToMatch()\n\n def collection_classifier( input_key ):\n multirun_key = \"%s|__collection_multirun__\" % input_key\n if multirun_key in incoming:\n incoming_val = incoming[ multirun_key ]\n # If subcollectin multirun of data_collection param - value will\n # be \"hdca_id|subcollection_type\" else it will just be hdca_id\n if \"|\" in incoming_val:\n encoded_hdc_id, subcollection_type = incoming_val.split( \"|\", 1 )\n else:\n try:\n src = incoming_val[ \"src\" ]\n if src != \"hdca\":\n raise exceptions.ToolMetaParameterException( \"Invalid dataset collection source type %s\" % src )\n encoded_hdc_id = incoming_val[ \"id\" ]\n except TypeError:\n encoded_hdc_id = incoming_val\n subcollection_type = None\n hdc_id = trans.app.security.decode_id( encoded_hdc_id )\n hdc = trans.sa_session.query( model.HistoryDatasetCollectionAssociation ).get( hdc_id )\n collections_to_match.add( input_key, hdc, subcollection_type=subcollection_type )\n if subcollection_type is not None:\n from galaxy.dataset_collections import subcollections\n subcollection_elements = subcollections.split_dataset_collection_instance( hdc, subcollection_type )\n return permutations.input_classification.MATCHED, subcollection_elements\n else:\n hdas = hdc.collection.dataset_instances\n return permutations.input_classification.MATCHED, hdas\n else:\n return permutations.input_classification.SINGLE, incoming[ input_key ]\n\n # Stick an unexpanded version of multirun keys so they can be replaced,\n # by expand_mult_inputs.\n incoming_template = incoming.copy()\n\n # Will reuse this in subsequent work, so design this way now...\n def try_replace_key( key, suffix ):\n found = key.endswith( suffix )\n if found:\n simple_key = key[ 0:-len( suffix ) ]\n if simple_key not in incoming_template:\n incoming_template[ simple_key ] = None\n return found\n\n multirun_found = False\n collection_multirun_found = False\n for key, value in incoming.iteritems():\n multirun_found = try_replace_key( key, \"|__multirun__\" ) or multirun_found\n collection_multirun_found = try_replace_key( key, \"|__collection_multirun__\" ) or collection_multirun_found\n\n if sum( [ 1 if f else 0 for f in [ multirun_found, collection_multirun_found ] ] ) > 1:\n # In theory doable, but to complicated for a first pass.\n message = \"Cannot specify parallel execution across both multiple datasets and dataset collections.\"\n raise exceptions.ToolMetaParameterException( message )\n\n if multirun_found:\n return permutations.expand_multi_inputs( incoming_template, classifier ), None\n else:\n expanded_incomings = permutations.expand_multi_inputs( incoming_template, collection_classifier )\n if collections_to_match.has_collections():\n collection_info = trans.app.dataset_collections_service.match_collections( collections_to_match )\n else:\n collection_info = None\n return expanded_incomings, collection_info",
"def _init_data(self, data):\n assert type(data) is dict, \"dict expected: %r\" % type(data)\n assert len(data) is 1, \"size of dict should be 1: %r\" % len(data)\n self._name = data.keys()[0]\n self._data = np.asarray(data[self._name])\n self._set = True",
"def update(self, data: Union[QueryWithResponse, List[QueryWithResponse]], initial_point: Dict = None):\n if isinstance(data, list):\n self.dataset.extend(data)\n else:\n self.dataset.append(data)\n if initial_point is None:\n initial_point = self.mean\n \n self.create_samples(initial_point)",
"def _unify_data_and_user_kwargs(\n data: LayerData,\n kwargs: Optional[dict] = None,\n layer_type: Optional[str] = None,\n fallback_name: str = None,\n) -> FullLayerData:\n _data, _meta, _type = _normalize_layer_data(data)\n\n if layer_type:\n # the user has explicitly requested this be a certain layer type\n # strip any kwargs from the plugin that are no longer relevant\n _meta = prune_kwargs(_meta, layer_type)\n _type = layer_type\n\n if kwargs:\n # if user provided kwargs, use to override any meta dict values that\n # were returned by the plugin. We only prune kwargs if the user did\n # *not* specify the layer_type. This means that if a user specified\n # both layer_type and additional keyword arguments to viewer.open(),\n # it is their responsibility to make sure the kwargs match the\n # layer_type.\n _meta.update(prune_kwargs(kwargs, _type) if not layer_type else kwargs)\n\n if not _meta.get('name') and fallback_name:\n _meta['name'] = fallback_name\n return (_data, _meta, _type)",
"def set_additionaldata_extractor(self, extractor):\r\n if not extractor:\r\n raise ValueError(\"extractor must not be null!\")\r\n self.additional_data_extractor = extractor"
] | [
"0.6740895",
"0.63110775",
"0.58376265",
"0.5787795",
"0.5517237",
"0.53976166",
"0.5333317",
"0.53206915",
"0.5248739",
"0.52395374",
"0.51345104",
"0.5132322",
"0.5106686",
"0.50934315",
"0.50909173",
"0.50712544",
"0.5013002",
"0.50040066",
"0.5002275",
"0.49812916",
"0.49588555",
"0.4936051",
"0.49263647",
"0.49003488",
"0.48893994",
"0.48714805",
"0.48658678",
"0.48617402",
"0.48574966",
"0.48459426"
] | 0.6730341 | 1 |
After running set_alt_data that triggers changes, the Form's data attribute should have _mutable = False. | def test_set_alt_data_mutable(self):
original_test_initial = self.test_initial
original_form_data = self.form.data
initial = self.test_initial
test_data = self.test_data.copy()
test_data.update({name: initial[name] for name in list(initial.keys())[1:-1]}) # two fields for alt_values
test_data._mutable = False
self.form.data = test_data
initial_data = test_data.copy()
alt_values = {name: f"alt_value_{name}" for name in initial} # some, but not all, will be used.
unchanged_fields = {name: val for name, val in test_data.items() if val == initial[name]}
expected_result = {name: alt_values[name] for name in unchanged_fields}
expected_data = test_data.copy()
expected_data.update(expected_result)
expect_updates = any(self.data_is_initial(name) for name in initial_data)
test_input = {name: (self.form.fields[name], val) for name, val in alt_values.items()}
result = self.form.set_alt_data(test_input)
had_updates = any(value != self.form.data[name] for name, value in initial_data.items())
for name, val in expected_data.items():
self.assertEqual(val, self.form.data[name])
self.assertTrue(expect_updates)
self.assertTrue(had_updates)
self.assertFalse(getattr(self.form.data, '_mutable', True))
self.assertDictEqual(expected_result, result)
self.assertDictEqual(expected_data, self.form.data)
self.form.data = original_form_data
self.test_initial = original_test_initial | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_set_alt_data_unchanged(self):\n original_form_data = self.form.data\n test_data = self.test_data.copy()\n test_data._mutable = False\n self.form.data = test_data\n initial_data = test_data.copy()\n alt_values = {name: f\"alt_value_{name}\" for name in self.test_initial}\n test_input = {name: (self.form.fields[name], val) for name, val in alt_values.items()}\n expect_updates = any(self.data_is_initial(name) for name in initial_data)\n result = self.form.set_alt_data(test_input)\n had_updates = any(self.form.data[name] != value for name, value in initial_data.items())\n\n self.assertFalse(expect_updates)\n self.assertFalse(had_updates)\n self.assertDictEqual({}, result)\n self.assertDictEqual(initial_data, self.form.data)\n self.assertIs(test_data, self.form.data)\n\n self.form.data = original_form_data",
"def test_set_alt_data_collection(self):\n names = list(self.test_data.keys())[1:-1]\n alt_values = {name: f\"alt_value_{name}\" for name in self.test_initial} # some, but not all, will be used.\n original_form_data = self.form.data\n test_data = self.test_data.copy()\n test_data.update({k: v for k, v in self.test_initial.items() if get_html_name(self.form, k) not in names})\n test_data._mutable = False\n self.form.data = test_data\n initial_data = test_data.copy()\n expected_result = {k: v for k, v in alt_values.items() if get_html_name(self.form, k) not in names}\n expected_data = test_data.copy()\n expected_data.update(expected_result)\n expect_updates = any(self.data_is_initial(name) for name in initial_data)\n test_input = {name: (self.form.fields[name], val) for name, val in alt_values.items()}\n result = self.form.set_alt_data(test_input)\n\n self.assertDictEqual(expected_result, result)\n self.assertDictEqual(expected_data, self.form.data)\n self.assertNotEqual(initial_data, self.form.data)\n self.assertTrue(expect_updates)\n self.assertIsNot(test_data, self.form.data)\n\n self.form.data = original_form_data",
"def update_original_data(self):\n pass",
"def test_set_alt_data_single(self):\n name, value = 'generic_field', 'alt_data_value'\n field = self.form.fields.get(name, None)\n self.assertIsNotNone(field, \"Unable to find the expected field in current fields. \")\n original_form_data = self.form.data\n test_data = self.test_data.copy()\n test_data.update({name: self.test_initial[name]})\n test_data._mutable = False\n self.form.data = test_data\n initial_data = test_data.copy()\n expected_data = test_data.copy()\n expected_data.update({name: value})\n initial_val = self.form.get_initial_for_field(field, name)\n html_name = self.form.add_prefix(name)\n data_val = field.widget.value_from_datadict(self.form.data, self.form.files, html_name)\n use_alt_value = not field.has_changed(initial_val, data_val)\n expected_value = value if use_alt_value else initial_data.get(name)\n expected_result = {name: value} if use_alt_value else {}\n result = self.form.set_alt_data(data=None, name=name, field=field, value=value)\n\n self.assertEqual(self.test_initial[name], initial_val)\n self.assertEqual(initial_data[name], data_val)\n self.assertEqual(expected_value, self.form.data[html_name])\n self.assertEqual(expected_value, field.initial)\n self.assertDictEqual(expected_result, result)\n for key in initial_data:\n self.assertEqual(expected_data[key], self.form.data[key])\n self.assertEqual(len(expected_data), len(self.form.data))\n self.assertTrue(use_alt_value)\n\n self.form.data = original_form_data",
"def set_immutable(self):\n self._mutable = False",
"def test_prep_field_properties(self):\n original_data = self.form.data\n test_data = original_data.copy()\n # modify values in data\n test_data._mutable = False\n self.form.data = test_data\n original_fields = self.form.fields\n test_fields = original_fields.copy()\n # modify fields\n self.form.fields = test_fields\n test_fields_info = {name: field.__dict__.copy() for name, field in test_fields.items()}\n original_get_overrides = self.form.get_overrides\n def skip_overrides(): return {}\n self.form.get_overrides = skip_overrides\n original_alt_field_info = getattr(self.form, 'alt_field_info', None)\n self.form.alt_field_info = self.alt_field_info\n self.form.test_condition_response = True\n expected_fields_info = test_fields_info.copy()\n result_fields = self.form.prep_fields()\n result_fields_info = {name: field.__dict__.copy() for name, field in result_fields.items()}\n modified_info = self.alt_field_info['alt_test_feature']\n first_label = modified_info['first']['label']\n first_initial = modified_info['first']['initial']\n last_initial = modified_info['last']['initial']\n for name, opts in modified_info.items():\n expected_fields_info[name].update(opts)\n\n self.assertEqual(first_label, result_fields['first'].label)\n self.assertEqual(first_initial, result_fields['first'].initial)\n self.assertEqual(last_initial, result_fields['last'].initial)\n for key, val in expected_fields_info.items():\n self.assertEqual(val, result_fields_info[key])\n self.assertDictEqual(expected_fields_info, result_fields_info)\n\n self.form.test_condition_response = False\n self.form.alt_field_info = original_alt_field_info\n if original_alt_field_info is None:\n del self.form.alt_field_info\n self.form.fields = original_fields\n self.form.data = original_data\n self.form.get_overrides = original_get_overrides",
"def test_no_error_handle_flag_field(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n new_cleaned_data = {self.form.name_for_user: 'test_value', self.form.name_for_email: 'test_value'}\n new_cleaned_data[self.form.USERNAME_FLAG_FIELD] = True # False\n user_field = self.form.computed_fields.pop(self.form.name_for_user, None)\n self.form.fields.update({self.form.name_for_user: user_field})\n email_field = self.form.fields[self.form.name_for_email]\n email_field.initial = new_cleaned_data[self.form.name_for_email]\n self.form.cleaned_data = new_cleaned_data.copy()\n expected = {}\n actual = self.form.handle_flag_field(self.form.name_for_email, self.form.name_for_user)\n\n self.assertIsNotNone(user_field)\n self.assertFalse(email_field.has_changed(email_field.initial, self.form.cleaned_data[self.form.name_for_email]))\n self.assertEqual(expected, actual)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def data_changed(self):\n return",
"def update_data(self):\n # Just set data_changed, the component should do the rest.\n self.data_changed = True",
"def _clean(self):\n self.cleaned_data = super().clean()\n # Use bound data to set the value if we both have bound and initial data.\n if self.is_bound and self.initial:\n self._set_and_validate_data(self.data)\n return\n else:\n # Set values according to bound data\n if self.is_bound:\n self._set_and_validate_data(self.data)\n return\n # Set values according to initial data\n if self.initial:\n self._set_and_validate_data(self.initial)\n return",
"def test_handle_removals_add_if_named_in_data(self):\n original_data = self.form.data\n original_fields = self.form.fields\n fields = original_fields.copy()\n remove_names = ['second', 'last']\n self.form.removed_fields = {name: fields.pop(name) for name in remove_names if name in fields}\n self.form.remove_field_names = []\n expected_fields = dict(**fields, **self.form.removed_fields)\n test_data = original_data.copy()\n test_data.update({name: f\"value_{name}\" for name in remove_names})\n test_data._mutable = False\n self.form.data = test_data\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result))\n self.assertEqual(0, len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(expected_fields, result)\n self.assertDictEqual(original_fields, result)\n self.assertIs(fields, result)\n\n self.data = original_data",
"def _setAllWithoutUpdate(self, data):\n super(SummonerModel, self)._setAllWithoutUpdate(data)",
"def setData(self,newData):\r\n pass",
"def test_prep_overrides(self):\n original_data = self.form.data\n test_data = original_data.copy()\n test_data._mutable = False\n self.form.data = test_data # copied only to allow tear-down reverting to original.\n original_fields = self.form.fields\n test_fields = original_fields.copy()\n self.form.fields = test_fields # copied to allow tear-down reverting to original.\n original_get_overrides = self.form.get_overrides\n def replace_overrides(): return self.formfield_attrs_overrides\n self.form.get_overrides = replace_overrides\n original_alt_field_info = getattr(self.form, 'alt_field_info', None)\n self.form.alt_field_info = {}\n overrides = self.formfield_attrs_overrides.copy()\n DEFAULT = overrides.pop('_default_')\n expected_attrs = {}\n for name, field in test_fields.items():\n attrs = field.widget.attrs.copy()\n if isinstance(field.widget, (RadioSelect, CheckboxSelectMultiple, CheckboxInput, )):\n pass # update if similar section in prep_fields is updated.\n attrs.update(overrides.get(name, {}))\n # TODO: setup structure for using default or defined version for all CharFields.\n no_resize = overrides.get(name, {}).pop('no_size_override', False)\n no_resize = True if isinstance(field.widget, (HiddenInput, MultipleHiddenInput)) else no_resize\n if no_resize:\n expected_attrs[name] = attrs\n continue # None of the following size overrides are applied for this field.\n if isinstance(field.widget, Textarea):\n width_attr_name = 'cols'\n default = DEFAULT.get('cols', None)\n display_size = attrs.get('cols', None)\n if 'rows' in DEFAULT:\n height = attrs.get('rows', None)\n height = min((DEFAULT['rows'], int(height))) if height else DEFAULT['rows']\n attrs['rows'] = str(height)\n if default: # For textarea, we always override. The others depend on different conditions.\n display_size = display_size or default\n display_size = min((int(display_size), int(default)))\n elif issubclass(field.__class__, CharField):\n width_attr_name = 'size' # 'size' is only valid for input types: email, password, tel, text\n default = DEFAULT.get('size', None) # Cannot use float(\"inf\") as an int.\n display_size = attrs.get('size', None)\n else: # This field does not have a size setting.\n width_attr_name, default, display_size = None, None, None\n input_size = attrs.get('maxlength', None)\n possible_size = [int(ea) for ea in (display_size or default, input_size) if ea]\n # attrs['size'] = str(int(min(float(display_size), float(input_size)))) # Can't use float(\"inf\") as an int.\n if possible_size and width_attr_name:\n attrs[width_attr_name] = str(min(possible_size))\n expected_attrs[name] = attrs\n # Expected:\n # formfield_attrs_overrides = {\n # '_default_': {'size': 15, 'cols': 20, 'rows': 4, },\n # 'first': {'maxlength': 191, 'size': 20, },\n # 'second': {'maxlength': 2, }, # 'size': 2,\n # 'last': {'maxlength': 2, 'size': 5, },\n # }\n result_fields = self.form.prep_fields()\n result_attrs = {name: field.widget.attrs.copy() for name, field in result_fields.items()}\n first_maxlength = expected_attrs['first']['maxlength'] # overrides['first']['maxlength']\n first_size = expected_attrs['first']['size'] # overrides['first']['size']\n second_maxlength = expected_attrs['second']['maxlength'] # overrides['second']['maxlength']\n last_maxlength = expected_attrs['last']['maxlength'] # overrides['last']['maxlength']\n last_size = expected_attrs['last']['size'] # overrides['last']['size']\n\n self.assertEqual(first_maxlength, result_fields['first'].widget.attrs.get('maxlength', None))\n self.assertEqual(first_size, result_fields['first'].widget.attrs.get('size', None))\n self.assertEqual(second_maxlength, result_fields['second'].widget.attrs.get('maxlength', None))\n self.assertEqual(last_maxlength, result_fields['last'].widget.attrs.get('maxlength', None))\n self.assertEqual(last_size, result_fields['last'].widget.attrs.get('size', None))\n for key, val in expected_attrs.items():\n self.assertEqual(val, result_attrs[key])\n self.assertDictEqual(expected_attrs, result_attrs)\n\n self.form.alt_field_info = original_alt_field_info\n if original_alt_field_info is None:\n del self.form.alt_field_info\n self.form.fields = original_fields\n self.form.data = original_data\n self.form.get_overrides = original_get_overrides",
"def form_tweaks(self):\n pass",
"def get_context_data(self, **kwargs):\n if 'form' not in kwargs:\n kwargs['form'] = self.get_form(self.form_class)\n return super(OrganizerDataSetUpdate, self).get_context_data(**kwargs)",
"def _dirty (self):\n pass",
"def set_data_protected(self): \n pass",
"def setContentData(self, content):\n original = content\n if IVersionedObject.providedBy(original):\n content = original.get_editable()\n if content is None:\n self.widgetFactoryFactory = SMIDisplayWidgetFactory\n content = original.get_previewable()\n\n super(SMISubEditForm, self).setContentData(content)",
"def test_clean_returns_cleaned_data(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n new_cleaned_data = {self.form.name_for_user: 'test_value', self.form.name_for_email: 'test_value'}\n new_cleaned_data[self.form.USERNAME_FLAG_FIELD] = False\n self.form.cleaned_data = new_cleaned_data.copy()\n expected_fields = {**original_fields, **original_computed_fields}\n\n cleaned_data = self.form.clean()\n self.assertDictEqual(new_cleaned_data, cleaned_data)\n self.assertDictEqual(expected_fields, self.form.fields)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def _reset(self, *args):\n self.dirty = True",
"def test_update_attribute_data(self):\n pass",
"def update_data():\n pass",
"def _set_data(self, new_data):\n for name, field in self._get_fields().items():\n if name in new_data:\n try:\n setattr(self, f\"__{name}\", field.from_raw(new_data[name]))\n except (fields.ValidationError, ValueError):\n # should at least log validation and value errors\n # this can happen in case of e.g. fields type change\n pass",
"def set_data(self, new_data):\n self.data = new_data",
"def test_bad_flag_handle_flag_field(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n email_val = self.form_test_data.get(self.form.name_for_email) # was overwritten for form request.\n new_cleaned_data = {self.form.name_for_user: 'test_value', self.form.name_for_email: email_val}\n new_cleaned_data[self.form.USERNAME_FLAG_FIELD] = True\n user_field = self.form.computed_fields.pop(self.form.name_for_user, None)\n self.form.fields.update({self.form.name_for_user: user_field})\n email_field = self.form.fields[self.form.name_for_email]\n email_field.initial = getattr(self.user, self.form.name_for_user)\n self.form.cleaned_data = new_cleaned_data.copy()\n message = \"Un-check the box, or leave empty, if you want to use this email address. \"\n expected = {self.form.USERNAME_FLAG_FIELD: message}\n actual = self.form.handle_flag_field(self.form.name_for_email, self.form.name_for_user)\n actual_username = self.form.cleaned_data.get(self.form.name_for_user, None)\n\n self.assertIsNotNone(email_val)\n self.assertIsNotNone(user_field)\n self.assertTrue(email_field.has_changed(email_field.initial, self.form.cleaned_data[self.form.name_for_email]))\n self.assertNotEqual(getattr(self.user, self.form.name_for_user), email_val)\n self.assertEqual(new_cleaned_data[self.form.name_for_user], actual_username)\n self.assertNotEqual(email_val, actual_username)\n self.assertEqual(expected, actual)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def test_raises_set_alt_data(self):\n name, value = 'generic_field', 'alt_data_value'\n field = self.form.fields.get(name, None)\n self.assertIsNotNone(field, \"Unable to find the expected field in current fields. \")\n data = {name: (field, value)}\n\n with self.assertRaises(ImproperlyConfigured):\n self.form.set_alt_data(data=data, name=name, field=field, value=value)",
"def setContentData(self, content):\n original = content\n if IVersionedObject.providedBy(original):\n content = original.get_editable()\n if content is None:\n self.widgetFactoryFactory = SMIDisplayWidgetFactory\n content = original.get_previewable()\n\n super(SMIEditForm, self).setContentData(content)",
"def _replace_fields(self):\n for name, value in self._cleaned_data.items():\n setattr(self, name, value)",
"def update(self, instance, validated_data):\n validated_data.pop(\"assignment\", None)\n return super().update(instance, validated_data)"
] | [
"0.75196934",
"0.682521",
"0.67945904",
"0.6526392",
"0.62162715",
"0.6169545",
"0.61402756",
"0.614015",
"0.60818297",
"0.6079438",
"0.59753525",
"0.5968095",
"0.5960009",
"0.5838921",
"0.5813265",
"0.580115",
"0.5800875",
"0.5797445",
"0.57854867",
"0.57814664",
"0.5761745",
"0.57597053",
"0.57523173",
"0.57163745",
"0.5716279",
"0.5711077",
"0.57029504",
"0.5697661",
"0.5687939",
"0.56766886"
] | 0.7199473 | 1 |
If all fields are not changed, then the Form's data is not overwritten. | def test_set_alt_data_unchanged(self):
original_form_data = self.form.data
test_data = self.test_data.copy()
test_data._mutable = False
self.form.data = test_data
initial_data = test_data.copy()
alt_values = {name: f"alt_value_{name}" for name in self.test_initial}
test_input = {name: (self.form.fields[name], val) for name, val in alt_values.items()}
expect_updates = any(self.data_is_initial(name) for name in initial_data)
result = self.form.set_alt_data(test_input)
had_updates = any(self.form.data[name] != value for name, value in initial_data.items())
self.assertFalse(expect_updates)
self.assertFalse(had_updates)
self.assertDictEqual({}, result)
self.assertDictEqual(initial_data, self.form.data)
self.assertIs(test_data, self.form.data)
self.form.data = original_form_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _replace_fields(self):\n for name, value in self._cleaned_data.items():\n setattr(self, name, value)",
"def _clean(self):\n self.cleaned_data = super().clean()\n # Use bound data to set the value if we both have bound and initial data.\n if self.is_bound and self.initial:\n self._set_and_validate_data(self.data)\n return\n else:\n # Set values according to bound data\n if self.is_bound:\n self._set_and_validate_data(self.data)\n return\n # Set values according to initial data\n if self.initial:\n self._set_and_validate_data(self.initial)\n return",
"def test_prep_field_properties(self):\n original_data = self.form.data\n test_data = original_data.copy()\n # modify values in data\n test_data._mutable = False\n self.form.data = test_data\n original_fields = self.form.fields\n test_fields = original_fields.copy()\n # modify fields\n self.form.fields = test_fields\n test_fields_info = {name: field.__dict__.copy() for name, field in test_fields.items()}\n original_get_overrides = self.form.get_overrides\n def skip_overrides(): return {}\n self.form.get_overrides = skip_overrides\n original_alt_field_info = getattr(self.form, 'alt_field_info', None)\n self.form.alt_field_info = self.alt_field_info\n self.form.test_condition_response = True\n expected_fields_info = test_fields_info.copy()\n result_fields = self.form.prep_fields()\n result_fields_info = {name: field.__dict__.copy() for name, field in result_fields.items()}\n modified_info = self.alt_field_info['alt_test_feature']\n first_label = modified_info['first']['label']\n first_initial = modified_info['first']['initial']\n last_initial = modified_info['last']['initial']\n for name, opts in modified_info.items():\n expected_fields_info[name].update(opts)\n\n self.assertEqual(first_label, result_fields['first'].label)\n self.assertEqual(first_initial, result_fields['first'].initial)\n self.assertEqual(last_initial, result_fields['last'].initial)\n for key, val in expected_fields_info.items():\n self.assertEqual(val, result_fields_info[key])\n self.assertDictEqual(expected_fields_info, result_fields_info)\n\n self.form.test_condition_response = False\n self.form.alt_field_info = original_alt_field_info\n if original_alt_field_info is None:\n del self.form.alt_field_info\n self.form.fields = original_fields\n self.form.data = original_data\n self.form.get_overrides = original_get_overrides",
"def update_fields(self):\n if hasattr(self.day, \"body_composition\"):\n for f in self.get_fields():\n name = f.get_field().name\n value = getattr(self.day.body_composition, name, None)\n if value is not None:\n f.set_field(value)\n else:\n f.set_field(\"\")",
"def save(self, *args, **kwargs):\n if self.id is not None and 'update_fields' not in kwargs:\n kwargs['update_fields'] = self.non_state_fields\n super().save(*args, **kwargs)",
"def update_original_data(self):\n pass",
"def test_set_alt_data_mutable(self):\n original_test_initial = self.test_initial\n original_form_data = self.form.data\n initial = self.test_initial\n test_data = self.test_data.copy()\n test_data.update({name: initial[name] for name in list(initial.keys())[1:-1]}) # two fields for alt_values\n test_data._mutable = False\n self.form.data = test_data\n initial_data = test_data.copy()\n alt_values = {name: f\"alt_value_{name}\" for name in initial} # some, but not all, will be used.\n unchanged_fields = {name: val for name, val in test_data.items() if val == initial[name]}\n expected_result = {name: alt_values[name] for name in unchanged_fields}\n expected_data = test_data.copy()\n expected_data.update(expected_result)\n expect_updates = any(self.data_is_initial(name) for name in initial_data)\n test_input = {name: (self.form.fields[name], val) for name, val in alt_values.items()}\n result = self.form.set_alt_data(test_input)\n had_updates = any(value != self.form.data[name] for name, value in initial_data.items())\n\n for name, val in expected_data.items():\n self.assertEqual(val, self.form.data[name])\n self.assertTrue(expect_updates)\n self.assertTrue(had_updates)\n self.assertFalse(getattr(self.form.data, '_mutable', True))\n self.assertDictEqual(expected_result, result)\n self.assertDictEqual(expected_data, self.form.data)\n\n self.form.data = original_form_data\n self.test_initial = original_test_initial",
"def test_prep_overrides(self):\n original_data = self.form.data\n test_data = original_data.copy()\n test_data._mutable = False\n self.form.data = test_data # copied only to allow tear-down reverting to original.\n original_fields = self.form.fields\n test_fields = original_fields.copy()\n self.form.fields = test_fields # copied to allow tear-down reverting to original.\n original_get_overrides = self.form.get_overrides\n def replace_overrides(): return self.formfield_attrs_overrides\n self.form.get_overrides = replace_overrides\n original_alt_field_info = getattr(self.form, 'alt_field_info', None)\n self.form.alt_field_info = {}\n overrides = self.formfield_attrs_overrides.copy()\n DEFAULT = overrides.pop('_default_')\n expected_attrs = {}\n for name, field in test_fields.items():\n attrs = field.widget.attrs.copy()\n if isinstance(field.widget, (RadioSelect, CheckboxSelectMultiple, CheckboxInput, )):\n pass # update if similar section in prep_fields is updated.\n attrs.update(overrides.get(name, {}))\n # TODO: setup structure for using default or defined version for all CharFields.\n no_resize = overrides.get(name, {}).pop('no_size_override', False)\n no_resize = True if isinstance(field.widget, (HiddenInput, MultipleHiddenInput)) else no_resize\n if no_resize:\n expected_attrs[name] = attrs\n continue # None of the following size overrides are applied for this field.\n if isinstance(field.widget, Textarea):\n width_attr_name = 'cols'\n default = DEFAULT.get('cols', None)\n display_size = attrs.get('cols', None)\n if 'rows' in DEFAULT:\n height = attrs.get('rows', None)\n height = min((DEFAULT['rows'], int(height))) if height else DEFAULT['rows']\n attrs['rows'] = str(height)\n if default: # For textarea, we always override. The others depend on different conditions.\n display_size = display_size or default\n display_size = min((int(display_size), int(default)))\n elif issubclass(field.__class__, CharField):\n width_attr_name = 'size' # 'size' is only valid for input types: email, password, tel, text\n default = DEFAULT.get('size', None) # Cannot use float(\"inf\") as an int.\n display_size = attrs.get('size', None)\n else: # This field does not have a size setting.\n width_attr_name, default, display_size = None, None, None\n input_size = attrs.get('maxlength', None)\n possible_size = [int(ea) for ea in (display_size or default, input_size) if ea]\n # attrs['size'] = str(int(min(float(display_size), float(input_size)))) # Can't use float(\"inf\") as an int.\n if possible_size and width_attr_name:\n attrs[width_attr_name] = str(min(possible_size))\n expected_attrs[name] = attrs\n # Expected:\n # formfield_attrs_overrides = {\n # '_default_': {'size': 15, 'cols': 20, 'rows': 4, },\n # 'first': {'maxlength': 191, 'size': 20, },\n # 'second': {'maxlength': 2, }, # 'size': 2,\n # 'last': {'maxlength': 2, 'size': 5, },\n # }\n result_fields = self.form.prep_fields()\n result_attrs = {name: field.widget.attrs.copy() for name, field in result_fields.items()}\n first_maxlength = expected_attrs['first']['maxlength'] # overrides['first']['maxlength']\n first_size = expected_attrs['first']['size'] # overrides['first']['size']\n second_maxlength = expected_attrs['second']['maxlength'] # overrides['second']['maxlength']\n last_maxlength = expected_attrs['last']['maxlength'] # overrides['last']['maxlength']\n last_size = expected_attrs['last']['size'] # overrides['last']['size']\n\n self.assertEqual(first_maxlength, result_fields['first'].widget.attrs.get('maxlength', None))\n self.assertEqual(first_size, result_fields['first'].widget.attrs.get('size', None))\n self.assertEqual(second_maxlength, result_fields['second'].widget.attrs.get('maxlength', None))\n self.assertEqual(last_maxlength, result_fields['last'].widget.attrs.get('maxlength', None))\n self.assertEqual(last_size, result_fields['last'].widget.attrs.get('size', None))\n for key, val in expected_attrs.items():\n self.assertEqual(val, result_attrs[key])\n self.assertDictEqual(expected_attrs, result_attrs)\n\n self.form.alt_field_info = original_alt_field_info\n if original_alt_field_info is None:\n del self.form.alt_field_info\n self.form.fields = original_fields\n self.form.data = original_data\n self.form.get_overrides = original_get_overrides",
"def full_clean(self):\n self._errors = ErrorDict()\n if not self.is_bound: # Stop further processing.\n return\n self.cleaned_data = {}\n if self.empty_permitted and not self.has_changed():\n self.cleaned_data = None\n return\n for name, field in self.fields.items():\n self.clean_field(name, field)\n try:\n self.cleaned_data = self.clean()\n except ValidationError, e:\n self._errors[NON_FIELD_ERRORS] = e.messages\n if self._errors:\n delattr(self, 'cleaned_data')",
"def form_valid(self, form):\n if self.fields is None:\n self.object.__dict__.update({\n field.name:form.cleaned_data[field.name] for field in form.visible_fields()\n })\n else:\n self.object.__dict__.update({\n field:form.cleaned_data[field] for field in self.fields\n })\n self.object.save()\n if self.request.is_ajax():\n return self.ajax_form_valid()\n else:\n return HttpResponseRedirect(self.get_success_url())",
"def clean(self):\n\n self.cleaned_data = super(RoomForm, self).clean()\n\n cleaned_data = self.cleaned_data.copy()\n\n if cleaned_data.get(\"trial\") is None:\n self.cleaned_data[\"trial\"] = False\n else:\n cleaned_data.pop(\"trial\")\n\n if not all(cleaned_data.get(field) for field in cleaned_data.keys()):\n\n raise forms.ValidationError(\n message=\"You must fill in all the required fields!\",\n )",
"def update_only_validator(form):\n return \"form_result\" not in form.__dict__",
"def test_clean_returns_cleaned_data(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n new_cleaned_data = {self.form.name_for_user: 'test_value', self.form.name_for_email: 'test_value'}\n new_cleaned_data[self.form.USERNAME_FLAG_FIELD] = False\n self.form.cleaned_data = new_cleaned_data.copy()\n expected_fields = {**original_fields, **original_computed_fields}\n\n cleaned_data = self.form.clean()\n self.assertDictEqual(new_cleaned_data, cleaned_data)\n self.assertDictEqual(expected_fields, self.form.fields)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def reset_modified(self):\n self.modified_fields = set()\n\n # compensate for us not having knowledge of certain fields changing\n for field_name, field in self.schema.normal_fields.items():\n if isinstance(field, ObjectField):\n self.modified_fields.add(field_name)",
"def _setAllWithoutUpdate(self, data):\n super(SummonerModel, self)._setAllWithoutUpdate(data)",
"def test_handle_removals_add_if_named_in_data(self):\n original_data = self.form.data\n original_fields = self.form.fields\n fields = original_fields.copy()\n remove_names = ['second', 'last']\n self.form.removed_fields = {name: fields.pop(name) for name in remove_names if name in fields}\n self.form.remove_field_names = []\n expected_fields = dict(**fields, **self.form.removed_fields)\n test_data = original_data.copy()\n test_data.update({name: f\"value_{name}\" for name in remove_names})\n test_data._mutable = False\n self.form.data = test_data\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result))\n self.assertEqual(0, len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(expected_fields, result)\n self.assertDictEqual(original_fields, result)\n self.assertIs(fields, result)\n\n self.data = original_data",
"def test_no_error_handle_flag_field(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n new_cleaned_data = {self.form.name_for_user: 'test_value', self.form.name_for_email: 'test_value'}\n new_cleaned_data[self.form.USERNAME_FLAG_FIELD] = True # False\n user_field = self.form.computed_fields.pop(self.form.name_for_user, None)\n self.form.fields.update({self.form.name_for_user: user_field})\n email_field = self.form.fields[self.form.name_for_email]\n email_field.initial = new_cleaned_data[self.form.name_for_email]\n self.form.cleaned_data = new_cleaned_data.copy()\n expected = {}\n actual = self.form.handle_flag_field(self.form.name_for_email, self.form.name_for_user)\n\n self.assertIsNotNone(user_field)\n self.assertFalse(email_field.has_changed(email_field.initial, self.form.cleaned_data[self.form.name_for_email]))\n self.assertEqual(expected, actual)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def form_valid(self, form):\n form.save()\n return super().form_valid(form)",
"def test_set_alt_data_collection(self):\n names = list(self.test_data.keys())[1:-1]\n alt_values = {name: f\"alt_value_{name}\" for name in self.test_initial} # some, but not all, will be used.\n original_form_data = self.form.data\n test_data = self.test_data.copy()\n test_data.update({k: v for k, v in self.test_initial.items() if get_html_name(self.form, k) not in names})\n test_data._mutable = False\n self.form.data = test_data\n initial_data = test_data.copy()\n expected_result = {k: v for k, v in alt_values.items() if get_html_name(self.form, k) not in names}\n expected_data = test_data.copy()\n expected_data.update(expected_result)\n expect_updates = any(self.data_is_initial(name) for name in initial_data)\n test_input = {name: (self.form.fields[name], val) for name, val in alt_values.items()}\n result = self.form.set_alt_data(test_input)\n\n self.assertDictEqual(expected_result, result)\n self.assertDictEqual(expected_data, self.form.data)\n self.assertNotEqual(initial_data, self.form.data)\n self.assertTrue(expect_updates)\n self.assertIsNot(test_data, self.form.data)\n\n self.form.data = original_form_data",
"def has_changed(self) -> bool:\n for name, field in self.fields.items():\n if name == 'ORDER' or name == 'id':\n continue\n prefixed_name = self.add_prefix(name)\n data_value = field.widget.value_from_datadict(self.data, self.files, prefixed_name)\n if not field.show_hidden_initial:\n initial_value = self.initial.get(name, field.initial)\n if callable(initial_value):\n initial_value = initial_value()\n else:\n initial_prefixed_name = self.add_initial_prefix(name)\n hidden_widget = field.hidden_widget()\n try:\n initial_value = field.to_python(hidden_widget.value_from_datadict(\n self.data, self.files, initial_prefixed_name))\n except forms.ValidationError:\n # Always assume data has changed if validation fails.\n self._changed_data.append(name)\n continue\n # We're using a private API of Django here. This is not nice, but no problem as it seems\n # like this will become a public API in future Django.\n if field._has_changed(initial_value, data_value):\n return True\n return False",
"def partial_change(self):\n return self.attempted_change() and not all(self._get_field_data())",
"def test_set_alt_data_single(self):\n name, value = 'generic_field', 'alt_data_value'\n field = self.form.fields.get(name, None)\n self.assertIsNotNone(field, \"Unable to find the expected field in current fields. \")\n original_form_data = self.form.data\n test_data = self.test_data.copy()\n test_data.update({name: self.test_initial[name]})\n test_data._mutable = False\n self.form.data = test_data\n initial_data = test_data.copy()\n expected_data = test_data.copy()\n expected_data.update({name: value})\n initial_val = self.form.get_initial_for_field(field, name)\n html_name = self.form.add_prefix(name)\n data_val = field.widget.value_from_datadict(self.form.data, self.form.files, html_name)\n use_alt_value = not field.has_changed(initial_val, data_val)\n expected_value = value if use_alt_value else initial_data.get(name)\n expected_result = {name: value} if use_alt_value else {}\n result = self.form.set_alt_data(data=None, name=name, field=field, value=value)\n\n self.assertEqual(self.test_initial[name], initial_val)\n self.assertEqual(initial_data[name], data_val)\n self.assertEqual(expected_value, self.form.data[html_name])\n self.assertEqual(expected_value, field.initial)\n self.assertDictEqual(expected_result, result)\n for key in initial_data:\n self.assertEqual(expected_data[key], self.form.data[key])\n self.assertEqual(len(expected_data), len(self.form.data))\n self.assertTrue(use_alt_value)\n\n self.form.data = original_form_data",
"def save_formset(self, request, form, formset, change):\n save_instance = False\n for form in formset:\n if form.changed_data:\n save_instance = True\n super().save_formset(request, form, formset, change)\n if save_instance:\n formset.instance.last_change = now()\n formset.instance.save()",
"def _validate_fields(self, change_fields):\n pass",
"def _onchange_field(self):\n if not self.secretary_contact_id:\n return\n if self.partner_type in ['dr', 'patient', 'secretary']:\n self.update({\n 'secretary_contact_id': False\n })",
"def clean(self):\n cleaned_data = super(UserUpdateForm, self).clean()\n if cleaned_data.get(\"password\") != cleaned_data.get(\"password2\"):\n raise forms.ValidationError(\"The new passwords do not match.\")\n elif cleaned_data.get(\"password\") == cleaned_data.get(\"oldpassword\"):\n raise forms.ValidationError(\n \"The new password needs to be different from the old one.\"\n )\n\n return cleaned_data",
"def get_context_data(self, **kwargs):\n if 'form' not in kwargs:\n kwargs['form'] = self.get_form(self.form_class)\n return super(OrganizerDataSetUpdate, self).get_context_data(**kwargs)",
"def test_prep_remaining(self):\n self.assertTrue(hasattr(self.form, 'prep_remaining'))\n original_fields = self.form.fields\n self.form.fields = original_fields.copy()\n remaining_fields = original_fields.copy()\n opts, field_rows = {'fake_opts': 'fake', 'fields': ['nope']}, [{'name': 'assigned_field'}]\n args = ['arbitrary', 'input', 'args']\n kwargs = {'test_1': 'data_1', 'test_2': 'data_2'}\n\n expected = (opts.copy(), field_rows.copy(), remaining_fields.copy(), *args, kwargs.copy())\n actual = self.form.prep_remaining(opts, field_rows, remaining_fields, *args, **kwargs)\n self.assertEqual(expected, actual)\n\n self.form.fields = original_fields",
"def test_clean_moves_computed_fields_to_fields(self):\n name = 'test_field'\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n computed_names = list(self.form.computed_fields.keys())\n field_names = list(self.form.fields.keys())\n field_data = {f_name: f\"input_{f_name}_{i}\" for i, f_name in enumerate(field_names)}\n field_data.update({name: f\"value_{f_name}_{i}\" for i, f_name in enumerate(computed_names)})\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy() # mimic full_clean\n populated_cleaned_data = deepcopy(original_cleaned_data or {})\n populated_cleaned_data.update(field_data)\n self.form.cleaned_data = populated_cleaned_data.copy() # ensure cleaned_data is present (mimic full_clean)\n final_cleaned_data = self.form.clean()\n\n self.assertIn(name, computed_names)\n self.assertNotIn(name, field_names)\n self.assertEqual(1, len(computed_names))\n self.assertIn(name, self.form.fields)\n self.assertNotEqual(original_cleaned_data, final_cleaned_data)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def _set_data(self, new_data):\n for name, field in self._get_fields().items():\n if name in new_data:\n try:\n setattr(self, f\"__{name}\", field.from_raw(new_data[name]))\n except (fields.ValidationError, ValueError):\n # should at least log validation and value errors\n # this can happen in case of e.g. fields type change\n pass"
] | [
"0.7125693",
"0.6493488",
"0.6476172",
"0.6390869",
"0.63886714",
"0.63684744",
"0.6261592",
"0.6239529",
"0.62338805",
"0.62091047",
"0.61917824",
"0.61357147",
"0.6092662",
"0.60753626",
"0.6056802",
"0.6033103",
"0.6012269",
"0.6007175",
"0.6002412",
"0.5995106",
"0.5991512",
"0.597885",
"0.5956133",
"0.59397334",
"0.5932139",
"0.5907822",
"0.59052753",
"0.5903221",
"0.5899023",
"0.5889677"
] | 0.68604416 | 1 |
For a field name condition_ method returning true, updates the result as expected. | def test_update_condition_true(self):
original_alt_info = getattr(self.form, 'alt_field_info', None)
expected_label = 'alt_test_feature'
test_method = getattr(self.form, 'condition_' + expected_label, None)
alt_info = getattr(self, 'alt_field_info', None)
expected = alt_info.get(expected_label, None)
self.form.alt_field_info = alt_info
self.form.test_condition_response = True
actual = self.form.get_alt_field_info()
self.assertIsNotNone(alt_info)
self.assertIsNotNone(test_method)
self.assertTrue(test_method())
self.assertIsNotNone(expected)
self.assertIn(expected_label, alt_info)
self.assertEqual(expected, actual)
self.form.test_condition_response = False
self.form.alt_field_info = original_alt_info
if original_alt_info is None:
del self.form.alt_field_info | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, fieldupdate='abc', condition='INVALID'):\n sql = self.generate_update_sql(fieldupdate, condition)\n self.sqlhistory.append(sql)\n return self.sql_update(sql)",
"def _updateField(self, entity, entity_properties, name):\n\n from soc.logic.helper import org_app_survey as org_app_helper\n\n value = entity_properties[name]\n\n if name == 'status' and value in ['accepted', 'rejected'] and \\\n entity.status != value:\n # Send email and notification that this application has been\n # accepted/rejected.\n org_app_helper.sendApplicationProcessedNotification(\n entity, value, self.module_name, self.mail_templates)\n\n return super(Logic, self)._updateField(entity, entity_properties, name)",
"def _propagate_changes(condition, changed_data, old_name):\n if '_formula' in changed_data:\n condition.update_fields()\n\n if condition.is_filter:\n # A filter does not have a name, thus no more changes needed.\n return\n\n # If condition name has changed, rename appearances in the content\n # field of the action.\n if 'name' in changed_data and condition.action:\n # Performing string substitution in the content and saving\n replacing = '{{% if {0} %}}'\n condition.action.text_content = condition.action.text_content.replace(\n escape(replacing.format(old_name)),\n escape(replacing.format(condition.name)))\n condition.action.save(update_fields=['text_content'])",
"def condition(self):\n return True",
"def test_fields_updated_with_computed(self):\n pass",
"def test_update_condition_false(self):\n original_alt_info = getattr(self.form, 'alt_field_info', None)\n expected_label = 'alt_test_feature'\n test_method = getattr(self.form, 'condition_' + expected_label, None)\n alt_info = getattr(self, 'alt_field_info', None)\n expected = {}\n self.form.alt_field_info = alt_info\n self.form.test_condition_response = False\n actual = self.form.get_alt_field_info()\n\n self.assertIsNotNone(alt_info)\n self.assertIsNotNone(test_method)\n self.assertFalse(test_method())\n self.assertIsNotNone(expected)\n self.assertIn(expected_label, alt_info)\n self.assertEqual(expected, actual)\n\n self.form.test_condition_response = False\n self.form.alt_field_info = original_alt_info\n if original_alt_info is None:\n del self.form.alt_field_info",
"def __update(self, condition, values):\n col = _VirtualColumn(\n df_name=self.thisptr[\"df_name_\"],\n operator=\"update\",\n operand1=self,\n operand2=values\n )\n if condition.thisptr[\"type_\"] != \"VirtualBooleanColumn\":\n raise Exception(\"Condition for an update must be a Boolen column.\")\n col.thisptr[\"condition_\"] = condition.thisptr\n return col",
"def test(self, values: Dict[str, Any]) -> Optional[str]:\n # This is always True\n if self.cond == '#':\n return None\n\n def why(cond, field, explanation) -> Optional[str]:\n if cond:\n return None\n return '{}: {}'.format(field, explanation)\n\n # If it's missing, it's only True if it's a missing test.\n if self.field not in values:\n # Default to ignoring id field as long as no version.\n if self.field == '':\n return why('-' not in self.value, 'id', 'unknown version {}'.format(self.value))\n return why(self.cond == '!', self.field, 'is missing')\n\n # If they supply a function, hand it to them.\n if callable(values[self.field]):\n return values[self.field](self)\n\n val = str(values[self.field])\n if self.cond == '!':\n return why(False, self.field, 'is present')\n elif self.cond == '=':\n return why(val == self.value,\n self.field,\n '!= {}'.format(self.value))\n elif self.cond == '/':\n return why(val != self.value,\n self.field,\n '= {}'.format(self.value))\n elif self.cond == '^':\n return why(val.startswith(self.value),\n self.field,\n 'does not start with {}'.format(self.value))\n elif self.cond == '$':\n return why(val.endswith(self.value),\n self.field,\n 'does not end with {}'.format(self.value))\n elif self.cond == '~':\n return why(self.value in val,\n self.field,\n 'does not contain {}'.format(self.value))\n elif self.cond == '<':\n try:\n actual_int = int(val)\n except ValueError:\n return why(False, self.field, \"not an integer field\")\n try:\n restriction_val = int(self.value)\n except ValueError:\n return why(False, self.field, \"not a valid integer\")\n return why(actual_int < restriction_val,\n self.field,\n \">= {}\".format(restriction_val))\n elif self.cond == '>':\n try:\n actual_int = int(val)\n except ValueError:\n return why(False, self.field, \"not an integer field\")\n try:\n restriction_val = int(self.value)\n except ValueError:\n return why(False, self.field, \"not a valid integer\")\n return why(actual_int > restriction_val,\n self.field,\n \"<= {}\".format(restriction_val))\n elif self.cond == '{':\n return why(val < self.value,\n self.field,\n 'is the same or ordered after {}'.format(self.value))\n elif self.cond == '}':\n return why(val > self.value,\n self.field,\n 'is the same or ordered before {}'.format(self.value))\n else:\n # We checked this in init!\n assert False",
"def updateFieldsForInput(self, input_name, fields_dict, input_field_name=\"Name\"):\r\n \r\n where_clause = \"%s = \\'%s\\'\" % (input_field_name, input_name)\r\n self.arc_table_utils.updateFields(self.fullpath, fields_dict, {'where_clause':where_clause})",
"def condition(self) -> global___Expression:",
"def condition(self) -> global___Expression:",
"def condition(self, condition):\n\n self._condition = condition",
"def update_element(cls, condition=None, async=True, **kwargs):\n\n command = cls.__table__.update().values(**kwargs)\n\n if condition is not None:\n command = command.where(condition)\n\n return DBConnection.execute_command(command=command, async=async)",
"def incr_cond(self):\n pass",
"def _process_if(self, node):\n creg = node.children[0].name\n cval = node.children[1].value\n self.backend.set_condition(creg, cval)\n self._process_node(node.children[2])\n self.backend.drop_condition()",
"def update_waiting(self):\n if self.variant(map(lambda x: x is not None, self.get_value(0, True))):\n values = list(filter(lambda x: x is not None, self.get_value(0, True)))\n if self.name == \"and\":\n self.set_value(all(values), 0)\n elif self.name == \"or\":\n self.set_value(any(values), 0)\n elif self.name == \"not and\":\n self.set_value(not all(values), 0)\n elif self.name == \"nor or\":\n self.set_value(not any(values), 0)\n elif self.name == \"equal\":\n self.set_value(len(set(values)) == 1, 0)\n self.state = ACTIVE",
"def test_update_condition_not_defined(self):\n original_alt_info = getattr(self.form, 'alt_field_info', None)\n expected_label = 'alt_test_no_method'\n label_for_used_attrs = 'alt_test_feature'\n test_method = getattr(self.form, 'condition_' + expected_label, None)\n alt_info = getattr(self, 'alt_field_info', None)\n expected = alt_info.get(label_for_used_attrs, None)\n self.form.alt_field_info = alt_info\n self.form.test_condition_response = True\n actual = self.form.get_alt_field_info()\n\n self.assertIsNotNone(alt_info)\n self.assertIsNone(test_method)\n self.assertIsNotNone(expected)\n self.assertIn(expected_label, alt_info)\n self.assertEqual(expected, actual)\n\n self.form.test_condition_response = False\n self.form.alt_field_info = original_alt_info\n if original_alt_info is None:\n del self.form.alt_field_info",
"def update_field_date(self, fieldid, name, namespace, require, modify, check, fill, remark):\n return self.mongo.db.userfield.update(\n {\n \"fields._id\":ObjectId(fieldid)\n },\n {\n '$set':\n {\n 'fields.$.name':name,\n 'fields.$.namespace':namespace,\n 'fields.$.require':bool(int(require)),\n 'fields.$.modify':bool(int(modify)),\n 'fields.$.check':bool(int(check)),\n 'fields.$.fill':bool(int(fill)),\n 'fields.$.remark':remark,\n }\n })",
"def checkTrue(comment, res, update=True):\n if update:\n if res:\n results[\"pass\"] += 1\n else:\n print(\"checking bool\",comment,'|',res,'is not True!')\n results[\"fail\"] += 1\n return res",
"def _solution_on_update(solution, field_name, old_value, new_value):\n if solution.status != SolutionStatus.SUBMITTED:\n return # not interesting\n\n old = old_value >= SOLUTION_CORRECT_SCORE\n new = new_value >= SOLUTION_CORRECT_SCORE\n\n if old != new:\n _update_solved_count(new - old, solution.task, solution.author.get_profile())",
"def update_record(self, collection_name, update_record, update_condition):\n try:\n self.logger.info('in update_record()')\n collection = self.get_db()[collection_name]\n collection.update_one(update_condition, {\"$set\": update_record})\n self.logger.info('out update_record()')\n except Exception as e:\n self.logger.error(f'Error occurred while updating record {e}')",
"def conditional(self) -> global___Statement.Conditional:",
"def generate_update_sql(self, fieldupdate, condition):\n return \"UPDATE %s SET %s WHERE %s\" % (self.tablename, fieldupdate, condition)",
"def update_field_input(self, fieldid, name, namespace, require, modify, check, fill, regex, warning, unique, remark):\n return self.mongo.db.userfield.update(\n {\n \"fields._id\":ObjectId(fieldid)\n },\n {\n '$set':\n {\n 'fields.$.name':name,\n 'fields.$.namespace':namespace,\n 'fields.$.require':bool(int(require)),\n 'fields.$.modify':bool(int(modify)),\n 'fields.$.check':bool(int(check)),\n 'fields.$.fill':bool(int(fill)),\n 'fields.$.unique':bool(int(unique)),\n 'fields.$.regex':regex,\n 'fields.$.warning':warning,\n 'fields.$.remark':remark\n }\n })",
"def _optimize_field_by_name(self, store: QueryOptimizerStore, model, selection, field_def) -> bool:\n name = self._get_name_from_field_dev(field_def)\n if not (model_field := self._get_model_field_from_name(model, name)):\n return False\n _logger.info('_optimize_field_by_name %r %r', name, model_field)\n if self._is_foreign_key_id(model_field, name):\n # ToDo: check if this works - i write resolvers for this\n store.only(name)\n return True\n if model_field.many_to_one or model_field.one_to_one:\n # ForeignKey or OneToOneField\n field_store = self._optimize_gql_selections(\n selection.selections,\n self._get_type(field_def),\n )\n store.select_related(name, field_store)\n return True\n if model_field.one_to_many or model_field.many_to_many:\n field_store = self._optimize_gql_selections(\n selection.selections,\n self._get_type(field_def),\n )\n if isinstance(model_field, ManyToOneRel):\n field_store.only(model_field.field.name)\n related_queryset = model_field.related_model.objects.all()\n _logger.info('_optimize_field_by_name many relation %r %r', model, name)\n store.prefetch_related(name, field_store, related_queryset)\n return True\n if not model_field.is_relation:\n store.only(name)\n return True\n return False",
"def test_control_update_field(self, field, new_value):\n control = factories.ControlFactory()\n\n self.api.put(control, control.id, {field: new_value})\n\n control = db.session.query(all_models.Control).get(control.id)\n self.assertEquals(getattr(control, field), new_value)",
"def _truth_value(self, condition):\n if condition:\n return 'true stuff'\n else:\n return 'false stuff'",
"def _truth_value(self, condition):\n if condition:\n return 'true stuff'\n else:\n return 'false stuff'",
"def test_updating_record_through_filter(self, test_domain):\n identifier1 = uuid4()\n identifier2 = uuid4()\n identifier3 = uuid4()\n identifier4 = uuid4()\n test_domain.repository_for(Person)._dao.create(\n id=identifier1, first_name=\"Athos\", last_name=\"Musketeer\", age=2\n )\n test_domain.repository_for(Person)._dao.create(\n id=identifier2, first_name=\"Porthos\", last_name=\"Musketeer\", age=3\n )\n test_domain.repository_for(Person)._dao.create(\n id=identifier3, first_name=\"Aramis\", last_name=\"Musketeer\", age=4\n )\n test_domain.repository_for(Person)._dao.create(\n id=identifier4, first_name=\"dArtagnan\", last_name=\"Musketeer\", age=5\n )\n\n # Perform update\n updated_count = (\n test_domain.repository_for(Person)\n ._dao.query.filter(age__gt=3)\n .update(last_name=\"Fraud\")\n )\n\n # Query and check if only the relevant records have been updated\n assert updated_count == 2\n\n u_person1 = test_domain.repository_for(Person)._dao.get(identifier1)\n u_person2 = test_domain.repository_for(Person)._dao.get(identifier2)\n u_person3 = test_domain.repository_for(Person)._dao.get(identifier3)\n u_person4 = test_domain.repository_for(Person)._dao.get(identifier4)\n assert u_person1.last_name == \"Musketeer\"\n assert u_person2.last_name == \"Musketeer\"\n assert u_person3.last_name == \"Fraud\"\n assert u_person4.last_name == \"Fraud\"",
"def AddCondition(self, name, expression):\n self.conditions[name] = expression"
] | [
"0.68372643",
"0.5833345",
"0.5775355",
"0.55311084",
"0.5475029",
"0.5427229",
"0.53909963",
"0.53827405",
"0.5348961",
"0.53487056",
"0.53487056",
"0.5307851",
"0.52772653",
"0.5267646",
"0.52673876",
"0.5218061",
"0.5189151",
"0.517015",
"0.5168191",
"0.5159086",
"0.5145711",
"0.5125274",
"0.5097138",
"0.50881946",
"0.5072278",
"0.5047906",
"0.5042992",
"0.5042992",
"0.50138634",
"0.49967015"
] | 0.6231951 | 1 |
Unchanged fields if 'remove_field_names' and 'removed_fields' are empty. | def test_unchanged_handle_removals(self):
original_fields = self.form.fields
fields = original_fields.copy()
self.form.removed_fields = {}
self.form.remove_field_names = []
result = self.form.handle_removals(fields)
self.assertEqual(len(original_fields), len(result))
self.assertEqual(0, len(self.form.removed_fields))
self.assertEqual(0, len(self.form.remove_field_names))
self.assertDictEqual(original_fields, result)
self.assertIs(fields, result) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_handle_removals_missing_removed_fields(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n self.form.remove_field_names = []\n if hasattr(self.form, 'removed_fields'):\n del self.form.removed_fields\n result = self.form.handle_removals(fields)\n\n self.assertTrue(hasattr(self.form, 'removed_fields'))\n self.assertEqual(len(original_fields), len(result))\n self.assertEqual(0, len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(original_fields, result)\n self.assertIs(fields, result)",
"def test_handle_removals_remove_field_names(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n remove_names = ['second', 'last']\n expected_fields = {name: field for name, field in fields.items() if name not in remove_names}\n self.form.removed_fields = {}\n self.form.remove_field_names = remove_names\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result) + len(remove_names))\n self.assertEqual(len(remove_names), len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(expected_fields, result)\n self.assertIs(fields, result)",
"def test_handle_removals_named_fields_not_in_data(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n remove_names = ['second', 'last']\n original_data = self.form.data\n data = original_data.copy()\n data.appendlist(remove_names[1], 'test_data_last')\n data._mutable = False\n self.form.data = data\n expected_fields = {name: field for name, field in fields.items() if name != remove_names[0]}\n self.form.removed_fields = {}\n self.form.remove_field_names = remove_names\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result) + len(remove_names) - 1)\n self.assertEqual(len(remove_names) - 1, len(self.form.removed_fields))\n self.assertEqual(1, len(self.form.remove_field_names))\n self.assertDictEqual(expected_fields, result)\n self.assertIs(fields, result)\n\n self.form.data = original_data",
"def test_handle_removals_add_if_named_in_data(self):\n original_data = self.form.data\n original_fields = self.form.fields\n fields = original_fields.copy()\n remove_names = ['second', 'last']\n self.form.removed_fields = {name: fields.pop(name) for name in remove_names if name in fields}\n self.form.remove_field_names = []\n expected_fields = dict(**fields, **self.form.removed_fields)\n test_data = original_data.copy()\n test_data.update({name: f\"value_{name}\" for name in remove_names})\n test_data._mutable = False\n self.form.data = test_data\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result))\n self.assertEqual(0, len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(expected_fields, result)\n self.assertDictEqual(original_fields, result)\n self.assertIs(fields, result)\n\n self.data = original_data",
"def test_handle_removals_missing_remove_field_names(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n if hasattr(self.form, 'remove_field_names'):\n del self.form.remove_field_names\n\n with self.assertRaises(ImproperlyConfigured):\n self.form.handle_removals(fields)",
"def remove_unuseful(remove_fields: np.ndarray, remove_values: np.ndarray):\n remove_fields = remove_fields[[0, 1, 2, 3, 4, 6]]\n remove_values = remove_values[:, [0, 1, 2, 3, 4, 6]]\n return remove_fields, remove_values",
"def remove_all_fields(self):\n self.fields = None",
"def reset_modified(self):\n self.modified_fields = set()\n\n # compensate for us not having knowledge of certain fields changing\n for field_name, field in self.schema.normal_fields.items():\n if isinstance(field, ObjectField):\n self.modified_fields.add(field_name)",
"def remove_ei(remove_fields: np.ndarray, remove_values: np.ndarray):\n remove_fields = remove_fields[2:10]\n remove_values = remove_values[:, 2:10]\n return remove_fields, remove_values",
"def _modify(self, fields):\n return fields",
"def drop(self, fields, inplace=True):\n if inplace:\n obj = self\n else:\n obj = copy.deepcopy(self)\n\n for field in list(fields):\n del obj[field]\n\n return obj",
"def test_clean_moves_computed_fields_to_fields(self):\n name = 'test_field'\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n computed_names = list(self.form.computed_fields.keys())\n field_names = list(self.form.fields.keys())\n field_data = {f_name: f\"input_{f_name}_{i}\" for i, f_name in enumerate(field_names)}\n field_data.update({name: f\"value_{f_name}_{i}\" for i, f_name in enumerate(computed_names)})\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy() # mimic full_clean\n populated_cleaned_data = deepcopy(original_cleaned_data or {})\n populated_cleaned_data.update(field_data)\n self.form.cleaned_data = populated_cleaned_data.copy() # ensure cleaned_data is present (mimic full_clean)\n final_cleaned_data = self.form.clean()\n\n self.assertIn(name, computed_names)\n self.assertNotIn(name, field_names)\n self.assertEqual(1, len(computed_names))\n self.assertIn(name, self.form.fields)\n self.assertNotEqual(original_cleaned_data, final_cleaned_data)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def __init__(self,**args):\n self.remove_fields = args['remove'] if 'remove' in args else []",
"def clear_field_values(self):\n\t\tlogging.info(\"Clearing values in the field[] dictionary of the object\")\n\t\tlogging.debug(\"Before = \" + str(self.field))\n\t\tfor key, value in self.fields.items():\n\t\t\tself.field[str(key)] = None\n\t\tlogging.debug(\"After = \" + str(self.field))\n\t\treturn",
"def _validate_fields(self, change_fields):\n pass",
"def _drop_fields(usecols, dtype, dropcols):\n for col in dropcols:\n try:\n usecols.remove(col)\n except ValueError:\n pass\n try:\n del dtype[col]\n except KeyError:\n pass\n return usecols, dtype",
"def remove_readonly_fields(self, readonly_field_names):\n values = self.query.values\n\n # The tuple is (field, model, value) where model if used for FKs.\n values[:] = (\n (field, _, __) for (field, _, __) in values\n if field.name not in readonly_field_names\n )",
"def remove_read_only_fields(self):\n self.fields = XML_List(Elements.FIELDS, [field for field in self.fields if\n not field.read_only or not str_to_bool(field.read_only)])",
"def filter_allowed_fields(self):\n allowed_fields = super().filter_allowed_fields\n # Remove assignment_id\n allowed_fields.remove('assignment_id')\n return allowed_fields",
"def remove_readonly_fields(self, readonly_field_names):\n fields = self.query.fields\n\n try:\n fields[:] = self._exclude_readonly_fields(\n fields, readonly_field_names)\n except AttributeError:\n # When deserializing, we might get an attribute error because this\n # list shoud be copied first :\n\n # \"AttributeError: The return type of 'local_concrete_fields'\n # should never be mutated. If you want to manipulate this list for\n # your own use, make a copy first.\"\n\n self.query.fields = list(self._exclude_readonly_fields(\n fields, readonly_field_names))",
"def strip_unwanted_fields(self, data, many, **kwargs):\n unwanted_fields = [\"resource_type\"]\n for field in unwanted_fields:\n if field in data:\n data.pop(field)\n return data",
"def depopulate(self, is_update):\n fields = {}\n schema = self.schema\n for k, field in schema.fields.items():\n is_modified = k in self.modified_fields\n orig_v = getattr(self, k)\n v = field.iset(\n self,\n orig_v,\n is_update=is_update,\n is_modified=is_modified\n )\n\n if is_modified or v is not None:\n if is_update and field.is_pk() and v == orig_v:\n continue\n\n else:\n fields[k] = v\n\n if not is_update:\n for field_name in schema.required_fields.keys():\n if field_name not in fields:\n raise KeyError(\"Missing required field {}\".format(field_name))\n\n return fields",
"def clean_whitespace_without_clear(etl, field_names, **kwargs):\r\n import arcetl\r\n func = functools.partial(\r\n etl.transform, transformation=arcetl.attributes.update_by_function,\r\n function=value.clean_whitespace_without_clear, **kwargs\r\n )\r\n tuple(func(field_name=name) for name in field_names)",
"def revive(self):\n field_name = self.get_delete_flag_field_name()\n return self.update(**{field_name: None})",
"def data_without(self, fields):\n without = {}\n data = json.loads(self.data())\n for field, value in data.items():\n if field not in fields:\n without[field] = value\n return json.dumps(without)",
"def _fetch_fields(self, old_or_new, target_fields):\r\n \r\n returned_fields = []\r\n for target_field in target_fields:\r\n if target_field in [\",\", \"\\t\"]:\r\n returned_fields.append(target_field)\r\n else:\r\n try:\r\n returned_fields.append(str(getattr(old_or_new, target_field)))\r\n except:\r\n returned_fields.append(\"-\") \r\n return returned_fields",
"def _clean(self):\n map(self.__delitem__, self.keys())\n self._original = []\n self._columns = {}\n self._modified, self._deleted = {}, {}",
"def test_raises_if_missed_fields(self):\n name = 'second'\n self.form.called_handle_modifiers = False\n remove = {'remove_field': name}\n self.form.handle_modifiers({}, [], **remove)\n self.assertNotIn(name, self.form.fields)\n self.assertIn(name, self.form.hold_field)\n message = \"Some unassigned fields, perhaps some added during handle_modifiers. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets(add_field=name)\n self.form.called_handle_modifiers = False",
"def task_2_remove_dict_fields(data: DT, redundant_keys: List[str]) -> DT:\n dict2 = copy.deepcopy(data)\n for item in dict2:\n for key in redundant_keys:\n item.pop(key)\n return dict2",
"def whitelist_form_fields(form, whitlisted_fields):\n for schema in getAdditionalSchemata(form):\n behavior_interface_name = schema.__name__\n for fieldname in schema:\n full_name = '{}.{}'.format(behavior_interface_name, fieldname)\n if full_name in whitlisted_fields:\n continue\n\n remove(form, fieldname, behavior_interface_name)"
] | [
"0.74554706",
"0.74491864",
"0.72936064",
"0.6925307",
"0.6923496",
"0.6707438",
"0.64466757",
"0.6417706",
"0.62968796",
"0.6211249",
"0.6186095",
"0.61174846",
"0.610701",
"0.6081443",
"0.6038494",
"0.59998083",
"0.5926599",
"0.58847034",
"0.5825061",
"0.5818654",
"0.5809551",
"0.57926965",
"0.57911",
"0.5774583",
"0.5723824",
"0.56985646",
"0.56849325",
"0.5679338",
"0.56656075",
"0.5633379"
] | 0.7591741 | 0 |
Unchanged fields. Form does not have removed_fields property initially, but it is added. | def test_handle_removals_missing_removed_fields(self):
original_fields = self.form.fields
fields = original_fields.copy()
self.form.remove_field_names = []
if hasattr(self.form, 'removed_fields'):
del self.form.removed_fields
result = self.form.handle_removals(fields)
self.assertTrue(hasattr(self.form, 'removed_fields'))
self.assertEqual(len(original_fields), len(result))
self.assertEqual(0, len(self.form.removed_fields))
self.assertEqual(0, len(self.form.remove_field_names))
self.assertDictEqual(original_fields, result)
self.assertIs(fields, result) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_unchanged_handle_removals(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n self.form.removed_fields = {}\n self.form.remove_field_names = []\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result))\n self.assertEqual(0, len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(original_fields, result)\n self.assertIs(fields, result)",
"def remove_all_fields(self):\n self.fields = None",
"def test_handle_removals_remove_field_names(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n remove_names = ['second', 'last']\n expected_fields = {name: field for name, field in fields.items() if name not in remove_names}\n self.form.removed_fields = {}\n self.form.remove_field_names = remove_names\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result) + len(remove_names))\n self.assertEqual(len(remove_names), len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(expected_fields, result)\n self.assertIs(fields, result)",
"def test_handle_removals_named_fields_not_in_data(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n remove_names = ['second', 'last']\n original_data = self.form.data\n data = original_data.copy()\n data.appendlist(remove_names[1], 'test_data_last')\n data._mutable = False\n self.form.data = data\n expected_fields = {name: field for name, field in fields.items() if name != remove_names[0]}\n self.form.removed_fields = {}\n self.form.remove_field_names = remove_names\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result) + len(remove_names) - 1)\n self.assertEqual(len(remove_names) - 1, len(self.form.removed_fields))\n self.assertEqual(1, len(self.form.remove_field_names))\n self.assertDictEqual(expected_fields, result)\n self.assertIs(fields, result)\n\n self.form.data = original_data",
"def test_handle_removals_missing_remove_field_names(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n if hasattr(self.form, 'remove_field_names'):\n del self.form.remove_field_names\n\n with self.assertRaises(ImproperlyConfigured):\n self.form.handle_removals(fields)",
"def clear_field_values(self):\n\t\tlogging.info(\"Clearing values in the field[] dictionary of the object\")\n\t\tlogging.debug(\"Before = \" + str(self.field))\n\t\tfor key, value in self.fields.items():\n\t\t\tself.field[str(key)] = None\n\t\tlogging.debug(\"After = \" + str(self.field))\n\t\treturn",
"def test_handle_removals_add_if_named_in_data(self):\n original_data = self.form.data\n original_fields = self.form.fields\n fields = original_fields.copy()\n remove_names = ['second', 'last']\n self.form.removed_fields = {name: fields.pop(name) for name in remove_names if name in fields}\n self.form.remove_field_names = []\n expected_fields = dict(**fields, **self.form.removed_fields)\n test_data = original_data.copy()\n test_data.update({name: f\"value_{name}\" for name in remove_names})\n test_data._mutable = False\n self.form.data = test_data\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result))\n self.assertEqual(0, len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(expected_fields, result)\n self.assertDictEqual(original_fields, result)\n self.assertIs(fields, result)\n\n self.data = original_data",
"def reset_modified(self):\n self.modified_fields = set()\n\n # compensate for us not having knowledge of certain fields changing\n for field_name, field in self.schema.normal_fields.items():\n if isinstance(field, ObjectField):\n self.modified_fields.add(field_name)",
"def drop(self, fields, inplace=True):\n if inplace:\n obj = self\n else:\n obj = copy.deepcopy(self)\n\n for field in list(fields):\n del obj[field]\n\n return obj",
"def remove_field():\n _id = request.form['_id']\n data, code, message = FIELD_SERVICE.remove_field(_id)\n return __result(data, code, message)",
"def clear_fields(self):\n\n if not self.is_root:\n return\n self.field_data.clear()",
"def remove_read_only_fields(self):\n self.fields = XML_List(Elements.FIELDS, [field for field in self.fields if\n not field.read_only or not str_to_bool(field.read_only)])",
"def filter_allowed_fields(self):\n allowed_fields = super().filter_allowed_fields\n # Remove assignment_id\n allowed_fields.remove('assignment_id')\n return allowed_fields",
"def _modify(self, fields):\n return fields",
"def whitelist_form_fields(form, whitlisted_fields):\n for schema in getAdditionalSchemata(form):\n behavior_interface_name = schema.__name__\n for fieldname in schema:\n full_name = '{}.{}'.format(behavior_interface_name, fieldname)\n if full_name in whitlisted_fields:\n continue\n\n remove(form, fieldname, behavior_interface_name)",
"def clearField(self):\n self.field.clearFields()",
"def test_clean_moves_computed_fields_to_fields(self):\n name = 'test_field'\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n computed_names = list(self.form.computed_fields.keys())\n field_names = list(self.form.fields.keys())\n field_data = {f_name: f\"input_{f_name}_{i}\" for i, f_name in enumerate(field_names)}\n field_data.update({name: f\"value_{f_name}_{i}\" for i, f_name in enumerate(computed_names)})\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy() # mimic full_clean\n populated_cleaned_data = deepcopy(original_cleaned_data or {})\n populated_cleaned_data.update(field_data)\n self.form.cleaned_data = populated_cleaned_data.copy() # ensure cleaned_data is present (mimic full_clean)\n final_cleaned_data = self.form.clean()\n\n self.assertIn(name, computed_names)\n self.assertNotIn(name, field_names)\n self.assertEqual(1, len(computed_names))\n self.assertIn(name, self.form.fields)\n self.assertNotEqual(original_cleaned_data, final_cleaned_data)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def data_without(self, fields):\n without = {}\n data = json.loads(self.data())\n for field, value in data.items():\n if field not in fields:\n without[field] = value\n return json.dumps(without)",
"def set_sensor_only_fields(self):\n\n self.sensor_fields = dict(self.all_fields)\n\n del self.sensor_fields[self.stamp_field]\n\n for label_field in self.label_fields:\n del self.sensor_fields[label_field]",
"def test_raises_if_missed_fields(self):\n name = 'second'\n self.form.called_handle_modifiers = False\n remove = {'remove_field': name}\n self.form.handle_modifiers({}, [], **remove)\n self.assertNotIn(name, self.form.fields)\n self.assertIn(name, self.form.hold_field)\n message = \"Some unassigned fields, perhaps some added during handle_modifiers. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets(add_field=name)\n self.form.called_handle_modifiers = False",
"def get_cleaned_data(form, keys_to_remove=[], values_to_remove=[]):\n if not values_to_remove:\n values_to_remove = get_ignorable_form_values()\n\n cleaned_data = copy.copy(form.cleaned_data)\n cleaned_data = clean_dict(\n cleaned_data,\n keys=list(set(cleaned_data.keys()) - set(keys_to_remove)),\n values=values_to_remove\n )\n\n ordered_cleaned_data = OrderedDict()\n for key in form.fields.keys():\n if key in cleaned_data:\n ordered_cleaned_data[key] = cleaned_data[key]\n\n return ordered_cleaned_data",
"def depopulate(self, is_update):\n fields = {}\n schema = self.schema\n for k, field in schema.fields.items():\n is_modified = k in self.modified_fields\n orig_v = getattr(self, k)\n v = field.iset(\n self,\n orig_v,\n is_update=is_update,\n is_modified=is_modified\n )\n\n if is_modified or v is not None:\n if is_update and field.is_pk() and v == orig_v:\n continue\n\n else:\n fields[k] = v\n\n if not is_update:\n for field_name in schema.required_fields.keys():\n if field_name not in fields:\n raise KeyError(\"Missing required field {}\".format(field_name))\n\n return fields",
"def test_charter_form_excluded_fields(self):\n\n charter_form = CharterForm()\n self.assertNotIn(\"created_at\", charter_form.fields)",
"def _replace_fields(self):\n for name, value in self._cleaned_data.items():\n setattr(self, name, value)",
"def get_current_fields(self):\n return self.form.fields.copy()",
"def _get_all_fields():\n participant_form = custom_form_factory(ParticipantEditForm)\n return list(participant_form().exclude([\n CustomField.CHECKBOX,\n CustomField.IMAGE,\n CustomField.EVENT\n ]))",
"def fields(self):\n self.update()\n return self.__fields",
"def get_empty_fields(self):\n return [f for f in self.__dict__ if not self.__dict__[f]]",
"def test_prep_remaining(self):\n self.assertTrue(hasattr(self.form, 'prep_remaining'))\n original_fields = self.form.fields\n self.form.fields = original_fields.copy()\n remaining_fields = original_fields.copy()\n opts, field_rows = {'fake_opts': 'fake', 'fields': ['nope']}, [{'name': 'assigned_field'}]\n args = ['arbitrary', 'input', 'args']\n kwargs = {'test_1': 'data_1', 'test_2': 'data_2'}\n\n expected = (opts.copy(), field_rows.copy(), remaining_fields.copy(), *args, kwargs.copy())\n actual = self.form.prep_remaining(opts, field_rows, remaining_fields, *args, **kwargs)\n self.assertEqual(expected, actual)\n\n self.form.fields = original_fields",
"def test_missing_initial_fieldsets(self):\n original_initial_fieldsets = self.form.fieldsets\n print(\"========================= TEST UNABLE TO DELETE THE PROPERTY FOR TESTING ========================\")\n print(original_initial_fieldsets)\n print(\"--------------------------------------\")\n delattr(self.form, 'fieldsets')\n response_fieldsets = self.form.make_fieldsets()\n print(response_fieldsets)\n\n setattr(self.form, 'fieldsets', original_initial_fieldsets)"
] | [
"0.77649677",
"0.7524932",
"0.7281162",
"0.7231894",
"0.6988346",
"0.68625975",
"0.67639565",
"0.6626596",
"0.6497562",
"0.6426146",
"0.6331287",
"0.62694836",
"0.62495565",
"0.6249388",
"0.6208533",
"0.6078891",
"0.60334074",
"0.6032778",
"0.60258466",
"0.60191256",
"0.600394",
"0.5995988",
"0.59955734",
"0.5958493",
"0.5949233",
"0.5879033",
"0.5858742",
"0.58167374",
"0.58059514",
"0.58006984"
] | 0.7574787 | 1 |
Fields whose name is in remove_field_names are removed from fields (with no form data). | def test_handle_removals_remove_field_names(self):
original_fields = self.form.fields
fields = original_fields.copy()
remove_names = ['second', 'last']
expected_fields = {name: field for name, field in fields.items() if name not in remove_names}
self.form.removed_fields = {}
self.form.remove_field_names = remove_names
result = self.form.handle_removals(fields)
self.assertEqual(len(original_fields), len(result) + len(remove_names))
self.assertEqual(len(remove_names), len(self.form.removed_fields))
self.assertEqual(0, len(self.form.remove_field_names))
self.assertDictEqual(expected_fields, result)
self.assertIs(fields, result) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_handle_removals_missing_remove_field_names(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n if hasattr(self.form, 'remove_field_names'):\n del self.form.remove_field_names\n\n with self.assertRaises(ImproperlyConfigured):\n self.form.handle_removals(fields)",
"def remove_all_fields(self):\n self.fields = None",
"def test_handle_removals_named_fields_not_in_data(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n remove_names = ['second', 'last']\n original_data = self.form.data\n data = original_data.copy()\n data.appendlist(remove_names[1], 'test_data_last')\n data._mutable = False\n self.form.data = data\n expected_fields = {name: field for name, field in fields.items() if name != remove_names[0]}\n self.form.removed_fields = {}\n self.form.remove_field_names = remove_names\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result) + len(remove_names) - 1)\n self.assertEqual(len(remove_names) - 1, len(self.form.removed_fields))\n self.assertEqual(1, len(self.form.remove_field_names))\n self.assertDictEqual(expected_fields, result)\n self.assertIs(fields, result)\n\n self.form.data = original_data",
"def test_handle_removals_missing_removed_fields(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n self.form.remove_field_names = []\n if hasattr(self.form, 'removed_fields'):\n del self.form.removed_fields\n result = self.form.handle_removals(fields)\n\n self.assertTrue(hasattr(self.form, 'removed_fields'))\n self.assertEqual(len(original_fields), len(result))\n self.assertEqual(0, len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(original_fields, result)\n self.assertIs(fields, result)",
"def test_unchanged_handle_removals(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n self.form.removed_fields = {}\n self.form.remove_field_names = []\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result))\n self.assertEqual(0, len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(original_fields, result)\n self.assertIs(fields, result)",
"def whitelist_form_fields(form, whitlisted_fields):\n for schema in getAdditionalSchemata(form):\n behavior_interface_name = schema.__name__\n for fieldname in schema:\n full_name = '{}.{}'.format(behavior_interface_name, fieldname)\n if full_name in whitlisted_fields:\n continue\n\n remove(form, fieldname, behavior_interface_name)",
"def remove_field():\n _id = request.form['_id']\n data, code, message = FIELD_SERVICE.remove_field(_id)\n return __result(data, code, message)",
"def strip_unwanted_fields(self, data, many, **kwargs):\n unwanted_fields = [\"resource_type\"]\n for field in unwanted_fields:\n if field in data:\n data.pop(field)\n return data",
"def remove_unuseful(remove_fields: np.ndarray, remove_values: np.ndarray):\n remove_fields = remove_fields[[0, 1, 2, 3, 4, 6]]\n remove_values = remove_values[:, [0, 1, 2, 3, 4, 6]]\n return remove_fields, remove_values",
"def test_handle_removals_add_if_named_in_data(self):\n original_data = self.form.data\n original_fields = self.form.fields\n fields = original_fields.copy()\n remove_names = ['second', 'last']\n self.form.removed_fields = {name: fields.pop(name) for name in remove_names if name in fields}\n self.form.remove_field_names = []\n expected_fields = dict(**fields, **self.form.removed_fields)\n test_data = original_data.copy()\n test_data.update({name: f\"value_{name}\" for name in remove_names})\n test_data._mutable = False\n self.form.data = test_data\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result))\n self.assertEqual(0, len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(expected_fields, result)\n self.assertDictEqual(original_fields, result)\n self.assertIs(fields, result)\n\n self.data = original_data",
"def drop(self, fields, inplace=True):\n if inplace:\n obj = self\n else:\n obj = copy.deepcopy(self)\n\n for field in list(fields):\n del obj[field]\n\n return obj",
"def remove_readonly_fields(self, readonly_field_names):\n values = self.query.values\n\n # The tuple is (field, model, value) where model if used for FKs.\n values[:] = (\n (field, _, __) for (field, _, __) in values\n if field.name not in readonly_field_names\n )",
"def remove_readonly_fields(self, readonly_field_names):\n fields = self.query.fields\n\n try:\n fields[:] = self._exclude_readonly_fields(\n fields, readonly_field_names)\n except AttributeError:\n # When deserializing, we might get an attribute error because this\n # list shoud be copied first :\n\n # \"AttributeError: The return type of 'local_concrete_fields'\n # should never be mutated. If you want to manipulate this list for\n # your own use, make a copy first.\"\n\n self.query.fields = list(self._exclude_readonly_fields(\n fields, readonly_field_names))",
"def filter_allowed_fields(self):\n allowed_fields = super().filter_allowed_fields\n # Remove assignment_id\n allowed_fields.remove('assignment_id')\n return allowed_fields",
"def drop_fields(key):\n return scom.drop_fields(key)",
"def remove_ei(remove_fields: np.ndarray, remove_values: np.ndarray):\n remove_fields = remove_fields[2:10]\n remove_values = remove_values[:, 2:10]\n return remove_fields, remove_values",
"def _drop_fields(usecols, dtype, dropcols):\n for col in dropcols:\n try:\n usecols.remove(col)\n except ValueError:\n pass\n try:\n del dtype[col]\n except KeyError:\n pass\n return usecols, dtype",
"def remove_read_only_fields(self):\n self.fields = XML_List(Elements.FIELDS, [field for field in self.fields if\n not field.read_only or not str_to_bool(field.read_only)])",
"def drop(self, name: str):\n del self._fields[name]",
"def pop_non_relevant_vuln_fields(data: Dict):\n keys_to_keep = [\n \"title\",\n \"description\",\n \"content_type\",\n \"published_at\",\n \"references\",\n \"severity\",\n \"solutions\",\n \"alternate_ids\",\n ]\n for key in list(data):\n if key not in keys_to_keep:\n data.pop(key)",
"def _remove_none(self, data):\r\n for key, value in data.items():\r\n if value is None or isinstance(value, forms.Field):\r\n del data[key]\r\n if isinstance(value, dict):\r\n self._remove_none(data[key])",
"def pop_non_relevant_module_fields(data: Dict):\n keys_to_keep = [\n \"title\",\n \"description\",\n \"content_type\",\n \"published_at\",\n \"references\",\n \"architectures\",\n \"authors\",\n \"rank\",\n \"reliability\",\n ]\n for key in list(data):\n if key not in keys_to_keep:\n data.pop(key)",
"def clean(self, value):\n return [f.clean(v) for v,f in zip(value, self.fields)]",
"def pop_non_relevant_search_fields(data: Dict):\n keys_to_keep = [\"title\", \"published_at\", \"identifier\"]\n for key in list(data):\n if key not in keys_to_keep:\n data.pop(key)",
"def data_without(self, fields):\n without = {}\n data = json.loads(self.data())\n for field, value in data.items():\n if field not in fields:\n without[field] = value\n return json.dumps(without)",
"def clear_field_values(self):\n\t\tlogging.info(\"Clearing values in the field[] dictionary of the object\")\n\t\tlogging.debug(\"Before = \" + str(self.field))\n\t\tfor key, value in self.fields.items():\n\t\t\tself.field[str(key)] = None\n\t\tlogging.debug(\"After = \" + str(self.field))\n\t\treturn",
"def remove_attributes(self, remove_attrs):\n remove = []\n for attr in self.data:\n for prefix in remove_attrs:\n if attr.startswith(prefix):\n remove.append(attr)\n break\n\n self.data = self.data.drop(remove, axis=1)",
"def remove_attributes(self, remove_attrs):\n remove = []\n for attr in self.data:\n for prefix in remove_attrs:\n if attr.startswith(prefix):\n remove.append(attr)\n break\n\n self.data = self.data.drop(remove, axis=1)",
"def __init__(self,**args):\n self.remove_fields = args['remove'] if 'remove' in args else []",
"def filter_excluded_fields(fields, Meta, exclude_dump_only):\n exclude = getattr(Meta, \"exclude\", [])\n if exclude_dump_only:\n exclude += getattr(Meta, \"dump_only\", [])\n\n filtered_fields = OrderedDict(\n (key, value) for key, value in fields.items() if key not in exclude\n )\n\n return filtered_fields"
] | [
"0.74436945",
"0.737302",
"0.7368792",
"0.7205383",
"0.70427924",
"0.6999577",
"0.67760515",
"0.67616045",
"0.6653553",
"0.6589306",
"0.65694857",
"0.6391059",
"0.6376142",
"0.63376814",
"0.6242384",
"0.62271845",
"0.6207275",
"0.6149979",
"0.61190933",
"0.6039027",
"0.6027406",
"0.6025633",
"0.59242964",
"0.5896673",
"0.589312",
"0.5885446",
"0.5881243",
"0.5881243",
"0.58538675",
"0.584278"
] | 0.7726188 | 0 |
Fields whose name is in remove_field_names, but not named in form data, are removed from fields. | def test_handle_removals_named_fields_not_in_data(self):
original_fields = self.form.fields
fields = original_fields.copy()
remove_names = ['second', 'last']
original_data = self.form.data
data = original_data.copy()
data.appendlist(remove_names[1], 'test_data_last')
data._mutable = False
self.form.data = data
expected_fields = {name: field for name, field in fields.items() if name != remove_names[0]}
self.form.removed_fields = {}
self.form.remove_field_names = remove_names
result = self.form.handle_removals(fields)
self.assertEqual(len(original_fields), len(result) + len(remove_names) - 1)
self.assertEqual(len(remove_names) - 1, len(self.form.removed_fields))
self.assertEqual(1, len(self.form.remove_field_names))
self.assertDictEqual(expected_fields, result)
self.assertIs(fields, result)
self.form.data = original_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_handle_removals_remove_field_names(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n remove_names = ['second', 'last']\n expected_fields = {name: field for name, field in fields.items() if name not in remove_names}\n self.form.removed_fields = {}\n self.form.remove_field_names = remove_names\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result) + len(remove_names))\n self.assertEqual(len(remove_names), len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(expected_fields, result)\n self.assertIs(fields, result)",
"def test_handle_removals_missing_remove_field_names(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n if hasattr(self.form, 'remove_field_names'):\n del self.form.remove_field_names\n\n with self.assertRaises(ImproperlyConfigured):\n self.form.handle_removals(fields)",
"def test_handle_removals_missing_removed_fields(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n self.form.remove_field_names = []\n if hasattr(self.form, 'removed_fields'):\n del self.form.removed_fields\n result = self.form.handle_removals(fields)\n\n self.assertTrue(hasattr(self.form, 'removed_fields'))\n self.assertEqual(len(original_fields), len(result))\n self.assertEqual(0, len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(original_fields, result)\n self.assertIs(fields, result)",
"def test_unchanged_handle_removals(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n self.form.removed_fields = {}\n self.form.remove_field_names = []\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result))\n self.assertEqual(0, len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(original_fields, result)\n self.assertIs(fields, result)",
"def test_handle_removals_add_if_named_in_data(self):\n original_data = self.form.data\n original_fields = self.form.fields\n fields = original_fields.copy()\n remove_names = ['second', 'last']\n self.form.removed_fields = {name: fields.pop(name) for name in remove_names if name in fields}\n self.form.remove_field_names = []\n expected_fields = dict(**fields, **self.form.removed_fields)\n test_data = original_data.copy()\n test_data.update({name: f\"value_{name}\" for name in remove_names})\n test_data._mutable = False\n self.form.data = test_data\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result))\n self.assertEqual(0, len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(expected_fields, result)\n self.assertDictEqual(original_fields, result)\n self.assertIs(fields, result)\n\n self.data = original_data",
"def whitelist_form_fields(form, whitlisted_fields):\n for schema in getAdditionalSchemata(form):\n behavior_interface_name = schema.__name__\n for fieldname in schema:\n full_name = '{}.{}'.format(behavior_interface_name, fieldname)\n if full_name in whitlisted_fields:\n continue\n\n remove(form, fieldname, behavior_interface_name)",
"def remove_all_fields(self):\n self.fields = None",
"def strip_unwanted_fields(self, data, many, **kwargs):\n unwanted_fields = [\"resource_type\"]\n for field in unwanted_fields:\n if field in data:\n data.pop(field)\n return data",
"def remove_field():\n _id = request.form['_id']\n data, code, message = FIELD_SERVICE.remove_field(_id)\n return __result(data, code, message)",
"def remove_unuseful(remove_fields: np.ndarray, remove_values: np.ndarray):\n remove_fields = remove_fields[[0, 1, 2, 3, 4, 6]]\n remove_values = remove_values[:, [0, 1, 2, 3, 4, 6]]\n return remove_fields, remove_values",
"def drop(self, fields, inplace=True):\n if inplace:\n obj = self\n else:\n obj = copy.deepcopy(self)\n\n for field in list(fields):\n del obj[field]\n\n return obj",
"def remove_readonly_fields(self, readonly_field_names):\n values = self.query.values\n\n # The tuple is (field, model, value) where model if used for FKs.\n values[:] = (\n (field, _, __) for (field, _, __) in values\n if field.name not in readonly_field_names\n )",
"def remove_readonly_fields(self, readonly_field_names):\n fields = self.query.fields\n\n try:\n fields[:] = self._exclude_readonly_fields(\n fields, readonly_field_names)\n except AttributeError:\n # When deserializing, we might get an attribute error because this\n # list shoud be copied first :\n\n # \"AttributeError: The return type of 'local_concrete_fields'\n # should never be mutated. If you want to manipulate this list for\n # your own use, make a copy first.\"\n\n self.query.fields = list(self._exclude_readonly_fields(\n fields, readonly_field_names))",
"def _drop_fields(usecols, dtype, dropcols):\n for col in dropcols:\n try:\n usecols.remove(col)\n except ValueError:\n pass\n try:\n del dtype[col]\n except KeyError:\n pass\n return usecols, dtype",
"def filter_allowed_fields(self):\n allowed_fields = super().filter_allowed_fields\n # Remove assignment_id\n allowed_fields.remove('assignment_id')\n return allowed_fields",
"def drop(self, name: str):\n del self._fields[name]",
"def _replace_fields(self):\n for name, value in self._cleaned_data.items():\n setattr(self, name, value)",
"def pop_non_relevant_vuln_fields(data: Dict):\n keys_to_keep = [\n \"title\",\n \"description\",\n \"content_type\",\n \"published_at\",\n \"references\",\n \"severity\",\n \"solutions\",\n \"alternate_ids\",\n ]\n for key in list(data):\n if key not in keys_to_keep:\n data.pop(key)",
"def remove_ei(remove_fields: np.ndarray, remove_values: np.ndarray):\n remove_fields = remove_fields[2:10]\n remove_values = remove_values[:, 2:10]\n return remove_fields, remove_values",
"def drop_fields(key):\n return scom.drop_fields(key)",
"def pop_non_relevant_module_fields(data: Dict):\n keys_to_keep = [\n \"title\",\n \"description\",\n \"content_type\",\n \"published_at\",\n \"references\",\n \"architectures\",\n \"authors\",\n \"rank\",\n \"reliability\",\n ]\n for key in list(data):\n if key not in keys_to_keep:\n data.pop(key)",
"def get_cleaned_data(form, keys_to_remove=[], values_to_remove=[]):\n if not values_to_remove:\n values_to_remove = get_ignorable_form_values()\n\n cleaned_data = copy.copy(form.cleaned_data)\n cleaned_data = clean_dict(\n cleaned_data,\n keys=list(set(cleaned_data.keys()) - set(keys_to_remove)),\n values=values_to_remove\n )\n\n ordered_cleaned_data = OrderedDict()\n for key in form.fields.keys():\n if key in cleaned_data:\n ordered_cleaned_data[key] = cleaned_data[key]\n\n return ordered_cleaned_data",
"def _remove_none(self, data):\r\n for key, value in data.items():\r\n if value is None or isinstance(value, forms.Field):\r\n del data[key]\r\n if isinstance(value, dict):\r\n self._remove_none(data[key])",
"def remove_field_name(a, name):\n names = list(a.dtype.names)\n if name in names:\n names.remove(name)\n b = a[names]\n return b",
"def clean(self, value):\n return [f.clean(v) for v,f in zip(value, self.fields)]",
"def _remove_data(things, lst_remove=None):\n\n for data in things:\n data.pop(\"_sa_instance_state\", None)\n data.pop(\"user_id\", None)\n\n if lst_remove is not None:\n for str_remove in lst_remove:\n if str_remove in data:\n data.pop(str_remove, None)\n\n return things",
"def pop_non_relevant_search_fields(data: Dict):\n keys_to_keep = [\"title\", \"published_at\", \"identifier\"]\n for key in list(data):\n if key not in keys_to_keep:\n data.pop(key)",
"def clear_field_values(self):\n\t\tlogging.info(\"Clearing values in the field[] dictionary of the object\")\n\t\tlogging.debug(\"Before = \" + str(self.field))\n\t\tfor key, value in self.fields.items():\n\t\t\tself.field[str(key)] = None\n\t\tlogging.debug(\"After = \" + str(self.field))\n\t\treturn",
"def remove_read_only_fields(self):\n self.fields = XML_List(Elements.FIELDS, [field for field in self.fields if\n not field.read_only or not str_to_bool(field.read_only)])",
"def data_without(self, fields):\n without = {}\n data = json.loads(self.data())\n for field, value in data.items():\n if field not in fields:\n without[field] = value\n return json.dumps(without)"
] | [
"0.7919481",
"0.76232165",
"0.733925",
"0.71936774",
"0.71093166",
"0.7092437",
"0.70440346",
"0.67084694",
"0.667372",
"0.6472375",
"0.63328904",
"0.62806547",
"0.62099826",
"0.620513",
"0.6195708",
"0.60789603",
"0.60676354",
"0.60476226",
"0.6041081",
"0.6028844",
"0.6009088",
"0.60053855",
"0.5953914",
"0.59286094",
"0.59192723",
"0.5915477",
"0.5891",
"0.58751434",
"0.585975",
"0.5836726"
] | 0.7789917 | 1 |
Applies overrides of field widget attrs if name is in overrides. | def test_prep_overrides(self):
original_data = self.form.data
test_data = original_data.copy()
test_data._mutable = False
self.form.data = test_data # copied only to allow tear-down reverting to original.
original_fields = self.form.fields
test_fields = original_fields.copy()
self.form.fields = test_fields # copied to allow tear-down reverting to original.
original_get_overrides = self.form.get_overrides
def replace_overrides(): return self.formfield_attrs_overrides
self.form.get_overrides = replace_overrides
original_alt_field_info = getattr(self.form, 'alt_field_info', None)
self.form.alt_field_info = {}
overrides = self.formfield_attrs_overrides.copy()
DEFAULT = overrides.pop('_default_')
expected_attrs = {}
for name, field in test_fields.items():
attrs = field.widget.attrs.copy()
if isinstance(field.widget, (RadioSelect, CheckboxSelectMultiple, CheckboxInput, )):
pass # update if similar section in prep_fields is updated.
attrs.update(overrides.get(name, {}))
# TODO: setup structure for using default or defined version for all CharFields.
no_resize = overrides.get(name, {}).pop('no_size_override', False)
no_resize = True if isinstance(field.widget, (HiddenInput, MultipleHiddenInput)) else no_resize
if no_resize:
expected_attrs[name] = attrs
continue # None of the following size overrides are applied for this field.
if isinstance(field.widget, Textarea):
width_attr_name = 'cols'
default = DEFAULT.get('cols', None)
display_size = attrs.get('cols', None)
if 'rows' in DEFAULT:
height = attrs.get('rows', None)
height = min((DEFAULT['rows'], int(height))) if height else DEFAULT['rows']
attrs['rows'] = str(height)
if default: # For textarea, we always override. The others depend on different conditions.
display_size = display_size or default
display_size = min((int(display_size), int(default)))
elif issubclass(field.__class__, CharField):
width_attr_name = 'size' # 'size' is only valid for input types: email, password, tel, text
default = DEFAULT.get('size', None) # Cannot use float("inf") as an int.
display_size = attrs.get('size', None)
else: # This field does not have a size setting.
width_attr_name, default, display_size = None, None, None
input_size = attrs.get('maxlength', None)
possible_size = [int(ea) for ea in (display_size or default, input_size) if ea]
# attrs['size'] = str(int(min(float(display_size), float(input_size)))) # Can't use float("inf") as an int.
if possible_size and width_attr_name:
attrs[width_attr_name] = str(min(possible_size))
expected_attrs[name] = attrs
# Expected:
# formfield_attrs_overrides = {
# '_default_': {'size': 15, 'cols': 20, 'rows': 4, },
# 'first': {'maxlength': 191, 'size': 20, },
# 'second': {'maxlength': 2, }, # 'size': 2,
# 'last': {'maxlength': 2, 'size': 5, },
# }
result_fields = self.form.prep_fields()
result_attrs = {name: field.widget.attrs.copy() for name, field in result_fields.items()}
first_maxlength = expected_attrs['first']['maxlength'] # overrides['first']['maxlength']
first_size = expected_attrs['first']['size'] # overrides['first']['size']
second_maxlength = expected_attrs['second']['maxlength'] # overrides['second']['maxlength']
last_maxlength = expected_attrs['last']['maxlength'] # overrides['last']['maxlength']
last_size = expected_attrs['last']['size'] # overrides['last']['size']
self.assertEqual(first_maxlength, result_fields['first'].widget.attrs.get('maxlength', None))
self.assertEqual(first_size, result_fields['first'].widget.attrs.get('size', None))
self.assertEqual(second_maxlength, result_fields['second'].widget.attrs.get('maxlength', None))
self.assertEqual(last_maxlength, result_fields['last'].widget.attrs.get('maxlength', None))
self.assertEqual(last_size, result_fields['last'].widget.attrs.get('size', None))
for key, val in expected_attrs.items():
self.assertEqual(val, result_attrs[key])
self.assertDictEqual(expected_attrs, result_attrs)
self.form.alt_field_info = original_alt_field_info
if original_alt_field_info is None:
del self.form.alt_field_info
self.form.fields = original_fields
self.form.data = original_data
self.form.get_overrides = original_get_overrides | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_overrides(self, app, name, namespace,\n flag='reset', override_values=None):\n if override_values is None:\n override_values = {}\n body = {'flag': flag, 'values': override_values, 'attributes': {}}\n return self._update(self._path(app) +\n '?name=' + name +\n '&namespace=' + namespace, body)",
"def set_field_widget_attributes(field, widget_attributes):\n for key, value in widget_attributes.items():\n field.widget.attrs[key] = value\n if key == \"class\":\n # djangular overwrites widget classes using the built-in \"widget_css_classes\" attribute\n # so be sure to re-set it here\n field.widget_css_classes = value",
"def update_field_widget_attributes(field, widget_attributes):\n for key, value in widget_attributes.items():\n try:\n current_attributes = field.widget.attrs[key]\n field.widget.attrs[key] = \"%s %s\" % (current_attributes, value)\n except KeyError:\n field.widget.attrs[key] = value\n if key == \"class\":\n # djangular overwrites widget classes using the built-in \"widget_css_classes\" attribute\n # so be sure to re-set it here\n try:\n current_widget_css_classes = field.widget_css_classes\n field.widget_css_classes = \"%s %s\" % (current_widget_css_classes, value)\n except AttributeError:\n field.widget_css_classes = value",
"def no_resize_override(self, empty=False, names='all'):\n if names == 'all':\n names = list(self.form.fields.keys())\n overrides = {} if empty else getattr(self.form, 'formfield_attrs_overrides', {})\n add_skip = {'no_size_override': True}\n for name in names:\n overrides[name] = overrides.get(name, {})\n overrides[name].update(add_skip)\n return overrides",
"def get_format_attrs(self, name, field, alt_field_info={}):\n # important_props = ('initial', 'autofocus', 'widget')\n if name in alt_field_info:\n field = deepcopy(field)\n for prop, value in alt_field_info[name].items():\n setattr(field, prop, value)\n initial = field.initial\n initial = initial() if callable(initial) else initial\n attrs, result = {}, []\n if initial and not isinstance(field.widget, Textarea):\n attrs['value'] = str(initial)\n data_val = self.form.data.get(get_html_name(self.form, name), None)\n if data_val not in ('', None):\n attrs['value'] = data_val\n attrs.update(field.widget_attrs(field.widget))\n result = ''.join(f'{key}=\"{val}\" ' for key, val in attrs.items())\n if getattr(field, 'autofocus', None):\n result += 'autofocus '\n if issubclass(self.form.__class__, FormOverrideMixIn):\n # TODO: Expand for actual output when using FormOverrideMixIn, or a sub-class of it.\n result += '%(attrs)s' # content '%(attrs)s'\n else:\n result = '%(attrs)s' + result # '%(attrs)s' content\n return result",
"def widget_attrs(self, widget):\n\n attrs = super(RelateField, self).widget_attrs(widget)\n\n attrs.update({'content_type': self.content_types})\n\n return attrs",
"def __init__(self, *args, **kwargs):\n super(ProfileForm, self).__init__(*args, **kwargs) \n for field in self.fields:\n self.fields[field].widget.attrs.update(\n {\n 'class': 'form-control',\n }\n )",
"def __init__(self, *args, **kwargs):\n super(CustomAuthenticationForm, self).__init__(*args, **kwargs)\n for field in self.fields:\n self.fields[field].widget.attrs.update(\n {\n 'class': 'form-control',\n }\n )",
"def withOverrides(overrides):",
"def set_default_binding_overrides(self, overrides):\n self.__default_binding_overrides = overrides or {}",
"def set_override(self, name, override, group=None):\n opt_info = self._get_opt_info(name, group)\n opt_info['override'] = self._get_enforced_type_value(\n opt_info['opt'], override)\n opt_info['location'] = LocationInfo(\n Locations.set_override,\n _get_caller_detail(3), # this function has a decorator to skip\n )",
"def makeOverrides(self):\n\t\tself.overridesWithValues = self.dataOverrides",
"def _overrides(self, tense, overrides, attr_name,persons=None): \n if not hasattr(self, attr_name):\n self_overrides = [ None ] * len(Tense)\n setattr(self, attr_name, self_overrides) \n else:\n self_overrides = getattr(self, attr_name)\n \n if tense in Tense.Person_Agnostic():\n if isinstance(overrides, str) or self_overrides[tense] is None:\n self_overrides[tense] = [ overrides ]\n else:\n self_overrides[tense].append(overrides)\n return\n \n if persons is None:\n _persons = Person\n elif isinstance(persons, int):\n _persons = [ persons ]\n elif isinstance(persons, list):\n _persons = persons\n else:\n self.__raise(\"persons must be None, integer or list of integers\", tense)\n \n if self_overrides[tense] is None:\n self_overrides[tense] = [None] * len(Person)\n \n if isinstance(overrides, str) or inspect.isfunction(overrides) or inspect.ismethod(overrides): \n for person in _persons:\n if isinstance(overrides, str) or self_overrides[tense][person] is None:\n # if a hard replacement (string), previous overrides are discarded because they will be replaced.\n # or this is the first override\n self_overrides[tense][person] = [overrides]\n else:\n self_overrides[tense][person].append(overrides) \n \n elif isinstance(overrides, list):\n for person, override in enumerate(overrides):\n if override is not None:\n if isinstance(override, str) or self_overrides[tense][person] is None:\n # if a hard replacement (string), previous overrides are discarded because they will be replaced.\n # or this is the first override\n self_overrides[tense][person] = [override]\n else:\n self_overrides[tense][person].append(override)",
"def replace(self, *args, **kws):\r\n for x in self.ATTRS:\r\n kws.setdefault(x, getattr(self, x))\r\n cls = self.__class__\r\n return cls(*args, **kws)",
"def assign_attrs(elem, attrs):\n for k, v in attrs:\n # assign attr k with v\n # override class\n elem.set(sanitize_name(k), v)",
"def get_switched_form_field_attrs(self, prefix, input_type, name):\n attributes = {'class': 'switched', 'data-switch-on': prefix + 'field'}\n attributes['data-' + prefix + 'field-' + input_type] = name\n return attributes",
"def date_attrs(name):\n attrs = battrs(name)\n attrs.update({'class': 'form-control datepicker'})\n return attrs",
"def test_good_practice_attrs(self):\n # FormOverrideMixIn.good_practice_attrs\n pass",
"def apply_overrides(self, parent_values):\n raise NotImplementedError(\n \"{} does not have implemented `apply_overrides`\".format(self)\n )",
"def set_attrs(self, username, attrs):\n pass",
"def set_field_attributes(fields, errors):\n for field in fields:\n field_instance = fields[field]\n widget = field_instance.widget\n if isinstance(field_instance, forms.DateField) and isinstance(widget, forms.TextInput):\n field_instance.format = '%d/%m/%Y'\n add_class_to_widget(widget, 'date')\n widget.attrs['type'] = 'text'\n elif isinstance(field_instance, forms.DateTimeField):\n field_instance.format = '%d/%m/%Y %H:%M'\n if isinstance(widget, forms.TextInput):\n add_class_to_widget(widget, 'datetime')\n elif isinstance(widget, DatetimeInput):\n add_class_to_widget(widget.widgets[0], 'date')\n elif isinstance(field_instance, forms.FloatField) and isinstance(widget, forms.TextInput):\n add_class_to_widget(widget, 'float')\n elif isinstance(field_instance, forms.IntegerField) and isinstance(widget, forms.TextInput):\n add_class_to_widget(widget, 'int')\n elif isinstance(field_instance, forms.CharField) and isinstance(widget, forms.TextInput):\n add_class_to_widget(widget, 'char')\n\n if isinstance(widget, forms.CheckboxSelectMultiple):\n add_class_to_widget(widget, 'checkbox-multiple-select')\n\n if field in errors:\n add_class_to_widget(widget, 'with_errors')\n if 'title' not in widget.attrs:\n widget.attrs['title'] = '; '.join(errors[field])\n\n add_class_to_widget(widget, 'form-control')",
"def user_overrides(f, overrides=None, *args, **kwargs):\n # problematically i don't really know how to do this.\n\n @functools.wraps\n def _():\n return f(overrides)\n\n return f(*args, **kwargs)",
"def customize_fields(self, fields):\n\n for field in fields.values():\n\n field_type = type(field.field)\n\n if field_type is List or field_type is Set:\n field.widgetFactory = CheckBoxFieldWidget\n\n elif field_type is Choice:\n field.widgetFactory = RadioFieldWidget",
"def inject_overrides(self, overrides):\n for run in self.benchmarks:\n _ = [run.update_spec(key, value) for key, value in overrides.items()]",
"def addattrs(field, my_attrs):\n my_attrs = my_attrs.split(',')\n my_attrs = dict([attr.split('=') for attr in my_attrs])\n return field.as_widget(attrs=my_attrs)",
"def apply(self, attrs=None, kattrs=None, merge=False):\n for attr in attrs:\n kattrs = kattrs or {}\n # Treat objects as assigned to their name\n if hasattr(attr, \"__name__\"):\n kattrs[attr.__name__] = attr\n else:\n kattrs[attr] = inspect.getattr_static(self.source, attr)\n for attr, value in kattrs.items():\n old_value = inspect.getattr_static(self.target, attr, None)\n # If callable, preserve old func\n if callable(value) and callable(old_value):\n # Prevent duplicate patching\n if value in patchy_records:\n continue\n patchy_records[value] = old_value\n\n # Merge collections and classes instead of replacing\n if merge:\n if isinstance(old_value, abc.Container):\n if isinstance(value, abc.Mapping) and isinstance(old_value, abc.MutableMapping):\n old_value.update(value)\n logger.info('Merging mapping {mod}.{attr}'.format(mod=self.target.__name__, attr=attr))\n elif isinstance(value, abc.Sequence) and isinstance(old_value, abc.MutableSequence):\n old_value.extend(value)\n logger.info('Merging sequence {mod}.{attr}'.format(mod=self.target.__name__, attr=attr))\n elif isinstance(value, abc.Set) and isinstance(old_value, abc.MutableSet):\n old_value.update(value)\n logger.info('Merging set {mod}.{attr}'.format(mod=self.target.__name__, attr=attr))\n else:\n setattr(self.target, attr, value)\n logger.info(\"Couldn't merge collection {target}.{attr}, replaced instead\".format(\n target=self.target.__name__,\n attr=attr))\n continue\n elif isinstance(old_value, type):\n logger.info('Merging class for {target}.{attr}'.format(\n target=self.target.__name__, attr=attr))\n self.cls(old_value, value).auto()\n continue\n logger.info('Setting value {target}.{attr}'.format(target=self.target.__name__, attr=attr))\n # Apply patched value\n setattr(self.target, attr, value)",
"def _override(config, overrides):\n for key, value in overrides.iteritems():\n if key not in config:\n raise KeyError(\"Unrecognized parameter: %s\" % key)\n config[key] = value",
"def copy(self, **overrides: Any) -> Annotable:\n this = copy(self)\n for name, value in overrides.items():\n setattr(this, name, value)\n return this",
"def merge_attrs(self):\n for aid in self.attrs:\n new_val = self.attrs[aid]\n if aid in self.attributes:\n if ('value' in self.attributes[aid] and\n self.attributes[aid]['value'] != new_val):\n pass\n # print \"Updating attribute %s[%s] %s -> %s\" % (\n # self.name, aid, self.attributes[aid]['value'], new_val)\n else:\n # print \"** Warning: non-declaired attribute %s['%s'] set to:\\n'%s'\" % (\n # self.name, aid, new_val)\n self.remember_custom_attribute(self.name, aid, new_val)\n self.attributes[aid] = {}\n self.attributes[aid]['nv'] = new_val",
"def _calculate_options(self, options, option_overrides):\n _options = {}\n _options.update(WidgetSettings.OPTIONS)\n _options.update(options if isinstance(options, dict) else {})\n if 'dateFormat' in _options and 'altFormat' not in _options:\n _options['altFormat'] = _options.pop('dateFormat')\n _options.update(option_overrides)\n self.options = _options"
] | [
"0.58639014",
"0.58119094",
"0.57164145",
"0.5690681",
"0.56085473",
"0.53666663",
"0.53194547",
"0.53071195",
"0.52736515",
"0.5261119",
"0.5206284",
"0.51718056",
"0.5151828",
"0.51367855",
"0.507694",
"0.5039261",
"0.50124925",
"0.49915925",
"0.49908444",
"0.49711272",
"0.49383122",
"0.49282834",
"0.4928231",
"0.48955324",
"0.48876435",
"0.48784885",
"0.48756525",
"0.4867156",
"0.48571402",
"0.4843604"
] | 0.6050348 | 0 |
Applies expected measurements for a textarea form input. | def test_prep_textarea(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def form_TextAreaColsAndRows(request):\n schema = schemaish.Structure()\n schema.add('textAreaCustom', schemaish.String())\n\n form = formish.Form(schema, 'form')\n form['textAreaCustom'].widget = formish.TextArea(cols=20,rows=4)\n return form",
"def calculate_char_in_textarea(context):\n context['max_length'] = {}\n context['remaining_length'] = {}\n introduction_max_length = Introduction._meta.get_field('introduction').max_length\n context['max_length']['introduction'] = introduction_max_length\n\n if context['introduction']:\n context['remaining_length']['introduction'] = (\n introduction_max_length - len(context['introduction'].introduction)\n )\n else:\n context['remaining_length']['introduction'] = introduction_max_length\n\n statement_max_length = Statement._meta.get_field('statement').max_length\n context['max_length']['statement'] = statement_max_length\n\n if context['statement']:\n context['remaining_length']['statement'] = (\n statement_max_length - len(context['statement'].statement)\n )\n else:\n context['remaining_length']['statement'] = statement_max_length\n\n experience_max_length = Experience._meta.get_field('experience').max_length\n context['max_length']['experience'] = experience_max_length\n\n work_detail_max_length = Work._meta.get_field('detail').max_length\n context['max_length']['work_detail'] = work_detail_max_length\n\n return context",
"def test_textlines_field():",
"def test_text_field():",
"def test_spaces(self):\n self.assertTrue(validate_measure_input('1 ', self.measures))\n self.assertFalse(validate_measure_input('1 1', self.measures))",
"def textArea(name, value=\"\", disabled=\"\", cols=\"80\", rows=\"8\"):\n log.debug(u\"textArea %s\" % value)\n html = u'<textarea name=\"%s\" ' % name\n html += 'id = \"%s\"' % name\n if disabled:\n html += u'disabled=\"disabled\" '\n html += u'style=\\\"width:100%\"'\n html += u'cols=\"%s\" rows=\"%s\">' %(cols, rows)\n html += value\n html += u'</textarea><br/>'\n return html",
"def handle_calculate(self, text_input):\n self.output_text = f'{float(self.get_valid_value(text_input)) * MILE_TO_KM_FACTOR:.3f}'",
"def considerAreasText(self):\n global consider_area_text\n consider_area_text = MathTex(\"\\\\text{Consider the following areas:}\").scale(0.8).shift(RIGHT*3.55)\n\n self.play(Write(consider_area_text))\n self.play(consider_area_text.animate.to_edge(UP))",
"def test_converter_area(self):\n \n input_values = [4,0,1,'20']\n\n output = []\n expected_result = \"Result: 20 Square meter(m^2) equals to 215.29 Square foot(ft^2)\"\n\n def mock_input(s):\n output.append(s)\n return input_values.pop(0)\n\n mp2.input = mock_input\n mp2.print = lambda s:output.append(s)\n mp2.main()\n self.assertEqual(output[-1],expected_result)",
"def clear_text_area(text_area_no: int) -> None:\n if text_area_no == 1:\n utterances['P1'].clear()\n timings['P1'] = 0\n elif text_area_no == 2:\n utterances['S1'].clear()\n timings['S1'] = 0\n elif text_area_no == 3:\n utterances['S2'].clear()\n timings['S2'] = 0\n elif text_area_no == 4:\n utterances['S3'].clear()\n timings['S3'] = 0\n elif text_area_no == 5:\n utterances['S4'].clear()\n timings['S4'] = 0\n elif text_area_no == 6:\n utterances['S4'].clear()\n timings['S4'] = 0\n elif text_area_no == 7:\n utterances['C1'].clear()\n timings['C1'] = 0\n elif text_area_no == 8:\n utterances['C2'].clear()\n timings['C2'] = 0\n return None",
"def trig_measure(self,event):\n unitComboboxValue = self.distanceUnitCombobox.GetValue()\n delay = server.getdelay()\n distance = data.measure(delay)\n if unitComboboxValue == \"m\":\n self.distance_txtBox.SetValue('{:0.2f}'.format(distance))\n elif unitComboboxValue == \"cm\":\n self.distance_txtBox.SetValue('{:0.2f}'.format((distance)*100))\n elif unitComboboxValue == \"in\":\n self.distance_txtBox.SetValue('{:0.2f}'.format((distance)*39.370))\n elif unitComboboxValue == \"ft\":\n self.distance_txtBox.SetValue('{:0.2f}'.format((distance)/0.3048))\n self.distance_txtBox.SetValue(str(distance))\n self.propdelay_txtBox.SetValue(str(delay*1000.0))\n '''\n try: \n delay = server.getdelay()\n data.measure(delay)\n if unitComboboxValue == \"m\":\n self.distance_txtBox.SetValue(str(delay*data.speed))\n elif unitComboboxValue == \"cm\":\n self.distance_txtBox.SetValue(str((delay*data.speed)*100))\n elif unitComboboxValue == \"in\":\n self.distance_txtBox.SetValue(str((delay*data.speed)*39.370))\n elif unitComboboxValue == \"ft\":\n self.distance_txtBox.SetValue(str((delay*data.speed)/0.3048))\n\n self.distance_txtBox.SetValue(str(delay*data.speed))\n self.propdelay_txtBox.SetValue(str(delay*1000.0))\n except ServerError:\n print \"Error connecting to device\"\n '''",
"def form_TextAreaStrip(request):\n schema = schemaish.Structure()\n schema.add('textAreaStrip', schemaish.String())\n\n form = formish.Form(schema, 'form')\n form['textAreaStrip'].widget = formish.TextArea(strip=True)\n return form",
"def lala(self):\n\n var = str(self.lineEdit.text())\n self.layout.addWidget(self.textEdit)\n self.layout.addWidget(self.button1)\n\n self.textEdit.document().setPlainText(nuke_info(var))\n\n font = self.textEdit.document().defaultFont()\n fontMetrics = QFontMetrics(font)\n textSize = fontMetrics.size(0, self.textEdit.toPlainText())\n\n w = textSize.width() + 10\n h = textSize.height() + 10\n self.resize(800, h * 3)\n if self.height() <= 350:\n self.resize(800, 350)\n else:\n pass\n self.textEdit.setReadOnly(True)\n self.setMinimumHeight(350)\n self.setMaximumHeight(700)",
"def __init__(self, *args, **kwargs):\n super(MonkeyTyperForm, self).__init__(*args, **kwargs)\n self.fields['typedField'].widget = forms.Textarea(attrs={'cols': self.instance.dieImage.bitWidth+2,\n 'rows': self.instance.dieImage.bitHeight+2,\n 'style': 'font-family:monospace;'})",
"def resizeEvent(self, event):\r\n menu_bar_height = self.menuBar().height()\r\n text_editor_width = self.width()\r\n text_editor_height = self.height()\r\n toolbar_height = self.file_toolbar.height()\r\n statusbar_height = self.statusBar.height()\r\n\r\n self.text_area.setGeometry(\r\n 0, \r\n menu_bar_height + toolbar_height,\r\n text_editor_width,\r\n text_editor_height - menu_bar_height - toolbar_height - statusbar_height\r\n )",
"def convert_area(self, event):\n try:\n #Compare other unit to one unit(square meters)\n current_value, current_unit = float(\"0\" + str(self.v.get())), self.dropdown.get()\n unit_comp = {\"acres\": 4046.8564224, \"ares\" :100.0, \"circular inches\": 0.0005067, \"hectares\": 10000.0, \"hides\": 485000.0, \"roods\": 1011.7141056, \"square centimeters\": 0.0001, \"square feet(US & UK)\": 0.092803, \"square feet(US survey)\": 0.092803, \"square inches\": 0.000645, \"square kilometers\": 1000000.0, \"square meters\": 1.0, \"square miles\": 2589988.110336, \"square millimeters\": 0.000001, \"square of timber\": 9.280304, \"square rods or poles\": 25.29285264, \"square yards\": 0.83612736, \"townships\": 93239571.972}\n value_comp, printer = current_value * unit_comp[current_unit], \"\"\n unit_list = sorted(unit_comp.keys())\n unit_list.remove(current_unit)\n for unit in unit_list:\n printer += \"To %s \" % unit + \" \" * (max([len(i) for i in unit_list]) - len(unit)) + str(value_comp / unit_comp[unit]) + [\"\", \"\\n\"][unit_list[-1] != unit]\n except ValueError: #In case user enter the other type of value, not Int or Float\n printer = \"Value is invalid.\"\n self.print_text(printer)",
"def test_form_inputs(self):\n self.assertContains(self.response, '<input', 4)\n self.assertContains(self.response, 'type=\"text\"', 1)\n self.assertContains(self.response, 'type=\"password\"', 2)",
"def test_search_form_terms_max(self):\n form = SearchForm()\n max_length = form.fields['terms_en'].max_length\n min_length = form.fields['terms_en'].min_length\n self.assertEqual(max_length, 50)\n self.assertEqual(min_length, 1)",
"def test_only_correct_widget_classes(self):\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed = self.get_allowed_width_fields()\n reject_fields = {name: field for name, field in self.form.fields.items() if name not in allowed}\n expected = {}\n actual = self.form.determine_label_width(reject_fields)\n self.assertEqual(expected, actual)\n self.form.adjust_label_width = original_setting",
"def test_editor(self):\n # This checks for a correct vlaue.\n with unittest.mock.patch('builtins.input', return_value='Snow'):\n user_date, title, minutes, notes, stop = self.ec.editor(self.\n ec.entry)\n self.assertEqual(user_date, '01/04/1995')\n self.assertEqual(title, 'Snow')\n self.assertEqual(minutes, 15)\n self.assertEqual(notes, 'Snow')\n self.assertFalse(stop)\n # This checks for an incorrect vlaue.\n with unittest.mock.patch('builtins.input', return_value='q'):\n user_date, title, minutes, notes, stop = self.ec.editor(self.\n ec.entry)\n self.assertFalse(stop)",
"def _calculate_feedback(self):\r\n age = self.age_field.value()\r\n height_cm = self.height_field.value()\r\n weight_kg = self.weight_field.value()\r\n body_fat = self.bodyFat_field.value()\r\n male = bool(self.gender_combobox.currentIndex())\r\n\r\n if self._mode != 'metric':\r\n height_cm *= 2.54\r\n weight_kg *= 0.454\r\n\r\n document = getWeightLogDocument(height_cm, weight_kg, age, body_fat, male, None, 1.2)\r\n self.feedback_field.setHtml(document)",
"def capture_user_input(self):\n\n self.ratings[self.current_unit_id] = self.UI.get_ratings()\n self.notes[self.current_unit_id] = self.UI.user_notes",
"def on_submit(self, text):\n self.pp = [float(i.text) for i in self.text_boxes]\n self.pp_values = self.pp.copy()\n self.pp_mapping()\n self.redraw()",
"def test_rectangle_area(self):\n self.assertEqual(12, rectangle_area(\n self.values['base'], self.values['height']))",
"def test_prep_overrides(self):\n original_data = self.form.data\n test_data = original_data.copy()\n test_data._mutable = False\n self.form.data = test_data # copied only to allow tear-down reverting to original.\n original_fields = self.form.fields\n test_fields = original_fields.copy()\n self.form.fields = test_fields # copied to allow tear-down reverting to original.\n original_get_overrides = self.form.get_overrides\n def replace_overrides(): return self.formfield_attrs_overrides\n self.form.get_overrides = replace_overrides\n original_alt_field_info = getattr(self.form, 'alt_field_info', None)\n self.form.alt_field_info = {}\n overrides = self.formfield_attrs_overrides.copy()\n DEFAULT = overrides.pop('_default_')\n expected_attrs = {}\n for name, field in test_fields.items():\n attrs = field.widget.attrs.copy()\n if isinstance(field.widget, (RadioSelect, CheckboxSelectMultiple, CheckboxInput, )):\n pass # update if similar section in prep_fields is updated.\n attrs.update(overrides.get(name, {}))\n # TODO: setup structure for using default or defined version for all CharFields.\n no_resize = overrides.get(name, {}).pop('no_size_override', False)\n no_resize = True if isinstance(field.widget, (HiddenInput, MultipleHiddenInput)) else no_resize\n if no_resize:\n expected_attrs[name] = attrs\n continue # None of the following size overrides are applied for this field.\n if isinstance(field.widget, Textarea):\n width_attr_name = 'cols'\n default = DEFAULT.get('cols', None)\n display_size = attrs.get('cols', None)\n if 'rows' in DEFAULT:\n height = attrs.get('rows', None)\n height = min((DEFAULT['rows'], int(height))) if height else DEFAULT['rows']\n attrs['rows'] = str(height)\n if default: # For textarea, we always override. The others depend on different conditions.\n display_size = display_size or default\n display_size = min((int(display_size), int(default)))\n elif issubclass(field.__class__, CharField):\n width_attr_name = 'size' # 'size' is only valid for input types: email, password, tel, text\n default = DEFAULT.get('size', None) # Cannot use float(\"inf\") as an int.\n display_size = attrs.get('size', None)\n else: # This field does not have a size setting.\n width_attr_name, default, display_size = None, None, None\n input_size = attrs.get('maxlength', None)\n possible_size = [int(ea) for ea in (display_size or default, input_size) if ea]\n # attrs['size'] = str(int(min(float(display_size), float(input_size)))) # Can't use float(\"inf\") as an int.\n if possible_size and width_attr_name:\n attrs[width_attr_name] = str(min(possible_size))\n expected_attrs[name] = attrs\n # Expected:\n # formfield_attrs_overrides = {\n # '_default_': {'size': 15, 'cols': 20, 'rows': 4, },\n # 'first': {'maxlength': 191, 'size': 20, },\n # 'second': {'maxlength': 2, }, # 'size': 2,\n # 'last': {'maxlength': 2, 'size': 5, },\n # }\n result_fields = self.form.prep_fields()\n result_attrs = {name: field.widget.attrs.copy() for name, field in result_fields.items()}\n first_maxlength = expected_attrs['first']['maxlength'] # overrides['first']['maxlength']\n first_size = expected_attrs['first']['size'] # overrides['first']['size']\n second_maxlength = expected_attrs['second']['maxlength'] # overrides['second']['maxlength']\n last_maxlength = expected_attrs['last']['maxlength'] # overrides['last']['maxlength']\n last_size = expected_attrs['last']['size'] # overrides['last']['size']\n\n self.assertEqual(first_maxlength, result_fields['first'].widget.attrs.get('maxlength', None))\n self.assertEqual(first_size, result_fields['first'].widget.attrs.get('size', None))\n self.assertEqual(second_maxlength, result_fields['second'].widget.attrs.get('maxlength', None))\n self.assertEqual(last_maxlength, result_fields['last'].widget.attrs.get('maxlength', None))\n self.assertEqual(last_size, result_fields['last'].widget.attrs.get('size', None))\n for key, val in expected_attrs.items():\n self.assertEqual(val, result_attrs[key])\n self.assertDictEqual(expected_attrs, result_attrs)\n\n self.form.alt_field_info = original_alt_field_info\n if original_alt_field_info is None:\n del self.form.alt_field_info\n self.form.fields = original_fields\n self.form.data = original_data\n self.form.get_overrides = original_get_overrides",
"def measurement_length_testing(self, shape, measurements):\n if shape == 'circle':\n if len(measurements) == 0:\n error_msg = 'There should be at least 1 measurement for shape circle: {}'.format(measurements)\n return error_msg\n\n if shape == 'rectangle':\n if len(measurements) <= 1:\n error_msg = 'There should be at least 2 measurement for shape rectangle: {}'.format(measurements)\n return error_msg",
"def text_changed(self, new_text):\n if resizing:\n text_width = self.fm.width(new_text)\n new_width = text_width + 15 # add some buffer\n self.setFixedWidth(min(\n max(new_width, self.base_width),\n self.max_width\n ))\n self.node_gui.update_shape()\n self.on_widget_val_changed(self.val)",
"def text_changed(self, new_text):\n if resizing:\n text_width = self.fm.width(new_text)\n new_width = text_width + 15 # add some buffer\n self.setFixedWidth(min(\n max(new_width, self.base_width),\n self.max_width\n ))\n self.node_gui.update_shape()\n self.on_widget_val_changed(self.val)",
"def test_determine_label_width(self):\n original_setting = self.form.adjust_label_width\n self.form.adjust_label_width = True\n allowed_fields = self.get_allowed_width_fields()\n test_fields = allowed_fields.copy() # TODO: ? Try an input with some double and some single column rows?\n labels = [field.label or pretty_name(name) for name, field in test_fields.items()]\n full_width = (max(len(ea) for ea in labels) + 1) // 2 # * 0.85 ch\n word_width = max(len(word) for label in labels for word in label.split()) // 2\n expected_width = full_width if full_width < self.form.max_label_width else word_width\n expected_attrs = {'style': 'width: {}rem; display: inline-block'.format(expected_width)}\n expected_attrs = {name: expected_attrs for name in list(test_fields.keys())}\n actual_attrs = self.form.determine_label_width(self.form.fields)\n\n self.assertLess(word_width, self.form.max_label_width)\n self.assertEqual(expected_attrs, actual_attrs)\n\n self.form.adjust_label_width = original_setting",
"def test_validate_input_valid(self):\n final_config = self.dtm1.validate_input('00001111')\n nose.assert_equal(final_config[0], 'q4')\n nose.assert_equal(str(final_config[1]), 'TMTape(\\'xxxxyyyy.\\')')"
] | [
"0.5577088",
"0.5400031",
"0.52361315",
"0.50759006",
"0.5063092",
"0.50100446",
"0.4869042",
"0.48271298",
"0.4776579",
"0.47435308",
"0.47408935",
"0.47304356",
"0.46997303",
"0.4672879",
"0.46539026",
"0.46504828",
"0.46376187",
"0.46081394",
"0.4606236",
"0.46027762",
"0.45997232",
"0.45634508",
"0.45387882",
"0.45280713",
"0.4526476",
"0.45218813",
"0.4438353",
"0.4438353",
"0.44290972",
"0.44050807"
] | 0.66720796 | 0 |
The prep_fields method is called by _html_output because of definition in FormOverrideMixIn. | def test_prep_fields_called_html_output(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_make_fieldsets_uses_prep_fields(self):\n original_called_prep_fields = self.form.called_prep_fields = False\n full_fieldsets = self.form.make_fieldsets()\n\n self.assertFalse(original_called_prep_fields)\n self.assertIsInstance(full_fieldsets, (list, tuple))\n self.assertIsNotNone(getattr(self.form, '_fieldsets', None))\n self.assertTrue(self.form.called_prep_fields)\n\n self.form.called_prep_fields = original_called_prep_fields",
"def _replace_fields(self):\n for name, value in self._cleaned_data.items():\n setattr(self, name, value)",
"def test_prep_fields(self):\n pass",
"def test_overall_make_fieldsets(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'not_third',\n 'not_fourth',\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n (None, {\n 'position': None,\n # 'modifiers': ['password_display', ],\n 'fields': [\n # ('password1', 'password2', ),\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def _generate_form_fields(self):\n params = list(filter(lambda x: (x.precedence is None or x.precedence >= 0) and not x.constant,\n self.param.params().values()))\n for p in sorted(params, key=lambda p: p.precedence or 9999):\n # TODO: Pass p.__dict__ as second argument instead of arbitrary\n p_name = p.name\n\n # Preserve param tuple type.\n if self.data:\n if isinstance(getattr(self.param, p.name), tuple):\n p.default = tuple(self.data.getlist(p.name))\n\n # Preserve initial options for Selector\n if isinstance(self.param.params()[p_name], (param.FileSelector, param.MultiFileSelector)):\n p.default = \"\"\n\n self.fields[p_name] = self.widget_map[type(p)](self.param, p, p.name)\n self.fields[p_name].label = p.name.replace(\"_\", \" \").title()\n if self.read_only is None:\n widget_attribute = {'class': 'form-control'}\n else:\n # TODO: Should this be readonly instead of disable?\n widget_attribute = {'class': 'form-control', 'disabled': self.read_only}\n self.fields[p_name].widget.attrs.update(widget_attribute)\n self.fields[p_name].required = not self.param.params()[p_name].allow_None\n self.fields[p_name].disabled = self.param.params()[p_name].constant\n self.fields[p_name].help_text = self.param.params()[p_name].doc\n # self.fields = self.base_fields",
"def test_prep_overrides(self):\n original_data = self.form.data\n test_data = original_data.copy()\n test_data._mutable = False\n self.form.data = test_data # copied only to allow tear-down reverting to original.\n original_fields = self.form.fields\n test_fields = original_fields.copy()\n self.form.fields = test_fields # copied to allow tear-down reverting to original.\n original_get_overrides = self.form.get_overrides\n def replace_overrides(): return self.formfield_attrs_overrides\n self.form.get_overrides = replace_overrides\n original_alt_field_info = getattr(self.form, 'alt_field_info', None)\n self.form.alt_field_info = {}\n overrides = self.formfield_attrs_overrides.copy()\n DEFAULT = overrides.pop('_default_')\n expected_attrs = {}\n for name, field in test_fields.items():\n attrs = field.widget.attrs.copy()\n if isinstance(field.widget, (RadioSelect, CheckboxSelectMultiple, CheckboxInput, )):\n pass # update if similar section in prep_fields is updated.\n attrs.update(overrides.get(name, {}))\n # TODO: setup structure for using default or defined version for all CharFields.\n no_resize = overrides.get(name, {}).pop('no_size_override', False)\n no_resize = True if isinstance(field.widget, (HiddenInput, MultipleHiddenInput)) else no_resize\n if no_resize:\n expected_attrs[name] = attrs\n continue # None of the following size overrides are applied for this field.\n if isinstance(field.widget, Textarea):\n width_attr_name = 'cols'\n default = DEFAULT.get('cols', None)\n display_size = attrs.get('cols', None)\n if 'rows' in DEFAULT:\n height = attrs.get('rows', None)\n height = min((DEFAULT['rows'], int(height))) if height else DEFAULT['rows']\n attrs['rows'] = str(height)\n if default: # For textarea, we always override. The others depend on different conditions.\n display_size = display_size or default\n display_size = min((int(display_size), int(default)))\n elif issubclass(field.__class__, CharField):\n width_attr_name = 'size' # 'size' is only valid for input types: email, password, tel, text\n default = DEFAULT.get('size', None) # Cannot use float(\"inf\") as an int.\n display_size = attrs.get('size', None)\n else: # This field does not have a size setting.\n width_attr_name, default, display_size = None, None, None\n input_size = attrs.get('maxlength', None)\n possible_size = [int(ea) for ea in (display_size or default, input_size) if ea]\n # attrs['size'] = str(int(min(float(display_size), float(input_size)))) # Can't use float(\"inf\") as an int.\n if possible_size and width_attr_name:\n attrs[width_attr_name] = str(min(possible_size))\n expected_attrs[name] = attrs\n # Expected:\n # formfield_attrs_overrides = {\n # '_default_': {'size': 15, 'cols': 20, 'rows': 4, },\n # 'first': {'maxlength': 191, 'size': 20, },\n # 'second': {'maxlength': 2, }, # 'size': 2,\n # 'last': {'maxlength': 2, 'size': 5, },\n # }\n result_fields = self.form.prep_fields()\n result_attrs = {name: field.widget.attrs.copy() for name, field in result_fields.items()}\n first_maxlength = expected_attrs['first']['maxlength'] # overrides['first']['maxlength']\n first_size = expected_attrs['first']['size'] # overrides['first']['size']\n second_maxlength = expected_attrs['second']['maxlength'] # overrides['second']['maxlength']\n last_maxlength = expected_attrs['last']['maxlength'] # overrides['last']['maxlength']\n last_size = expected_attrs['last']['size'] # overrides['last']['size']\n\n self.assertEqual(first_maxlength, result_fields['first'].widget.attrs.get('maxlength', None))\n self.assertEqual(first_size, result_fields['first'].widget.attrs.get('size', None))\n self.assertEqual(second_maxlength, result_fields['second'].widget.attrs.get('maxlength', None))\n self.assertEqual(last_maxlength, result_fields['last'].widget.attrs.get('maxlength', None))\n self.assertEqual(last_size, result_fields['last'].widget.attrs.get('size', None))\n for key, val in expected_attrs.items():\n self.assertEqual(val, result_attrs[key])\n self.assertDictEqual(expected_attrs, result_attrs)\n\n self.form.alt_field_info = original_alt_field_info\n if original_alt_field_info is None:\n del self.form.alt_field_info\n self.form.fields = original_fields\n self.form.data = original_data\n self.form.get_overrides = original_get_overrides",
"def prepare(self, form):\n \n return form",
"def test_prep_field_properties(self):\n original_data = self.form.data\n test_data = original_data.copy()\n # modify values in data\n test_data._mutable = False\n self.form.data = test_data\n original_fields = self.form.fields\n test_fields = original_fields.copy()\n # modify fields\n self.form.fields = test_fields\n test_fields_info = {name: field.__dict__.copy() for name, field in test_fields.items()}\n original_get_overrides = self.form.get_overrides\n def skip_overrides(): return {}\n self.form.get_overrides = skip_overrides\n original_alt_field_info = getattr(self.form, 'alt_field_info', None)\n self.form.alt_field_info = self.alt_field_info\n self.form.test_condition_response = True\n expected_fields_info = test_fields_info.copy()\n result_fields = self.form.prep_fields()\n result_fields_info = {name: field.__dict__.copy() for name, field in result_fields.items()}\n modified_info = self.alt_field_info['alt_test_feature']\n first_label = modified_info['first']['label']\n first_initial = modified_info['first']['initial']\n last_initial = modified_info['last']['initial']\n for name, opts in modified_info.items():\n expected_fields_info[name].update(opts)\n\n self.assertEqual(first_label, result_fields['first'].label)\n self.assertEqual(first_initial, result_fields['first'].initial)\n self.assertEqual(last_initial, result_fields['last'].initial)\n for key, val in expected_fields_info.items():\n self.assertEqual(val, result_fields_info[key])\n self.assertDictEqual(expected_fields_info, result_fields_info)\n\n self.form.test_condition_response = False\n self.form.alt_field_info = original_alt_field_info\n if original_alt_field_info is None:\n del self.form.alt_field_info\n self.form.fields = original_fields\n self.form.data = original_data\n self.form.get_overrides = original_get_overrides",
"def set_up_fields(self, fields):\n self.fields = {\n 'name': self.name,\n 'email': self.email\n }\n for key in fields.keys():\n # special keys first, not to be used in the template\n if key.upper() == 'CC':\n self.is_cc = fields[key]\n elif key.upper() == 'BCC':\n self.is_bcc = fields[key]\n else:\n self.fields[key] = fields[key]",
"def _initFields(self):\n pass",
"def form_tweaks(self):\n pass",
"def test_make_fieldsets_outcome_order(self):\n original_fieldsets = self.form.fieldsets\n self.form.fieldsets = (\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }),\n ('Non_Fields', {\n 'position': 3,\n 'fields': [\n 'non-field_name',\n 'not_a_field'\n ],\n }),\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'position': None,\n 'fields': [\n 'generic_field',\n 'bool_field',\n 'single_check'\n ]\n }),\n ('address', {\n 'classes': ('collapse', 'address', ),\n # 'modifiers': ['address', 'prep_country_fields', ],\n 'position': 'end',\n 'fields': [\n 'billing_address_1',\n 'billing_address_2',\n ('billing_city', 'billing_country_area', 'billing_postcode', ),\n ],\n }), )\n fieldsets = [(label, deepcopy(opts)) for label, opts in self.form.fieldsets if label != 'Non_Fields']\n fieldsets[0], fieldsets[1] = fieldsets[1], fieldsets[0]\n remaining_fields = self.form.fields.copy()\n assigned_field_names = flatten([flatten(opts['fields']) for fieldset_label, opts in fieldsets])\n unassigned_field_names = [name for name in remaining_fields if name not in assigned_field_names]\n remaining_fields.pop('hide_field')\n address_fieldset = fieldsets.pop()\n opts = {'modifiers': 'prep_remaining', 'position': 'remaining', 'fields': unassigned_field_names}\n fieldsets.append((None, opts))\n fieldsets.append(address_fieldset)\n for fieldset_label, opts in fieldsets:\n opts['field_names'] = flatten(opts['fields'])\n rows, column_count = [], 0\n for names in opts['fields']:\n if isinstance(names, str):\n names = [names]\n columns = {name: self.form.fields[name] for name in names if name in remaining_fields}\n # TODO: Remove hidden or otherwise excluded fields.\n column_count = max(column_count, len(columns))\n if columns:\n rows.append(columns)\n opts['rows'] = rows\n opts['column_count'] = column_count\n self.form.make_fieldsets()\n actual_fieldsets = self.form._fieldsets\n self.assertEqual(len(fieldsets), 5)\n self.assertEqual(len(fieldsets), len(actual_fieldsets))\n count = 0\n for expect, got in zip(fieldsets, actual_fieldsets):\n labels = str(got[0]) if expect[0] == got[0] else ' & '.join(str(ea) for ea in (expect[0], got[0]))\n expect_row_names = flatten([list(ea.keys()) for ea in expect[1]['rows']])\n actual_row_names = flatten([list(ea.keys()) for ea in got[1]['rows']])\n row_names = str(expect_row_names) + '\\n' + str(actual_row_names)\n message = f\"Fieldset # {count} named {labels} expected then got: \\n{row_names}\"\n self.assertEqual(expect, got, message)\n count += 1\n self.assertEqual(fieldsets, actual_fieldsets)\n\n self.form.fieldsets = original_fieldsets",
"def make_fields(self):\n for name, prop in self.edit:\n instance_value = self.model.get(name)\n post_value = self.data[name] if (self.data and self.data.has_key(name)) else instance_value\n form_field_class = self.get_field_type(prop)\n form_field = form_field_class(model=self.model, property=prop, name=name, instance_value=instance_value, post_value=post_value)\n self.add(form_field)",
"def intialize_from_fields(self):\n raise NotImplementedError",
"def test_prep_country_fields(self):\n original_flag = self.form.country_optional\n self.form.country_optional = True\n original_fields = self.form.fields\n original_removed = getattr(self.form, 'removed_fields', None)\n original_computed = getattr(self.form, 'computed_fields', None)\n self.form.fields = original_fields.copy()\n if original_removed is not None:\n self.form.removed_fields = original_removed.copy()\n if original_computed is not None:\n self.form.computed_fields = original_computed.copy()\n remaining = original_fields.copy()\n opts, field_rows = {'fake_opts': 'fake', 'fields': ['nope']}, [{'name': 'assigned_field'}]\n args = ['arbitrary', 'input', 'args']\n kwargs = {'test_1': 'data_1', 'test_2': 'data_2'}\n field_names = (self.form.country_field_name, 'country_flag', )\n if not any(remaining.get(name, None) for name in field_names):\n fix_fields = {name: self.get_missing_field(name) for name in field_names if name not in remaining}\n remaining.update(fix_fields)\n expected_add = {name: remaining[name] for name in field_names if name in remaining}\n expected_field_rows = field_rows.copy()\n expected_field_rows.append(expected_add)\n expected_remaining = {name: field for name, field in remaining.items() if name not in expected_add}\n expected_opts = deepcopy(opts)\n expected_opts['fields'].append(field_names)\n\n sent = (opts, field_rows, remaining, *args)\n r_opts, r_rows, r_remaining, *r_args, r_kwargs = self.form.prep_country_fields(*sent, **kwargs)\n self.assertEqual(expected_opts, r_opts)\n self.assertEqual(expected_field_rows, r_rows)\n self.assertEqual(expected_remaining, r_remaining)\n self.assertEqual(args, r_args)\n self.assertEqual(kwargs, r_kwargs)\n\n self.form.country_optional = original_flag\n self.form.fields = original_fields\n if original_removed is not None:\n self.form.removed_fields = original_removed\n if original_computed is not None:\n self.form.computed_fields = original_computed",
"def test_pass_through_prep_country_fields(self):\n original_flag = self.form.country_optional\n self.form.country_optional = False # True\n original_fields = self.form.fields\n self.form.fields = original_fields.copy()\n remaining_fields = original_fields.copy()\n opts, field_rows = {'fake_opts': 'fake'}, [{'name': 'assigned_field'}]\n args = ['arbitrary', 'input', 'args']\n kwargs = {'test_1': 'data_1', 'test_2': 'data_2'}\n\n expected = (opts.copy(), field_rows.copy(), remaining_fields.copy(), *args, kwargs.copy())\n actual = self.form.prep_country_fields(opts, field_rows, remaining_fields, *args, **kwargs)\n self.assertEqual(expected, actual)\n\n self.form.country_optional = original_flag\n self.form.fields = original_fields",
"def _create_and_initialise_fields(self):\n for team in self.category.breaking_teams.all():\n self.fields[self._fieldname_remark(team)] = OptionalChoiceField(choices=BreakingTeam.REMARK_CHOICES, required=False)\n try:\n self.initial[self._fieldname_remark(team)] = self._bt(team).remark\n except KeyError:\n self.initial[self._fieldname_remark(team)] = None",
"def test_missing_initial_fieldsets(self):\n original_initial_fieldsets = self.form.fieldsets\n print(\"========================= TEST UNABLE TO DELETE THE PROPERTY FOR TESTING ========================\")\n print(original_initial_fieldsets)\n print(\"--------------------------------------\")\n delattr(self.form, 'fieldsets')\n response_fieldsets = self.form.make_fieldsets()\n print(response_fieldsets)\n\n setattr(self.form, 'fieldsets', original_initial_fieldsets)",
"def test_prep_remaining(self):\n self.assertTrue(hasattr(self.form, 'prep_remaining'))\n original_fields = self.form.fields\n self.form.fields = original_fields.copy()\n remaining_fields = original_fields.copy()\n opts, field_rows = {'fake_opts': 'fake', 'fields': ['nope']}, [{'name': 'assigned_field'}]\n args = ['arbitrary', 'input', 'args']\n kwargs = {'test_1': 'data_1', 'test_2': 'data_2'}\n\n expected = (opts.copy(), field_rows.copy(), remaining_fields.copy(), *args, kwargs.copy())\n actual = self.form.prep_remaining(opts, field_rows, remaining_fields, *args, **kwargs)\n self.assertEqual(expected, actual)\n\n self.form.fields = original_fields",
"def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n placeholders = {\n 'group_id': 'group_id',\n 'first_name': 'first_name',\n 'starter': 'starter',\n 'main': 'main',\n 'dessert': 'dessert',\n 'special_diet': 'special_diet',\n 'requirements': 'requirements',\n }\n\n for field in self.fields:\n placeholder = placeholders[field]\n self.fields[field].widget.attrs['placeholder'] = placeholder\n self.fields[field].widget.attrs['class'] = 'stripe-style-input'",
"def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n placeholders = {\n \"first_name\": \"First Name\",\n \"last_name\": \"Last Name\",\n \"default_phone_num\": \"Phone Number\",\n \"default_passport_num\": \"Passport Number\",\n }\n\n self.fields[\"default_phone_num\"].widget.attrs[\"autofocus\"] = True\n for field in self.fields:\n placeholder = placeholders[field]\n self.fields[field].widget.attrs[\"placeholder\"] = placeholder\n self.fields[field].widget.attrs[\n \"class\"\n ] = \"border-black rounded-0 \\\n all-form-input\"\n self.fields[field].label = False\n self.helper = FormHelper()\n self.helper.form_tag = True\n self.helper.layout = Layout(\n Div(\n Field(\n \"first_name\",\n ),\n Field(\n \"last_name\",\n ),\n Field(\n \"default_phone_num\",\n ),\n Field(\n \"default_passport_num\",\n ),\n ),\n ButtonHolder(\n Submit(\"submit\", \"Save\", css_class=\"m-0 btn btn-outline\"),\n ),\n )",
"def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n placeholders = {\n 'company_name': 'Company name',\n 'street_address1': 'Street Address 1',\n 'street_address2': 'Street Address 2',\n 'country': 'Country or State',\n 'postcode': 'Postcode',\n 'town_or_city': 'Town or City',\n 'payment': 'Paid for number of months',\n 'setting_daystart': 'Hour when your day starts',\n 'setting_dayend': 'hour when your day ends'\n }\n\n for field in self.fields:\n if field != 'country':\n if self.fields[field].required:\n placeholder = f'{placeholders[field]} *'\n else:\n placeholder = placeholders[field]\n self.fields[field].widget.attrs['placeholder'] = placeholder\n if field == 'setting_daystart' or field == 'setting_dayend' or field == 'payment':\n self.fields[field].widget.attrs['class'] = 'width-numbers'\n else:\n self.fields[field].widget.attrs['class'] = 'profile-form-input'\n self.fields[field].label = placeholder",
"def __init__(self, *args, **kwargs):\n kwargs.pop('widget_syntax')\n\n super(TemplateForm, self).__init__( *args, **kwargs)\n print self.fields",
"def test_prep_country_fields_flat(self):\n original_flag = self.form.country_optional\n self.form.country_optional = True\n original_fields = self.form.fields\n original_removed = getattr(self.form, 'removed_fields', None)\n original_computed = getattr(self.form, 'computed_fields', None)\n self.form.fields = original_fields.copy()\n if original_removed is not None:\n self.form.removed_fields = original_removed.copy()\n if original_computed is not None:\n self.form.computed_fields = original_computed.copy()\n remaining = original_fields.copy()\n opts, field_rows = {'fake_opts': 'fake', 'fields': ['nope']}, [{'name': 'assigned_field'}]\n args = ['arbitrary', 'input', 'args']\n kwargs = {'test_1': 'data_1', 'test_2': 'data_2'}\n field_names = (self.form.country_field_name, 'country_flag', )\n if not any(remaining.get(name, None) for name in field_names):\n fix_fields = {name: self.get_missing_field(name) for name in field_names if name not in remaining}\n remaining.update(fix_fields)\n expected_add = {name: remaining[name] for name in field_names if name in remaining}\n expected_field_rows = field_rows.copy()\n expected_field_rows.append(expected_add)\n expected_remaining = {name: field for name, field in remaining.items() if name not in expected_add}\n expected_opts = deepcopy(opts)\n # expected_opts['fields'].append(field_names)\n kwargs['flat_fields'] = True\n expected_remaining.update(expected_add)\n\n sent = (opts, field_rows, remaining, *args)\n r_opts, r_rows, r_remaining, *r_args, r_kwargs = self.form.prep_country_fields(*sent, **kwargs)\n self.assertEqual(expected_opts, r_opts)\n self.assertEqual(expected_field_rows, r_rows)\n self.assertEqual(expected_remaining, r_remaining)\n self.assertEqual(args, r_args)\n self.assertEqual(kwargs, r_kwargs)\n\n self.form.country_optional = original_flag\n self.form.fields = original_fields\n if original_removed is not None:\n self.form.removed_fields = original_removed\n if original_computed is not None:\n self.form.computed_fields = original_computed\n pass",
"def __init__(self, *args, **kw):\n super(SignupFormExtra, self).__init__(*args, **kw)\n # Put the first and last name at the top\n new_order = self.fields.keyOrder[:-2]\n new_order.insert(0, 'first_name')\n new_order.insert(1, 'last_name')\n self.fields.keyOrder = new_order",
"def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n placeholders = {\n 'group_id': 'Guest Group',\n 'first_name': 'First Name',\n 'last_name': 'Last Name',\n 'address_line_1': 'Address Line 1',\n 'address_line_2': 'Address Line 2',\n 'city': 'City',\n 'county': 'County',\n 'postcode': 'Post Code',\n 'country': 'Country',\n 'email': 'Email'\n }\n\n for field in self.fields:\n if field != 'country':\n placeholder = placeholders[field]\n self.fields[field].widget.attrs['placeholder'] = placeholder\n self.fields[field].widget.attrs['class'] = 'stripe-style-input'\n self.fields[field].label = False",
"def _init_fields(self):\n if self._fields is None:\n M.mset('U', \"^\") # DBS Calls Require this\n f = self._fields = {}\n attrs = self.fieldnames = {}\n fieldid = \"0\"\n while 1:\n # Subscript 0 is field description, .1 is the title, 3 is help\n fieldid, info, title, fieldhelp = M.ddwalk(self._fileid, fieldid)\n #fieldid, info, title, fieldhelp = M.mexec(\n # \"\"\"set s0=$order(^DD(s2,s0)) Q:s0'=+s0 s s1=$G(^DD(s2,s0,0)),s3=$G(^DD(s2,s0,.1)),s4=$G(^DD(s2,s0,3))\"\"\",\n # M.INOUT(str(fieldid)), M.INOUT(\"\"), str(self._fileid), M.INOUT(\"\"), M.INOUT(\"\"))\n if fieldid == \"\" or fieldid[0] not in \"0123456789.\":\n break\n\n info = info.split(\"^\", 4) \n label = self._clean_label(info[0])\n try:\n ftype = info[1]\n except:\n ftype = None\n if ftype:\n finst = None\n for klass in FIELD_TYPES:\n if klass.isa(ftype):\n finst = f[fieldid] = klass(fieldid, label, info)\n finst.fileid = self.fileid\n finst.ownerdd = self\n attrs[label] = fieldid\n break\n if finst is None:\n print finst, \"FIELD [%s], spec [%s] was not identified\" % (label, ftype)\n continue\n finst.title = title\n finst.fieldhelp = fieldhelp\n else:\n assert finst, \"FIELD [%s] %s has no fieldspec\" % (label, info)\n\n return self._fields",
"def set_fields(self, fields: FieldDict):\n super().set_fields(fields)\n nested_field: NestedField = self.fields[self.nested]\n if not isinstance(nested_field, NestedField):\n raise TypeError(\n f'The field \"{self.nested}\" must be a NestedField instance, not \"{nested_field}\".')\n if nested_field.many:\n raise ValueError(f'The field \"{self.nested}\" can not be set as \"many=True\".')\n self.nested_field = nested_field\n # create partial methods\n self._do_dump = partial(\n getattr(self, self.dump_method),\n target=nested_field.dump_target,\n method=nested_field.dump,\n )\n self._do_load = partial(\n getattr(self, self.load_method),\n target=nested_field.load_target,\n method=nested_field.load,\n )",
"def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n placeholders = {\n 'team_name': 'Team name',\n 'planning_deadline': 'planning_deadline',\n 'coaching_rep': 'coaching_rep',\n 'min_lunchbreak': 'min_lunchbreak',\n 'min_dinnerbreak': 'min_dinnerbreak',\n 'min_paidbreak': 'min_paidbreak'\n }\n\n for field in self.fields:\n if self.fields[field].required:\n placeholder = f'{placeholders[field]} *'\n else:\n placeholder = placeholders[field]\n self.fields[field].widget.attrs['placeholder'] = placeholder\n self.fields[field].widget.attrs['class'] = 'profile-form-input'\n self.fields[field].label = False",
"def set_field_attributes(fields, errors):\n for field in fields:\n field_instance = fields[field]\n widget = field_instance.widget\n if isinstance(field_instance, forms.DateField) and isinstance(widget, forms.TextInput):\n field_instance.format = '%d/%m/%Y'\n add_class_to_widget(widget, 'date')\n widget.attrs['type'] = 'text'\n elif isinstance(field_instance, forms.DateTimeField):\n field_instance.format = '%d/%m/%Y %H:%M'\n if isinstance(widget, forms.TextInput):\n add_class_to_widget(widget, 'datetime')\n elif isinstance(widget, DatetimeInput):\n add_class_to_widget(widget.widgets[0], 'date')\n elif isinstance(field_instance, forms.FloatField) and isinstance(widget, forms.TextInput):\n add_class_to_widget(widget, 'float')\n elif isinstance(field_instance, forms.IntegerField) and isinstance(widget, forms.TextInput):\n add_class_to_widget(widget, 'int')\n elif isinstance(field_instance, forms.CharField) and isinstance(widget, forms.TextInput):\n add_class_to_widget(widget, 'char')\n\n if isinstance(widget, forms.CheckboxSelectMultiple):\n add_class_to_widget(widget, 'checkbox-multiple-select')\n\n if field in errors:\n add_class_to_widget(widget, 'with_errors')\n if 'title' not in widget.attrs:\n widget.attrs['title'] = '; '.join(errors[field])\n\n add_class_to_widget(widget, 'form-control')"
] | [
"0.68164235",
"0.6493502",
"0.63907284",
"0.63283646",
"0.6232555",
"0.62033767",
"0.6180277",
"0.61739326",
"0.6124719",
"0.60883695",
"0.60432965",
"0.6012013",
"0.59731865",
"0.5861026",
"0.58439845",
"0.5822553",
"0.5813767",
"0.5795458",
"0.57355815",
"0.5726009",
"0.5717302",
"0.57112145",
"0.57002974",
"0.56687814",
"0.5658119",
"0.56550574",
"0.5647743",
"0.5631946",
"0.56311995",
"0.56059045"
] | 0.75277853 | 0 |
Raises ImproperlyConfigured if constructor_fields property is not a list or tuple of strings. | def test_raises_on_constructor_fields_error(self):
self.form.constructor_fields = None
message = "Expected a list of field name strings for constructor_fields. "
with self.assertRaisesMessage(ImproperlyConfigured, message):
self.form.confirm_required_fields() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_construct_values_raises_for_missing_cleaned_data(self):\n constructor_fields = ('first', 'second', 'last', )\n if hasattr(self.form, 'cleaned_data'):\n del self.form.cleaned_data\n message = \"This method can only be evaluated after 'cleaned_data' has been populated. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.construct_value_from_values(constructor_fields)",
"def test_raises_on_missing_needed_fields(self):\n test_name = \"impossible_creature_not_present\"\n self.form.constructor_fields = [*self.form.constructor_fields, test_name]\n message = \"The fields for email, username, and constructor must be set in fields. \"\n self.assertNotIn(test_name, self.form.base_fields)\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.confirm_required_fields()",
"def test_construct_values_raises_for_missing_fields(self):\n message = \"There must me one or more field names to compute a value. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.construct_value_from_values()\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.construct_value_from_values('')\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.construct_value_from_values([])",
"def __init__(self, field_names=..., **kwargs) -> None:\n ...",
"def test_construct_values_raises_missing_cleaned_no_error(self):\n constructor_fields = ('first', 'second', 'last', )\n values = ['FirstValue', 'SecondValue', 'LastValue']\n cleaned_data = getattr(self.form, 'cleaned_data', {})\n cleaned_data.update(dict(zip(constructor_fields[:-1], values[:-1])))\n self.form.cleaned_data = cleaned_data\n err = \"This computed value can only be evaluated after fields it depends on have been cleaned. \"\n err += \"The field order must have the computed field after fields used for its value. \"\n with self.assertRaisesMessage(ImproperlyConfigured, err):\n self.form.construct_value_from_values(constructor_fields)",
"def __init__(self, fields):\n self.__init_handle_by_constructor__(_make.TupleType, fields)",
"def test_init_valid_field(self):\n fields = {'Conn Note': {'offset': 0,\n 'length': 20}}\n parser = top.Parser(fields=fields)\n received = parser.get_fields()\n expected = fields\n msg = 'Fields initialisation property setter/getter error.'\n self.assertEqual(received, expected, msg)",
"def test_set_non_dictionary_based_field(self):\n self.assertRaises(TypeError, self._p.set_fields, '')",
"def __init__(self, fields: Optional[List[Field]] = None) -> None:\n self.fields = [] if not fields else fields",
"def _initFields(self):\n pass",
"def intialize_from_fields(self):\n raise NotImplementedError",
"def test_construct_values_raises_on_invalid_normalize(self):\n constructor_fields = ('first', 'second', 'last', )\n values = ['first_value', 'second_value', 'last_value']\n cleaned_data = getattr(self.form, 'cleaned_data', {})\n cleaned_data.update(dict(zip(constructor_fields, values)))\n self.form.cleaned_data = cleaned_data\n normalize = 'not a valid normalize function'\n message = \"The normalize parameter must be a callable or None. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.construct_value_from_values(constructor_fields, normalize=normalize)",
"def test_DistanceMatrices_setter_too_few(self):\r\n self.assertRaises(ValueError, setattr, self.cs, 'DistanceMatrices', [])\r\n # Also test that constructor raises this error.\r\n self.assertRaises(ValueError, CorrelationStats, [])",
"def __init__(self, field_info):\n self.field_info = field_info",
"def test_raises_if_initial_fieldsets_error(self):\n original_fieldsets = self.form.fieldsets\n test_fieldsets = (\n ('Your Name', {\n 'position': 1,\n 'fields': [('first_name', 'last_name', )],\n }),\n (None, {\n 'classes': ('counting', ),\n 'position': 2,\n 'fields': [\n ('first', 'second', ),\n 'last',\n ],\n }), )\n position_missing_fieldsets = deepcopy(test_fieldsets)\n del position_missing_fieldsets[1][1]['position']\n fields_missing_fieldsets = deepcopy(test_fieldsets)\n del fields_missing_fieldsets[0][1]['fields']\n message = \"There must be 'fields' and 'position' in each fieldset. \"\n self.form.fieldsets = position_missing_fieldsets\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets()\n self.form.fieldsets = fields_missing_fieldsets\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.make_fieldsets()\n\n self.form.fieldsets = original_fieldsets",
"def __init__(self, constructors: List[Any], functions: List[Callable]):\n for constructor in constructors:\n is_valid_constructor(constructor, constructors)\n\n for func in functions:\n is_valid_function(func, constructors)\n\n self.constructors = constructors\n self.functions = functions\n\n self._build_schema_data()",
"def test_construct_values_skips_already_caught_errors(self):\n constructor_fields = ('first', 'second', 'last', )\n values = ['FirstValue', 'SecondValue', 'LastValue']\n expected = None # Normal is: '_'.join(ea for ea in values if ea).casefold()\n cleaned_data = getattr(self.form, 'cleaned_data', {})\n cleaned_data.update(dict(zip(constructor_fields[:-1], values[:-1])))\n self.form.cleaned_data = cleaned_data\n original_errors = deepcopy(self.form._errors)\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n self.form.add_error('last', 'An error for testing')\n actual = self.form.construct_value_from_values(constructor_fields)\n\n self.assertIsNone(actual)\n self.assertEqual(expected, actual)\n\n self.form._errors = original_errors",
"def from_fields(cls, field_list):\n field_dict = dict(field_list)\n return cls(**field_dict)",
"def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.fields['cd_identifier'].required = True\n self.fields['library'].required = True",
"def testConstructorValueError(self):\n test_cases = [\n 'these',\n 'are',\n 'bad',\n 'data',\n 'types',\n 'FILE',\n 'STRING',\n 'JSON',\n ]\n for bad_data_type in test_cases:\n with self.assertRaises(ValueError):\n ASCIITransportFormat(bad_data_type, '')",
"def __init__(self, name: str, fields: List[str]) -> None:\n self.name = name\n self.fields = fields",
"def __init__(self, name: str, createStepName: str, fields: str = \"\"):\n pass",
"def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.fields['first_name'].required = False\n self.fields['last_name'].required = False\n self.fields['institution'].required = False\n self.fields['institution_logo'].required = False\n self.fields['allow_notifications'].required = False",
"def __init__(self, field: str):\n super().__init__()\n self.field = field",
"def __init__(self, **kwargs):\n for type_hint in self.__fields_types__.values():\n if type_hint is ForwardRef or ForwardRef in get_args(type_hint):\n raise Warning(\"Not all type hints were evaluated.\")\n errors = []\n for name in kwargs:\n if ((getattr(self, name, None) is not None\n and name not in self.__fields_types__)\n or name in self._forbidden_fields):\n errors.append(f\" This attribute name is reserved: '{name}'.\")\n if errors:\n raise ValueError(\"\\n\" + \"\\n\".join(errors))\n for k, v in kwargs.items():\n setattr(self, k, v)",
"def __init__(self, field):\n super().__init__()\n self.field = str(field)",
"def _check_name_composing_fields(cls, **_kwargs: Any) -> List[checks.CheckMessage]:\n if not cls.name_composing_fields:\n return [\n checks.Warning(\n \"You must specify the fields that make up the name by \"\n \"listing them in name_composing_fields.\",\n obj=cls.__name__\n )\n ]\n errors = []\n for field in cls.name_composing_fields:\n try:\n get_fields_and_lookups(cls, field)\n except (exceptions.FieldDoesNotExist, exceptions.FieldError) as e:\n errors.append(\n checks.Error(\n \"Attribute 'name_composing_fields' contains invalid item: \"\n \"'%s'. %s\" % (field, e),\n obj=cls\n )\n )\n return errors",
"def __init__(self, **kwargs):\n\n for (k, v) in self._fields:\n if k in kwargs:\n self.__dict__[k] = v.validate(kwargs[k])\n self.__dict__[k] = v.default",
"def __init__(self, *args, **kwargs):\n\n self.min_length = kwargs.pop('min_length', None)\n self.max_length = kwargs.pop('max_length', None)\n self.allow_blank = kwargs.pop('allow_blank', False)\n self.allow_whitespace = kwargs.pop('allow_whitespace', False)\n\n args = list(args)\n name, type_ = self._extract_name_and_type(args, kwargs)\n if type_ is None:\n type_ = self.DEFAULT_TYPE\n\n if not misc_utils.is_subclass_or_instance(type_, String):\n raise StringColumnTypeIsInvalidError('The string column type must be '\n 'an instance or subclass of [{string}].'\n .format(string=String))\n\n if isinstance(type_, type) and self.max_length is not None:\n type_ = type_(length=self.max_length)\n\n kwargs.update(name=name, type_=type_)\n\n super().__init__(*args, **kwargs)",
"def __getinitargs__(self):\n\n return (self.admin_property_err,)"
] | [
"0.5997121",
"0.59445363",
"0.59265906",
"0.58876675",
"0.584348",
"0.57208145",
"0.5712317",
"0.5644994",
"0.55909115",
"0.54709804",
"0.532488",
"0.53136766",
"0.5304112",
"0.5294022",
"0.5268261",
"0.52323484",
"0.5202136",
"0.5167893",
"0.51547426",
"0.5135524",
"0.50840026",
"0.50778735",
"0.5074278",
"0.5035025",
"0.5031333",
"0.5014044",
"0.5006524",
"0.49907458",
"0.49760807",
"0.49581763"
] | 0.7602628 | 0 |
Raises ImproperlyConfigured if missing any fields from constructor, username, email, and flag_field. | def test_raises_on_missing_needed_fields(self):
test_name = "impossible_creature_not_present"
self.form.constructor_fields = [*self.form.constructor_fields, test_name]
message = "The fields for email, username, and constructor must be set in fields. "
self.assertNotIn(test_name, self.form.base_fields)
with self.assertRaisesMessage(ImproperlyConfigured, message):
self.form.confirm_required_fields() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, **kwargs):\n self.user_id = kwargs.get(\"user_id\")\n self.firstname = kwargs.get(\"firstname\")\n self.lastname = kwargs.get(\"lastname\")\n self.othernames = \"none\"\n self.username = kwargs.get(\"username\")\n self.email = kwargs.get(\"email\")\n self.phonenumber = kwargs.get(\"phonenumber\")\n self.is_admin = kwargs.get(\"is_admin\")\n self.password = kwargs.get(\"password\")\n self.registered_on = kwargs.get(\"registered_on\")",
"def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n ignore_fields = (\n 'about_me',\n 'romanized_first_name',\n 'romanized_last_name',\n 'postal_code',\n )\n set_fields_to_required(self, ignore_fields=ignore_fields)",
"def test_raises_on_constructor_fields_error(self):\n self.form.constructor_fields = None\n message = \"Expected a list of field name strings for constructor_fields. \"\n with self.assertRaisesMessage(ImproperlyConfigured, message):\n self.form.confirm_required_fields()",
"def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.fields['first_name'].required = False\n self.fields['last_name'].required = False\n self.fields['institution'].required = False\n self.fields['institution_logo'].required = False\n self.fields['allow_notifications'].required = False",
"def test_setup(self):\n self.assertEqual(self.form._meta.model.USERNAME_FIELD, self.form.name_for_user)\n self.assertEqual(self.form._meta.model.get_email_field_name(), self.form.name_for_email)\n self.assertIn(self.form._meta.model.get_email_field_name(), self.form.fields)\n self.assertNotIn('email_field', self.form.fields)",
"def _initFields(self):\n pass",
"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 test_raise_missing_flag_field(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_flag = self.form.USERNAME_FLAG_FIELD\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n original_errors = getattr(self.form, '_errors', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.USERNAME_FLAG_FIELD = 'Not a valid field name'\n self.form.cleaned_data = {self.form.name_for_user: 'test_username', self.form.name_for_email: 'test_email'}\n # self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n self.form._errors = None if original_errors is None else original_errors.copy()\n\n with self.assertRaises(ImproperlyConfigured):\n self.form.configure_username_confirmation()\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.USERNAME_FLAG_FIELD = original_flag\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors\n if original_cleaned_data is None:\n del self.form.cleaned_data\n if original_errors is None:\n del self.form._errors",
"def __init__(self, *args, **kwargs):\n self.captcha_required = kwargs.pop(\"captcha_required\", None)\n self.authy_required = kwargs.pop(\"authy_required\", None)\n\n super(HumbleAuthenticationException, self).__init__(*args, **kwargs)",
"def __init__(self, request=None, *args, **kwargs):\n self.request = request\n self.user_cache = None\n super().__init__(*args, **kwargs)\n\n # Set the max length and label for the \"username\" field.\n self.username_field = User._meta.get_field(User.EMAIL_FIELD)\n username_max_length = self.username_field.max_length\n self.fields['username'].max_length = username_max_length\n self.fields['username'].widget.attrs['maxlength'] = username_max_length\n if self.fields['username'].label is None:\n self.fields['username'].label = capfirst(self.username_field.verbose_name)",
"def __init__(self):\n \n super(Member, self).__init__()\n\n # Elements that faculty members have but guests do not\n self.username = \"\" \n self.email_address = \"\" \n self.password = \"\" \n self.last_access_date = 00000000\n self.last_access_time = 0000\n\n # Extra elements to help with OOP \n self.config_path = \"./user/config.txt\" \n self.options = ['Sign In', 'Search', 'Help', 'Quit']",
"def setUpClass(cls):\n cls.user_info = dict(email=\"@burninglegion.net\", password=\"thetrueeredar\", firstname=\"Archimonde\",\n familyname=\"the defiler\", gender=\"male\", city=\"Mac'Aree\", country=\"Argus\")\n cls.used_mails = [\"\"]",
"def setUpClass(cls):\n cls.user_info = dict(email=\"[email protected]\", password=\"thetrueeredar\", firstname=\"Archimonde\",\n familyname=\"the defiler\", gender=\"male\", city=\"Mac'Aree\", country=\"Argus\")",
"def __init__(__self__, *,\n email_address: pulumi.Input[str],\n is_enabled: pulumi.Input[bool],\n auth_method: Optional[pulumi.Input[float]] = None,\n magic_code: Optional[pulumi.Input[str]] = None,\n password: Optional[pulumi.Input[str]] = None):\n pulumi.set(__self__, \"email_address\", email_address)\n pulumi.set(__self__, \"is_enabled\", is_enabled)\n if auth_method is not None:\n pulumi.set(__self__, \"auth_method\", auth_method)\n if magic_code is not None:\n pulumi.set(__self__, \"magic_code\", magic_code)\n if password is not None:\n pulumi.set(__self__, \"password\", password)",
"def __init__(self, authsource_id: AuthsourceID, username: Username) -> None:\n not_none(authsource_id, 'authsource_id')\n not_none(username, 'username')\n self.authsource_id = authsource_id\n self.username = username",
"def __init__(self):\n self.user = \"\"\n self.password = \"\"",
"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 __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 __init__(self, first_name, last_name, email, password):\n self.first_name = first_name\n self.last_name = last_name\n self.email = email\n self.password = password",
"def __init__(self, first_name, last_name, email, password):\n self.first_name = first_name\n self.last_name = last_name\n self.email = email\n self.password = password",
"def user_init(self):\n pass",
"def __init__(self):\n try:\n self.contact_api_key = helpers.config_section_map(\"Full Contact\")[\"api_key\"]\n except Exception:\n self.contact_api_key = None\n click.secho(\"[!] Did not find a Full Contact API key.\",fg=\"yellow\")",
"def __init__(self):\n self.logged_in = False\n self.driver = None\n self.mail = \"\"\n self.firstname = \"\"\n self.lastname = \"\"",
"def __init__(\n self,\n _email_address=None,\n _name=None,\n _otherinfo=\"\",\n _extrainfo=\"\",\n **kwargs\n ):\n self.email_address = _email_address\n self.name = _name\n self.otherinfo = _otherinfo\n self.extrainfo = _extrainfo\n self.misc = kwargs.items()\n\n self.validate()",
"def __init__(self, *args, **kwargs):\n user = kwargs.pop('user', None)\n super().__init__(*args, **kwargs)\n if self.instance.id:\n for origin in Origin.ORIGIN_TYPES:\n # in case they had an origin that doesn't exist any more.\n try:\n self.fields[origin[0]].initial = self.instance.origins.filter(type=origin[0]).first()\n except Origin.DoesNotExist:\n pass\n # adjust fields for different users\n if user.has_perm('players.view_any_player'):\n allowed_fields = self.fields.keys()\n else:\n allowed_fields = PLAYER_ALLOWED_FIELDS\n if not self.instance.id:\n allowed_fields = allowed_fields + NEW_PLAYER_FIELDS\n self.fields = dict([(key, val) for key, val in self.fields.items() if key in allowed_fields])",
"def __init__(self, request=None, *args, **kwargs):\n self.request = request\n self.user_cache = None\n super(AuthenticationForm, self).__init__(*args, **kwargs)\n\n # Set the label for the \"username\" field.\n self.username_field = UserModel._meta.get_field(UserModel.USERNAME_FIELD)\n if self.fields['username'].label is None:\n self.fields['username'].label = capfirst(self.username_field.verbose_name)",
"def __init__(self, field_names=..., **kwargs) -> None:\n ...",
"def __init__(__self__, *,\n is_enabled: pulumi.Input[bool],\n user_name: pulumi.Input[str],\n api_key: Optional[pulumi.Input[str]] = None,\n is_validated: Optional[pulumi.Input[bool]] = None):\n pulumi.set(__self__, \"is_enabled\", is_enabled)\n pulumi.set(__self__, \"user_name\", user_name)\n if api_key is not None:\n pulumi.set(__self__, \"api_key\", api_key)\n if is_validated is not None:\n pulumi.set(__self__, \"is_validated\", is_validated)",
"def _check_settings(self):\n if self.api_key is None:\n raise ImproperlyConfigured(\"You must provide an API key.\")",
"def __init__(self, **kwargs):\n\t\tself._name = None\n\t\tself._username = None\n\t\tself._password = None\n\t\tself._context = self"
] | [
"0.6357581",
"0.63517404",
"0.63337785",
"0.6269192",
"0.62222046",
"0.6208381",
"0.61986077",
"0.6190089",
"0.6172834",
"0.60944897",
"0.60727406",
"0.59823936",
"0.5973203",
"0.5972595",
"0.58756524",
"0.58631855",
"0.58452314",
"0.583517",
"0.58163303",
"0.58163303",
"0.5801179",
"0.5793054",
"0.5782641",
"0.57799965",
"0.577817",
"0.57682675",
"0.5768265",
"0.57644147",
"0.57278234",
"0.57248646"
] | 0.6688426 | 0 |
Gets the effect that running the validator method has on the field's required attribute. | def validators_effect_required(self, field, func, *args, **kwargs):
NOT_EXIST = '_MISSING_'
original_required = getattr(field, 'required', NOT_EXIST)
field.required = False
func(*args, **kwargs)
after_false = field.required
field.required = True
func(*args, **kwargs)
after_true = field.required
result = None
if after_false and after_true:
result = True
elif not after_false and not after_true:
result = False
elif after_false and not after_true:
result = 'Flip'
field.required = original_required
if original_required == NOT_EXIST:
del field.required
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validation_required(self):\n return self._validation_required",
"def required(self):\n return self._required",
"def required(self):\n return self._required",
"def is_required(self):\r\n return self._required",
"def isRequired(self):\n return not self.isOptional()\n # return self._field.label == FieldDescriptor.LABEL_REQUIRED",
"def required(self) -> pulumi.Input[bool]:\n return pulumi.get(self, \"required\")",
"def required(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"required\")",
"def required(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"required\")",
"def required(self) -> pulumi.Output[Optional[bool]]:\n return pulumi.get(self, \"required\")",
"def required(self) -> bool | None:\n return self._underlying.required",
"def is_required(self) -> bool:\n return self.required",
"def is_required(self, field):\n return field.scheme.is_required and not field.scheme.is_pk",
"def validation_required(self, validation_required):\n self._validation_required = validation_required",
"def is_required(self):\r\n return self.default == self.NotSpecified",
"def get_validate(self):\n return self.validate",
"def required(self):\n\n return bool(self.qualifiers.get(\"required\", False))",
"def required(f):\n f.__required__ = True\n return f",
"def _required_attr(self, attr, key):\n assert isinstance(attr, dict)\n if key not in attr:\n raise AttributeError(\"Required attribute {} not found.\".format(key))\n return attr[key]",
"def _required_attr(self, attr, key):\n assert isinstance(attr, dict)\n if key not in attr:\n raise AttributeError(\"Required attribute {} not found.\".format(key))\n return attr[key]",
"def explicitly_required(self):\n\n return self._explicit",
"def enforce_required_fields(self, attrs):\n if self.instance is not None:\n return\n # missing_items = {\n # field_name: self.missing_message\n # for field_name in self.fields\n # if field_name not in attrs\n # }\n # if missing_items:\n # raise ValidationError(missing_items, code='required')",
"def _validate_required_field(field_name, field_value, prefix='', **kwargs):\n if prefix:\n field_name = prefix + '__' + field_name\n\n if not field_value:\n raise AssertionError(\n \"Missing required Job Definition field: {0}\".format(field_name)\n )",
"def hasRequiredAttributes(self):\n return _libsbml.Rule_hasRequiredAttributes(self)",
"def mandatory(self):\n return self._mandatory",
"def hasRequiredAttributes(self):\n return _libsbml.Replacing_hasRequiredAttributes(self)",
"def hasRequiredAttributes(self):\n return _libsbml.Trigger_hasRequiredAttributes(self)",
"def validator(self):\n return self._validator",
"def validate(self):\n return 1",
"def hasRequiredAttributes(self):\n return _libsbml.Group_hasRequiredAttributes(self)",
"def action_required(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"action_required\")"
] | [
"0.7846773",
"0.7119182",
"0.7119182",
"0.69930714",
"0.693971",
"0.6885761",
"0.66354066",
"0.66354066",
"0.6627754",
"0.6611352",
"0.6601932",
"0.6595242",
"0.65710676",
"0.64031506",
"0.6312467",
"0.62659794",
"0.61985457",
"0.6147427",
"0.6147427",
"0.602703",
"0.6014231",
"0.59417367",
"0.59295535",
"0.59082955",
"0.58930725",
"0.5878242",
"0.58567727",
"0.58020526",
"0.5798875",
"0.5781902"
] | 0.7132236 | 1 |
Returns how many validators are applied to a given field. | def validators_applied_count(self, field, func, *args, **kwargs):
original_validators = field.validators
field.validators = []
func(*args, **kwargs)
result = len(field.validators)
field.validators = original_validators
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getNumValidators(self):\n return _libsbml.SBMLDocument_getNumValidators(self)",
"def get_number_of_validation(self):\n return self.n_valid",
"def validation_set_count(self) -> int:\n return pulumi.get(self, \"validation_set_count\")",
"def field_length(self, fieldname):\n\t\t# todo: is this right?\n\t\tquery = {fieldname: {'$exists': 1}}\n\t\treturn self.index.collection.find(query).count()",
"def _count_fields(self, ws):\n\n field_number = 1\n while ws.cell(row=1, column=field_number).value:\n field_number += 1\n\n return field_number",
"def get_num_of_choices(self) -> int:\n return len(self._choices)",
"def number_of_constraints(self):\n return len(self.constraints)",
"def num_rules(self) -> int:\n return self._rule_count",
"def count_valid_passwords(passwords, validator):\n count = len(list(filter(validator, passwords)))\n print(f\"Found {count} valid passwords\")\n return count",
"def error_count(self):\n return len(self.errors)",
"def count_functions(self):\n\n return len(self.get_functions())",
"def count(self):\n return len([i for i in self.iteritems()])",
"def __len__(self):\n return sum(f.count for f in self.filters)",
"def no_of_constraints(self):\n return np.sum(self._no_of_constraints_by_object())",
"def total_form_count(self):\n if self.initial_extra:\n count = len(self.initial_extra) if self.initial_extra else 0\n count += self.extra\n return count\n else:\n return forms.BaseInlineFormSet.total_form_count(self)",
"def get_validators_for_field(field):\n\n # TODO: Add more validation methods\n\n validators = {}\n if v.validation_includes(field.attr.validator, v.Email):\n validators['email'] = True\n\n if v.validation_includes(field.attr.validator, v.Number):\n validators['number'] = True\n\n if v.validation_includes(field.attr.validator, v.Required):\n validators['required'] = True\n\n if v.validation_includes(field.attr.validator, v.URL):\n validators['url'] = True\n\n if v.validation_includes(field.attr.validator, v.DomainName):\n validators['hostname'] = True\n\n if v.validation_includes(field.attr.validator, v.IPAddress):\n validators['ip_address'] = True\n\n if v.validation_includes(field.attr.validator, v.Min):\n for validator in field.attr.validator.validators:\n if isinstance(validator, v.Min):\n validators['min'] = validator.min_val\n\n if v.validation_includes(field.attr.validator, v.Max):\n for validator in field.attr.validator.validators:\n if isinstance(validator, v.Max):\n validators['max'] = validator.max_val\n\n if v.validation_includes(field.attr.validator, v.Remote):\n for validator in field.attr.validator.validators:\n if isinstance(validator, v.Remote):\n validators['remote'] = validator.validator_name\n\n\n return validators",
"def __len__(self):\n return self.dbms.get_nb_fields(self.table, self.db)",
"def _fields_num(self):\n return len(self.paths)",
"def __len__(self) -> int:\n n_fuzzy_patterns = sum(len(p[\"patterns\"]) for p in self.fuzzy_patterns.values())\n n_regex_patterns = sum(len(p[\"patterns\"]) for p in self.regex_patterns.values())\n return n_fuzzy_patterns + n_regex_patterns",
"def doc_field_length(self, docnum, fieldname, default=0):\n\t\tdoc = self.index.collection.get(docnum, fields=[fieldname])\n\t\tfield = doc['field']\n\t\treturn len(field)",
"def _requiredLength(self):\n if self.partner is not None:\n if self.partner.level == self.level:\n return len(self.partner)\n elif self.partner.level < self.level:\n return 1\n elif self._value is not None:\n return 1\n else:\n return 0",
"def count(self):\n return len(self.find())",
"def valid_record_count(self) -> int:\n return pulumi.get(self, \"valid_record_count\")",
"def no_of_constraint_definitions(self):\n return len(self._constraints_df['name'].unique())",
"def count(self):\n return len(self._components)",
"def __len__(self):\n return len(self.constraints)",
"def get_count_of_controls(self, recurse: bool) -> int:\n return len(list(self.get_all_controls(recurse)))",
"def all_for_field(self, field):\n sum_ = 0\n for cat, cat_name in self.CATEGORIES:\n val = getattr(self, '%s_%s' % (cat, field), None)\n sum_ += val if val is not None else 0\n return sum_",
"def get_number_of_classes(self):\n return len(self.class_dict.keys())",
"def count(self):\n # TODO not implemented yet\n return 0"
] | [
"0.66500133",
"0.64522016",
"0.6205027",
"0.59986514",
"0.5799962",
"0.57960945",
"0.57889473",
"0.56877226",
"0.5686231",
"0.56690854",
"0.5652346",
"0.5574244",
"0.54889596",
"0.5487244",
"0.54550755",
"0.54487497",
"0.5423463",
"0.54120666",
"0.54112846",
"0.5379686",
"0.53693503",
"0.53661907",
"0.534962",
"0.53322935",
"0.5292949",
"0.5292546",
"0.5231994",
"0.52117896",
"0.5201193",
"0.5196692"
] | 0.77912045 | 0 |
The validators from name_for_user_validators are applied as expected. | def test_username_validators(self):
name = self.form.name_for_user
field_source = self.form.fields if name in self.form.fields else self.form.base_fields
field = field_source.get(name, None)
self.assertIsNotNone(field)
expected = 2
count_strict = expected + 1
original_strict = getattr(self.form, 'strict_username', None)
self.form.strict_username = False
func = self.form.name_for_user_validators
actual = self.validators_applied_count(field, func, field_source)
required_not_strict = self.validators_effect_required(field, func, field_source)
self.form.strict_username = True
actual_strict = self.validators_applied_count(field, func, field_source)
required_strict = self.validators_effect_required(field, func, field_source)
self.assertIsNone(required_not_strict)
self.assertEqual(expected, actual)
self.assertIsNone(required_strict)
self.assertEqual(count_strict, actual_strict)
self.form.strict_username = original_strict
if original_strict is None:
del self.form.strict_username | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _validate_user(_):\n pass",
"def validate(self, data):\n user_type = 3\n return validate_register_user(self, data, user_type)",
"def find_user_validations() -> Type[ValidatorComposite]:\n\n arr_validations = [Builder.field(\"user_id\").required().build()]\n\n validations = sum(arr_validations, [])\n\n return ValidatorComposite.build(validations)",
"def test_email_username_validator(self):\n # Test with good data\n validator = self.validator.username_email_validator\n resp = validator('moracha', '[email protected]',\n mock_data['user_dets'])\n self.assertTrue(resp)\n # Test with bad data\n # Registered username\n resp = validator(mock_data['reg_usernm'],\n '[email protected]', mock_data['user_dets'])\n self.assertEqual(resp, \"Username already taken\")\n # Registered email\n resp = validator(\n 'moracha', mock_data['reg_email'], mock_data['user_dets'])\n self.assertEqual(resp, \"Email already used to register\")\n # invalid email\n resp = validator(\n 'moracha', mock_data['bad_email'], mock_data['user_dets'])\n self.assertEqual(resp, \"Email invalid\")\n # username less than four characters\n resp = validator('moa', '[email protected]', mock_data['user_dets'])\n self.assertEqual(resp, \"Username cannot be less than four characters\")\n # username with characters\n resp = validator(mock_data['space_usnm'],\n '[email protected]', mock_data['user_dets'])\n self.assertEqual(resp, \"Username cannot have spaces\")\n # username starting with number\n resp = validator('5mvdfg', '[email protected]', mock_data['user_dets'])\n self.assertEqual(resp, \"Username must start with a letter\")\n # Username with wrong characters\n resp = validator('gtftas%$', '[email protected]', mock_data['user_dets'])\n self.assertEqual(resp, \"Username cannot have this characters: @*#%!&$\")",
"def test_interface_compute_name_for_user(self):\n self.form.name_for_user = self.form._meta.model.USERNAME_FIELD\n self.form.name_for_email = self.form._meta.model.get_email_field_name()\n expected = \"Unique test response value\"\n\n def confirm_func(username_field_name=None, email_field_name=None): return expected\n original_func = self.form.username_from_email_or_names\n self.form.username_from_email_or_names = confirm_func\n actual = self.form.compute_name_for_user()\n self.form.username_from_email_or_names = original_func\n\n self.assertEqual(expected, actual)",
"def validate(self, data):\n user_type = 3\n return validate_login_user(self, data, user_type)",
"def __get_validators__(cls) -> Generator:\n yield cls.validate_type\n yield cls.validate_strip\n yield cls.validate_allow_empty\n yield cls.validate_max_length\n yield cls.validate_min_length\n yield cls.validate_regex",
"def clean(self):\n\n # Getting cleaned email and username data.\n email = self.cleaned_data.get('email')\n username = self.cleaned_data.get('username')\n\n # Get possible user objects based on email and username.\n user_email = User.objects.filter(email=email)\n user_uname = User.objects.filter(username=username)\n\n # If the user has changed his email\n # and if the email already exists.\n if email != self.user.email:\n if user_email:\n raise forms.ValidationError(\"Email address is already taken\")\n\n # If the user has changed his username\n # and if the username already exists.\n if username != self.user.username:\n if user_uname:\n raise forms.ValidationError(\"Username is already taken\")",
"def validate(cls):\n\n def register_onvalidation(form):\n\n onvalidation = current.auth.settings.register_onvalidation\n if onvalidation:\n from gluon.tools import callback\n callback(onvalidation, form, tablename=\"auth_user\")\n\n # Check if L2 is currently blocked for new registrations\n from .customise.org import check_blocked_l2\n check_blocked_l2(form, \"location_L2\")\n\n return register_onvalidation",
"def test_configure_username_confirmation(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n # valid = self.form.is_valid()\n self.form.full_clean()\n names = (original_data.get(field_name, None) for field_name in self.form.constructor_fields)\n expected_name = '_'.join(name for name in names if name is not None).casefold()\n normalize = self.form.user_model.normalize_username\n if callable(normalize):\n expected_name = normalize(expected_name)\n expected_flag = 'False'\n\n self.assertNotIn(self.form.name_for_user, original_data)\n self.assertNotIn(self.form.name_for_user, original_fields)\n self.assertIn(get_html_name(self.form, self.form.name_for_user), self.form.data)\n self.assertIn(self.form.name_for_user, self.form.fields)\n self.assertNotIn(self.form.USERNAME_FLAG_FIELD, original_data)\n self.assertNotIn(self.form.USERNAME_FLAG_FIELD, original_fields)\n self.assertIn(get_html_name(self.form, self.form.USERNAME_FLAG_FIELD), self.form.data)\n self.assertIn(self.form.USERNAME_FLAG_FIELD, self.form.fields)\n self.assertEqual(expected_name, self.form.data.get(get_html_name(self.form, self.form.name_for_user), None))\n self.assertEqual(expected_flag, self.form.data.get(get_html_name(self.form, self.form.USERNAME_FLAG_FIELD)))\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields",
"def validate(self, attrs):\n username = attrs.get(self.username_field)\n try:\n account = get_user_model().objects.get(username=username)\n except get_user_model().DoesNotExist:\n raise UserNotFoundLogin()\n\n if not account.is_active:\n raise UserNotConfirmEmail()\n\n try:\n return super().validate(attrs)\n except serializers.ValidationError:\n raise IncorrectPassword()",
"def validate(self, name, values):\r\n \r\n pass",
"def _validate(self, *_):\n provider = self.provider_entry.get_text()\n username = self.account_name_entry.get_text()\n token = \"\".join(self.token_entry.get_text().split())\n\n if not username:\n self.account_name_entry.get_style_context().add_class(\"error\")\n valid_name = False\n else:\n self.account_name_entry.get_style_context().remove_class(\"error\")\n valid_name = True\n\n if not provider:\n self.provider_combobox.get_style_context().add_class(\"error\")\n valid_provider = False\n else:\n self.provider_combobox.get_style_context().remove_class(\"error\")\n valid_provider = True\n\n if (not token or not OTP.is_valid(token)) and not self.props.is_edit:\n self.token_entry.get_style_context().add_class(\"error\")\n valid_token = False\n else:\n self.token_entry.get_style_context().remove_class(\"error\")\n valid_token = True\n\n self.emit(\"changed\", all([valid_name, valid_provider, valid_token]))",
"def validate(self, attrs):\n email = attrs.get('email')\n password = attrs.get('password')\n\n user = authenticate(\n request=self.context.get('request'),\n username=email,\n password=password\n )\n\n if not user:\n msg = 'User not Found, Please Try Different User'\n raise serializers.ValidationError(\n {'message': msg},\n code='authentication'\n )\n attrs['user'] = user\n return attrs",
"def validate_username(self, attrs, source):\n phone_no = attrs[source]\n if not phoneCleaner(phone_no):\n raise serializers.ValidationError(\"Please check your phone no. the format is incorrect\")\n\n try:\n us = User.objects.get(username__iexact=phone_no)\n except User.DoesNotExist:\n raise serializers.ValidationError(\"Phone number must already be registered before doing this\")\n\n if us.hierarchy != 'master':\n raise serializers.ValidationError(\"Phone number must not be a slave to another user\")\n\n return attrs",
"def test_validators():",
"def get_extra_validators(self):\n return self.extra_validators",
"def _run_extra_validators(self, data):\n errors = defaultdict(list)\n for validator in self.get_extra_validators():\n validator.set_instance(self.instance)\n try:\n validator(data)\n except ValidationError as exc:\n for field, field_errors in exc.detail.items():\n errors[field] += field_errors\n return errors",
"def test_validators_attach(self):\n field_name = 'generic_field'\n expected = validators.validate_confusables\n field = self.form.fields.get(field_name, None)\n all_validators = field.validators if field else []\n self.assertIn(expected, all_validators)",
"def run_validators(self, value):\n errors = []\n for validator in self.validators:\n if hasattr(validator, 'set_context'):\n validator.set_context(self)\n\n try:\n validator(value)\n except serializers.ValidationError as exc:\n # If the validation error contains a mapping of fields to\n # errors then simply raise it immediately rather than\n # attempting to accumulate a list of errors.\n if isinstance(exc.detail, dict):\n raise\n if isinstance(validator, UniqueTogetherValidator):\n self.conflict = True\n errors.extend(exc.detail)\n except serializers.DjangoValidationError as exc:\n errors.extend(exc.messages)\n if errors:\n raise serializers.ValidationError(errors)",
"def validate(self):\n return self.validator.validate(self.fields)",
"def validate(self):\n for name, field in self._get_fields().items():\n field.validate(getattr(self, name))",
"def validate(self):\n raise NotImplementedError(\"validate function needs to be implemented for validators\")",
"def test_email_from_username_from_email_or_names(self):\n self.form.name_for_user = self.form._meta.model.USERNAME_FIELD\n self.form.name_for_email = self.form._meta.model.get_email_field_name()\n new_info = OTHER_USER.copy()\n original_data = self.form.data\n test_data = original_data.copy()\n test_data.update(new_info)\n test_data._mutable = False\n self.form.data = test_data\n self.form.is_bound = True\n self.form.cleaned_data = new_info.copy()\n expected = new_info['email']\n UserModel = get_user_model()\n\n self.assertEqual(1, UserModel.objects.count())\n self.assertEqual(self.user, UserModel.objects.first())\n for key in (self.form.name_for_user, self.form.name_for_email):\n new_info.get(key, None) != getattr(self.user, key, '')\n for key, value in new_info.items():\n self.assertIn(key, self.form.cleaned_data)\n result = self.form.username_from_email_or_names(self.form.name_for_user, self.form.name_for_email)\n self.assertEqual(expected, result)\n\n self.form.data = original_data\n del self.form.cleaned_data",
"def _validate(self, value, name):\n validated = self._validate_impl(value, name)\n return self._validate_post(value, name, validated)",
"def test_validate_user(self):\n with self.assertRaises(ValidationError):\n self.make_assignment(\n self.category, self.user_alice, self.role_contributor\n )",
"def run_validators(self, value):\r\n for validator in self.validators:\r\n if isinstance(validator, validators.UniqueTogetherValidator):\r\n self.validators.remove(validator)\r\n super(ProfileSerializer, self).run_validators(value)",
"def clean_users_not_same(field_name):\n\n @check_field_is_empty(field_name)\n def wrapped(self):\n \"\"\"Decorator wrapper method.\n \"\"\"\n clean_user_field = clean_existing_user(field_name)\n user_entity = clean_user_field(self)\n\n current_user_entity = user_logic.getCurrentUser()\n # pylint: disable=E1103\n if user_entity.key() == current_user_entity.key():\n # users are equal\n raise forms.ValidationError(\"You cannot enter yourself here.\")\n\n return user_entity\n return wrapped",
"def test_single_field_validation(self):\n UserFactory.create(username='user', email='[email protected]')\n # using username and email that have conflicts but sending form_field_key will return\n # validation for only email\n self.assertValidationDecision(\n {'username': 'user', 'email': '[email protected]', 'is_authn_mfe': True, 'form_field_key': 'email'},\n {'email': AUTHN_EMAIL_CONFLICT_MSG}\n )",
"def clean(self):\n\n # Fetch cleaned email and username data.\n email = self.cleaned_data.get('email')\n username = self.cleaned_data.get('username')\n\n # Fetch possible user objects from the database\n # based on provided and email and password.\n user_email = User.objects.filter(email=email)\n user_uname = User.objects.filter(username=username)\n\n # If user exists based on the email address or username,\n # raise validation error.\n if user_email:\n self._errors[\"email\"] = \"Email address is already associated with another account\"\n\n if user_uname:\n self._errors[\"username\"] = \"Usename is already associated with another account\""
] | [
"0.6465854",
"0.6126383",
"0.60170776",
"0.58740145",
"0.58586645",
"0.58527416",
"0.58149683",
"0.57209533",
"0.5690418",
"0.5666043",
"0.5659131",
"0.5653846",
"0.56325513",
"0.55936015",
"0.557374",
"0.55715215",
"0.5543325",
"0.55432403",
"0.55430436",
"0.55049217",
"0.54905075",
"0.5486311",
"0.548161",
"0.547061",
"0.5460238",
"0.5453623",
"0.5396187",
"0.5390856",
"0.5386977",
"0.5381623"
] | 0.68008995 | 0 |
The validators from name_for_email_validators are applied as expected. | def test_email_validators(self):
name = self.form.name_for_email
field = self.form.fields[name]
expected = 2
count_strict = expected + 1
original_strict = getattr(self.form, 'strict_email', None)
self.form.strict_email = False
func = self.form.name_for_email_validators
# email_opts = {'names': (field_name, 'email'), 'alt_field': 'email_field', 'computed': False}
# email_opts.update({'name': field_name, 'field': field})
actual = self.validators_applied_count(field, func, self.form.fields)
required_not_strict = self.validators_effect_required(field, func, self.form.fields)
self.form.strict_email = True
actual_strict = self.validators_applied_count(field, func, self.form.fields)
required_strict = self.validators_effect_required(field, func, self.form.fields)
self.assertTrue(required_not_strict)
self.assertEqual(expected, actual)
self.assertTrue(required_strict)
self.assertEqual(count_strict, actual_strict)
self.form.strict_email = original_strict
if original_strict is None:
del self.form.strict_email | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate(self, value):\n # Use the parent's handling of required fields, etc.\n super().validate(value)\n for email in value:\n validate_email(email)",
"def test_email_username_validator(self):\n # Test with good data\n validator = self.validator.username_email_validator\n resp = validator('moracha', '[email protected]',\n mock_data['user_dets'])\n self.assertTrue(resp)\n # Test with bad data\n # Registered username\n resp = validator(mock_data['reg_usernm'],\n '[email protected]', mock_data['user_dets'])\n self.assertEqual(resp, \"Username already taken\")\n # Registered email\n resp = validator(\n 'moracha', mock_data['reg_email'], mock_data['user_dets'])\n self.assertEqual(resp, \"Email already used to register\")\n # invalid email\n resp = validator(\n 'moracha', mock_data['bad_email'], mock_data['user_dets'])\n self.assertEqual(resp, \"Email invalid\")\n # username less than four characters\n resp = validator('moa', '[email protected]', mock_data['user_dets'])\n self.assertEqual(resp, \"Username cannot be less than four characters\")\n # username with characters\n resp = validator(mock_data['space_usnm'],\n '[email protected]', mock_data['user_dets'])\n self.assertEqual(resp, \"Username cannot have spaces\")\n # username starting with number\n resp = validator('5mvdfg', '[email protected]', mock_data['user_dets'])\n self.assertEqual(resp, \"Username must start with a letter\")\n # Username with wrong characters\n resp = validator('gtftas%$', '[email protected]', mock_data['user_dets'])\n self.assertEqual(resp, \"Username cannot have this characters: @*#%!&$\")",
"def is_valid(self):\n from_email = '[email protected]' # TODO\n self.instance.from_email = from_email\n\n emails = get_admin_emails_as_flat_list()\n emails = ','.join(emails) # transform to comma separated strings\n self.instance.admin_emails = emails\n\n is_valid = super().is_valid()\n return is_valid",
"def _validateEmail(dErrors, sName, sValue):\n (sValue, sError) = ModelDataBase.validateEmail(sValue, fAllowNull = True);\n if sError is not None:\n dErrors[sName] = sError;\n return sValue;",
"def validate_element(self, value):\n if super(EmailField, self).validate_element(value):\n valid_uname, valid_domain = validation_util.valid_email(value)\n if not (valid_uname and valid_domain):\n if isinstance(valid_domain, int):\n val_error = ValidationError(\n 'Field encountered improperly formatted email address: %s' % value)\n else:\n if '@' not in value:\n val_error = ValidationError(\n 'Field encountered email address with missing @ '\n 'character: %s' % value)\n else:\n val_error = ValidationError(\n 'Field encountered email address with illegal '\n 'characters: %s' % value)\n\n raise val_error\n else:\n return value",
"def validate(self, data):\n email = data['email']\n if re.search(r'[\\w.-]+@[\\w.-]+.\\w+', email): # check name has more than 1 word\n return data\n raise serializers.ValidationError(\"Please enter valide email\")",
"def validate_email(self, email):\n return models.Email.normalize_address(email)",
"def validate_email(self, data):\n if User.objects.filter(email=data.lower()).exists():\n raise serializers.ValidationError('Already registered email!')\n return data.lower()",
"def emailValidate(form, field):\n\n if ' ' in field.data:\n raise ValidationError(message='Invalid e-mail address')\n\n if field.data.count('.') < 1:\n raise ValidationError(message='Invalid e-mail address')\n\n if field.data.count('@') < 1:\n raise ValidationError(message='Invalid e-mail address')",
"def validate_email(self, value):\n verifier = EmailVerifier(value)\n if not verifier.is_valid():\n if verifier.errors:\n raise serializers.ValidationError(verifier.errors)\n error_code = verifier.data.get('result', 'unknown_error')\n if verifier.status_code == status.HTTP_200_OK:\n raise serializers.ValidationError({error_code:\n VALIDATION_ERRORS[error_code]})\n else:\n # This errors are 'Payment required' or 'Rate limit' errors etc, they\n # logged in by the EmailVerifier and should not be exposed to a user.\n raise serializers.ValidationError({'unknown_error':\n VALIDATION_ERRORS['unknown_error']})\n return value",
"def clean_email(self):\r\n email_domain = self.cleaned_data['email'].split('@')[1]\r\n if email_domain in self.bad_domains:\r\n raise forms.ValidationError(_(u'Registration using free email addresses is prohibited. Please supply a different email address.'))\r\n return self.cleaned_data['email']",
"def test_single_field_validation(self):\n UserFactory.create(username='user', email='[email protected]')\n # using username and email that have conflicts but sending form_field_key will return\n # validation for only email\n self.assertValidationDecision(\n {'username': 'user', 'email': '[email protected]', 'is_authn_mfe': True, 'form_field_key': 'email'},\n {'email': AUTHN_EMAIL_CONFLICT_MSG}\n )",
"def email_validate(self,\r\n email,\r\n fix_typos=False):\r\n\r\n # Prepare query URL\r\n _url_path = '/email-validate'\r\n _query_builder = Configuration.get_base_uri()\r\n _query_builder += _url_path\r\n _query_url = APIHelper.clean_url(_query_builder)\r\n\r\n # Prepare headers\r\n _headers = {\r\n 'accept': 'application/json'\r\n }\r\n\r\n # Prepare form parameters\r\n _form_parameters = {\r\n 'output-case': 'camel',\r\n 'email': email,\r\n 'fix-typos': fix_typos\r\n }\r\n\r\n # Prepare and execute request\r\n _request = self.http_client.post(_query_url, headers=_headers, parameters=_form_parameters)\r\n CustomQueryAuth.apply(_request)\r\n _context = self.execute_request(_request)\r\n self.validate_response(_context)\r\n\r\n # Return appropriate type\r\n return APIHelper.json_deserialize(_context.response.raw_body, EmailValidateResponse.from_dictionary)",
"def emails() -> st.SearchStrategy[str]:\n return (\n st.emails()\n .map(lambda s: s.lower())\n .map(_validate_email)\n .filter(_is_valid_email)\n .map(lambda m: m.normalized) # type: ignore[union-attr]\n )",
"def clean_email(field_name):\n @check_field_is_empty(field_name)\n def wrapper(self):\n \"\"\"Decorator wrapper method.\n \"\"\"\n # convert to lowercase for user comfort\n email = self.cleaned_data.get(field_name)\n validator = validators.validate_email\n\n try:\n validator(email)\n except forms.ValidationError, e:\n if e.code == 'invalid':\n msg = ugettext(u'Enter a valid email address.')\n raise forms.ValidationError(msg, code='invalid')\n return email\n\n return wrapper",
"def clean_email(self):\n # NOTE: all emails are stored in lower case\n e = self.cleaned_data['email'].lower()\n if User.objects.filter(email=e).count() > 0:\n raise forms.ValidationError('An existing account is using that email address.')\n return e",
"def validate(self):\n rv = Form.validate(self)\n if not rv:\n return False\n\n cur = get_cursor()\n if not email_exists(cur, self.email.data):\n self.email.errors.append('Please check your email address.')\n return False\n\n return True",
"def validate_email(self, email):\n email = email.lower()\n if User.objects.filter(email=email).exists():\n raise serializers.ValidationError('Email already registered.')\n return email",
"def test_validators_attach(self):\n field_name = 'generic_field'\n expected = validators.validate_confusables\n field = self.form.fields.get(field_name, None)\n all_validators = field.validators if field else []\n self.assertIn(expected, all_validators)",
"def clean_email(self):\n email = self.cleaned_data['email'].lower()\n if not email.endswith('@pearson.com'):\n raise forms.ValidationError('Your email address must end with @pearson.com')\n return email",
"def validate_email(self):\n # source: https://docs.python.org/2/howto/regex.html\n if not re.match(r\"[^@.]+@[A-Za-z]+\\.[a-z]+\", self.email):\n return 'Invalid email address!'\n return self.email",
"def __get_validators__(cls) -> Generator:\n yield cls.validate_type\n yield cls.validate_strip\n yield cls.validate_allow_empty\n yield cls.validate_max_length\n yield cls.validate_min_length\n yield cls.validate_regex",
"def __call__(self, value: Any, __context=None) -> Any:\n value = super(Email, self).__call__(\n value,\n __context=__context,\n )\n\n if self.email_validator:\n try:\n self.email_validator()(value)\n except ValidationError:\n raise exc.PatternMatchError(\n expected='valid email',\n actual=value,\n )\n\n return value",
"def validate_email(self, data, field_name):\n existing = User.objects.filter(email__iexact=data['email'])\n if existing.exists():\n raise fields.ValidationError(\"A user with that email already exists.\")\n else:\n return data",
"def clean_email(self):\n if User.objects.filter(email__iexact=self.cleaned_data['email']):\n raise forms.ValidationError('This email address is already in use. Please supply a different email address.')\n return self.cleaned_data['email']",
"def clean(self):\n cleaned_data = super(UserForm, self).clean()\n if 'email' not in cleaned_data and 'verify_email' not in cleaned_data:\n return cleaned_data\n elif 'email' in cleaned_data and 'verify_email' in cleaned_data:\n email = cleaned_data['email']\n verify_email = cleaned_data['verify_email']\n print(email, verify_email)\n if email != verify_email:\n raise forms.ValidationError(\n \"You need to enter the same email in both fields.\")\n else:\n raise forms.ValidationError(\n \"You need to enter the same email in both fields.\")",
"def clean_email(self):\r\n if User.objects.filter(email__iexact=self.cleaned_data['email']):\r\n raise forms.ValidationError(_(u'This email address is already in use. Please supply a different email address.'))\r\n return self.cleaned_data['email']",
"def clean_email(self):\n if User.objects.filter(email__iexact=self.cleaned_data['email']):\n raise forms.ValidationError(_(\"This email address is already in use. Please supply a different email address.\"))\n return self.cleaned_data['email']",
"def clean_email(self):\n if User.objects.filter(email__iexact=self.cleaned_data['email']):\n raise forms.ValidationError(_(\"This email address is already in use. Please supply a different email address.\"))\n return self.cleaned_data['email']",
"def test_invalid_emails_cause_error(self):\n form = forms.GroupInviteForm({'emails': 'abcd123123'})\n self.assertFalse(form.is_valid())\n self.assertEqual(\n form.errors['emails'],\n [u'No Valid Addresses Found'])"
] | [
"0.65610677",
"0.6268303",
"0.6046455",
"0.6038639",
"0.6019607",
"0.60033554",
"0.6002678",
"0.6001875",
"0.5987494",
"0.5919595",
"0.5918489",
"0.58521897",
"0.5850795",
"0.5824184",
"0.58181787",
"0.58074874",
"0.5795105",
"0.5782553",
"0.57596254",
"0.57560974",
"0.5750787",
"0.5730748",
"0.5715641",
"0.57155424",
"0.57116765",
"0.568382",
"0.56824726",
"0.5681472",
"0.5681472",
"0.5679212"
] | 0.72215724 | 0 |
If email already used, uses constructor_fields to make a username in username_from_email_or_names. | def test_constructor_fields_used_when_email_fails(self):
self.form.name_for_user = self.form._meta.model.USERNAME_FIELD
self.form.name_for_email = self.form._meta.model.get_email_field_name()
existing_email = self.user.email
new_info = {'first_name': "Newbie", 'last_name': "Newsome", 'email': existing_email}
original_data = self.form.data
test_data = original_data.copy()
test_data.update(new_info)
test_data._mutable = False
self.form.data = test_data
self.form.is_bound = True
self.form.cleaned_data = new_info.copy()
names = (new_info[field_name] for field_name in self.form.constructor_fields)
expected = '_'.join(names).casefold()
UserModel = get_user_model()
cur_user = self.user
found_user = UserModel.objects.get(username=cur_user.username)
self.assertEqual(cur_user, found_user)
for key, value in new_info.items():
self.assertIn(key, self.form.cleaned_data)
if key in (self.form.name_for_user, self.form.name_for_email):
continue
self.assertNotEqual(getattr(self.user, key, None), value)
result = self.form.username_from_email_or_names(self.form.name_for_user, self.form.name_for_email)
self.assertEqual(expected, result)
self.form.data = original_data
del self.form.cleaned_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, first_name, last_name, email, mobile, user_name):\n self.first_name = first_name\n self.last_name = last_name\n self.email = email\n self.mobile = mobile\n self.user_name = user_name",
"def _user_from_name_or_email(username_or_email):\r\n username_or_email = strip_if_string(username_or_email)\r\n\r\n if '@' in username_or_email:\r\n return User.objects.get(email=username_or_email)\r\n else:\r\n return User.objects.get(username=username_or_email)",
"def __init__(self, request=None, *args, **kwargs):\n self.request = request\n self.user_cache = None\n super().__init__(*args, **kwargs)\n\n # Set the max length and label for the \"username\" field.\n self.username_field = User._meta.get_field(User.EMAIL_FIELD)\n username_max_length = self.username_field.max_length\n self.fields['username'].max_length = username_max_length\n self.fields['username'].widget.attrs['maxlength'] = username_max_length\n if self.fields['username'].label is None:\n self.fields['username'].label = capfirst(self.username_field.verbose_name)",
"def __init__(self, author_and_email_tuple):\n name, email = author_and_email_tuple\n first_last = name.strip()\n if first_last in names_equivalences:\n first_last = names_equivalences[first_last]\n self.first_last = first_last\n self.email = email.lower()\n last_name_fragment, suffix = self._last_name(name)\n name_sep = name.index(last_name_fragment)\n self.first = name[:name_sep].rstrip()\n self.last = last_name_fragment\n self.suffix = suffix\n if not self.first:\n self.last_first = self.last\n else:\n self.last_first = u', '.join([self.last, self.first])\n if self.suffix:\n self.last_first += u', ' + self.suffix\n if self.last == \"van Rossum\":\n # Special case for our beloved BDFL. :)\n if self.first == \"Guido\":\n self.nick = \"GvR\"\n elif self.first == \"Just\":\n self.nick = \"JvR\"\n else:\n raise ValueError(\"unkown van Rossum %r!\" % self)\n self.last_first += \" (%s)\" % (self.nick,)\n else:\n self.nick = self.last",
"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 sample_user_dynamic_email(email):\n return get_user_model().objects.create_user(email=email,\n password=\"password123\",\n name=\"some name\")",
"def test_create_no_username(self):\n\n # If there is no username, email will be used instead\n properties = self.portal.portal_properties.site_properties\n properties.manage_changeProperties(use_email_as_login=True)\n\n user = api.user.create(\n email='[email protected]',\n password='secret'\n )\n\n self.assertEquals(user.getUserName(), '[email protected]')\n\n # But if using emails as a username is disabled, we should get\n # an error\n properties.manage_changeProperties(use_email_as_login=False)\n\n self.assertRaises(\n ValueError,\n api.user.create,\n email='[email protected]', password='secret'\n )",
"def save(self, *args, **kwargs):\n self.username = self.username or self.email\n super().save(*args, **kwargs)",
"def create_user(email, password, f_name, l_name):\n pass",
"def test_email_from_username_from_email_or_names(self):\n self.form.name_for_user = self.form._meta.model.USERNAME_FIELD\n self.form.name_for_email = self.form._meta.model.get_email_field_name()\n new_info = OTHER_USER.copy()\n original_data = self.form.data\n test_data = original_data.copy()\n test_data.update(new_info)\n test_data._mutable = False\n self.form.data = test_data\n self.form.is_bound = True\n self.form.cleaned_data = new_info.copy()\n expected = new_info['email']\n UserModel = get_user_model()\n\n self.assertEqual(1, UserModel.objects.count())\n self.assertEqual(self.user, UserModel.objects.first())\n for key in (self.form.name_for_user, self.form.name_for_email):\n new_info.get(key, None) != getattr(self.user, key, '')\n for key, value in new_info.items():\n self.assertIn(key, self.form.cleaned_data)\n result = self.form.username_from_email_or_names(self.form.name_for_user, self.form.name_for_email)\n self.assertEqual(expected, result)\n\n self.form.data = original_data\n del self.form.cleaned_data",
"def create(self):\n if User.load(username) is None:\n \"\"\"This username is not in use\"\"\"\n if self.validateEmail(self.email):\n \"\"\"This email is valid\"\"\"\n if len(self.username) > 2:\n \"\"\"This is long enough\"\"\"\n self.__store()",
"def __init__(self, **kwargs):\n self.user_id = kwargs.get(\"user_id\")\n self.firstname = kwargs.get(\"firstname\")\n self.lastname = kwargs.get(\"lastname\")\n self.othernames = \"none\"\n self.username = kwargs.get(\"username\")\n self.email = kwargs.get(\"email\")\n self.phonenumber = kwargs.get(\"phonenumber\")\n self.is_admin = kwargs.get(\"is_admin\")\n self.password = kwargs.get(\"password\")\n self.registered_on = kwargs.get(\"registered_on\")",
"def test_create_with_username(self):\n properties = self.portal.portal_properties.site_properties\n properties.manage_changeProperties(use_email_as_login=True)\n\n user = api.user.create(\n username='chuck',\n email='[email protected]',\n password='secret',\n )\n self.assertEquals(user.getUserName(), '[email protected]')\n\n properties = self.portal.portal_properties.site_properties\n properties.manage_changeProperties(use_email_as_login=False)\n\n user = api.user.create(\n username='chuck',\n email='[email protected]',\n password='secret',\n )\n self.assertEquals(user.getUserName(), 'chuck')",
"def __init__(self, username: str) -> None:\n try:\n check_string(username, 'username', 'a-z0-9', 100)\n except IllegalParameterError as e:\n raise IllegalUsernameError(e.message) from e\n self.name = username",
"def __init__(self, \n given_name=None, initials=None, family_name=None, \n email_address=None\n ):\n self.given_name = given_name\n self.initials = initials\n self.family_name = family_name\n self.email_address = email_address",
"def clean_username_or_email(self):\n username_or_email = self.cleaned_data['username_or_email']\n try:\n user = User.objects.get(username__iexact=username_or_email)\n self.profile = user.profile\n except User.DoesNotExist:\n try:\n self.profile = Profile.objects.get(\n settings__email__iexact=username_or_email)\n except Profile.DoesNotExist:\n raise forms.ValidationError(ERRORS['invalid_username'])\n return username_or_email",
"def _create_user(self, username, email, password, phone, **extra_fields):\n\n username = self.model.normalize_username(username)\n user = self.model(username=username, email=email, phone=phone, **extra_fields) # using email_id instead of email\n user.set_password(password)\n user.save(using=self._db)\n return user",
"def __init__(self, username, first_name=None, last_name=None, **kwargs):\n self.username = username\n self.first_name = first_name\n self.last_name = last_name\n if kwargs:\n self._parameters = kwargs\n else:\n self._parameters = {}",
"def save(self, commit=True):\n\n email_local_part = self.cleaned_data['email'].split('@')[0]\n username_start = email_local_part[:5] if len(email_local_part) >= 5 else email_local_part\n self.instance.username = username_start + ''.join(\n [choice(ascii_letters) for _ in range(30 - len(username_start))])\n\n return super(RegisterForm, self).save(commit=commit)",
"def __init__(self, first_name, last_name, email, password):\n self.first_name = first_name\n self.last_name = last_name\n self.email = email\n self.password = password",
"def __init__(self, first_name, last_name, email, password):\n self.first_name = first_name\n self.last_name = last_name\n self.email = email\n self.password = password",
"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 __init__(self, first_name, second_name, age, location):\n self.name = f'{first_name.title()} {second_name.title()}'\n self.age = age\n self.location = location\n self.login_attempts = 0",
"def _create_user(self, email, password, **extra_fields):\n\n email = self.normalize_email(email)\n #username = self.model.normalize_username(username)\n user = self.model( email=email, **extra_fields)\n user.set_password(password)\n user.save(using=self._db)\n return user",
"def __init__(__self__, *,\n email: Optional[pulumi.Input[str]] = None,\n first_name: Optional[pulumi.Input[str]] = None,\n last_name: Optional[pulumi.Input[str]] = None,\n phone: Optional[pulumi.Input[str]] = None,\n title: Optional[pulumi.Input[str]] = None):\n if email is not None:\n pulumi.set(__self__, \"email\", email)\n if first_name is not None:\n pulumi.set(__self__, \"first_name\", first_name)\n if last_name is not None:\n pulumi.set(__self__, \"last_name\", last_name)\n if phone is not None:\n pulumi.set(__self__, \"phone\", phone)\n if title is not None:\n pulumi.set(__self__, \"title\", title)",
"def test_unique_username(self):\n user = User(name=\"thealphadollar\")\n g.db.add(user)\n g.db.commit()\n\n user_field = Field(\"thealphadollar\")\n\n with self.assertRaises(ValidationError):\n unique_username(None, user_field)",
"def clean_user_account(field_name):\n\n @check_field_is_empty(field_name)\n def wrapped(self):\n \"\"\"Decorator wrapper method.\n \"\"\"\n email_adress = self.cleaned_data[field_name]\n return users.User(email_adress)\n\n return wrapped",
"def __init__(self, email, username, first_name, password):\n self.email = email\n self.username = username\n self.first_name = first_name\n self.password = Bcrypt().generate_password_hash(password).decode()\n self.register_date = datetime.datetime.now()",
"def __init__(self, request=None, *args, **kwargs):\n self.request = request\n self.user_cache = None\n super(AuthenticationForm, self).__init__(*args, **kwargs)\n\n # Set the label for the \"username\" field.\n self.username_field = UserModel._meta.get_field(UserModel.USERNAME_FIELD)\n if self.fields['username'].label is None:\n self.fields['username'].label = capfirst(self.username_field.verbose_name)",
"def test_new_user_email_normalize(self):\n email = \"[email protected]\"\n user = get_user_model().objects.create_user(email, \"test123123123123\")\n\n self.assertEqual(email.lower(), user.email)"
] | [
"0.64217675",
"0.6367761",
"0.63263166",
"0.620328",
"0.61865926",
"0.61669844",
"0.61543685",
"0.6141236",
"0.61404413",
"0.6122232",
"0.6121378",
"0.60854435",
"0.60776377",
"0.6067628",
"0.6064595",
"0.6050339",
"0.60310495",
"0.6002653",
"0.5994113",
"0.5989058",
"0.5989058",
"0.5972127",
"0.59599334",
"0.5956146",
"0.5948072",
"0.59419906",
"0.5930612",
"0.59300625",
"0.589715",
"0.5895003"
] | 0.67416775 | 0 |
The get_login_message response for link_only and no text passed returns as expected. | def test_message_link_only_no_text(self):
kwargs = dict(link_text=None, link_only=False, reset=False)
kwargs['link_only'] = True
urls = self.get_or_make_links(('login', 'password_reset'))
for url in urls:
self.assertIsNotNone(url)
expected = self.mock_get_login_message(urls, **kwargs)
actual = self.form.get_login_message(**kwargs)
self.assertEqual(expected, actual) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_message_default_no_text(self):\n kwargs = dict(link_text=None, link_only=False, reset=False)\n urls = self.get_or_make_links(('login', 'password_reset'))\n for url in urls:\n self.assertIsNotNone(url)\n expected = self.mock_get_login_message(urls, **kwargs)\n actual = self.form.get_login_message(**kwargs)\n\n self.assertEqual(expected, actual)",
"def test_message_link_only_with_text(self):\n kwargs = dict(link_text=None, link_only=False, reset=False)\n kwargs['link_only'] = True\n kwargs['link_text'] = 'This is the text for the test - test_message_link_only_with_text'\n urls = self.get_or_make_links(('login', 'password_reset'))\n for url in urls:\n self.assertIsNotNone(url)\n expected = self.mock_get_login_message(urls, **kwargs)\n actual = self.form.get_login_message(**kwargs)\n\n self.assertEqual(expected, actual)",
"def test_message_default_with_text(self):\n kwargs = dict(link_text=None, link_only=False, reset=False)\n link_names = ('login', 'password_reset')\n text_template = 'The {} test text - test_message_default_with_text'\n kwargs['link_text'] = [text_template.format(name) for name in link_names]\n urls = self.get_or_make_links(link_names)\n for url in urls:\n self.assertIsNotNone(url)\n expected = self.mock_get_login_message(urls, **kwargs)\n actual = self.form.get_login_message(**kwargs)\n\n self.assertEqual(expected, actual)",
"def test_message_reset_link_only_no_text(self):\n kwargs = dict(link_text=None, link_only=False, reset=False)\n kwargs['link_only'] = True\n kwargs['reset'] = True\n urls = self.get_or_make_links(('login', 'password_reset'))\n for url in urls:\n self.assertIsNotNone(url)\n expected = self.mock_get_login_message(urls, **kwargs)\n actual = self.form.get_login_message(**kwargs)\n\n self.assertEqual(expected, actual)",
"def test_message_reset_link_only_with_text(self):\n kwargs = dict(link_text=None, link_only=False, reset=False)\n kwargs['link_only'] = True\n kwargs['reset'] = True\n kwargs['link_text'] = 'This is the text for the test - test_message_link_only_with_text'\n urls = self.get_or_make_links(('login', 'password_reset'))\n for url in urls:\n self.assertIsNotNone(url)\n expected = self.mock_get_login_message(urls, **kwargs)\n actual = self.form.get_login_message(**kwargs)\n\n self.assertEqual(expected, actual)",
"def test_message_reset_no_text(self):\n kwargs = dict(link_text=None, link_only=False, reset=False)\n kwargs['reset'] = True\n urls = self.get_or_make_links(('login', 'password_reset'))\n for url in urls:\n self.assertIsNotNone(url)\n expected = self.mock_get_login_message(urls, **kwargs)\n actual = self.form.get_login_message(**kwargs)\n\n self.assertEqual(expected, actual)",
"def test_message_reset_with_text(self):\n kwargs = dict(link_text=None, link_only=False, reset=False)\n kwargs['reset'] = True\n link_names = ('login', 'password_reset')\n text_template = 'The {} test text - test_message_default_with_text'\n kwargs['link_text'] = [text_template.format(name) for name in link_names]\n urls = self.get_or_make_links(link_names)\n for url in urls:\n self.assertIsNotNone(url)\n expected = self.mock_get_login_message(urls, **kwargs)\n actual = self.form.get_login_message(**kwargs)\n\n self.assertEqual(expected, actual)",
"def get_msg_login(self, username):\n return \"Welcome\"",
"def login_link(self):\n\t\tresponse = self.client.post(self._endpoint + \"/loginLink\")\n\t\treturn response.json[\"link\"]",
"def get_msg_login(self, username):\n return self.user_table[username]['msg_login']",
"def format_message(self, login: str, message: dict) -> str:\n login_from = login if message['incoming'] else self.username\n login_to = self.username if message['incoming'] else login\n return f'{login_from} -> {login_to}:\\n{message[\"text\"]}'",
"def test_login_page_content(self):\n response = self.app.get(\"/accounts/login/\")\n self.assertEqual(response.status_code, 200,\n \"Could not access /accounts/login/ route\")\n self.assertIn(b\"/accounts/create/\", response.data,\n \"Couldn't find link to /accounts/create/\")",
"def test_spa_get_bad_token(app, client, get_message):\n with capture_flashes() as flashes:\n with capture_passwordless_login_requests() as requests:\n response = client.post(\n \"/login\",\n json=dict(email=\"[email protected]\"),\n headers={\"Content-Type\": \"application/json\"},\n )\n assert response.headers[\"Content-Type\"] == \"application/json\"\n token = requests[0][\"login_token\"]\n time.sleep(1)\n\n response = client.get(\"/login/\" + token)\n assert response.status_code == 302\n split = urlsplit(response.headers[\"Location\"])\n assert \"localhost:8081\" == split.netloc\n assert \"/login-error\" == split.path\n qparams = dict(parse_qsl(split.query))\n assert all(k in qparams for k in [\"email\", \"error\", \"identity\"])\n\n msg = get_message(\"LOGIN_EXPIRED\", within=\"1 milliseconds\", email=\"[email protected]\")\n assert msg == qparams[\"error\"].encode(\"utf-8\")\n\n # Test mangled token\n token = (\n \"WyIxNjQ2MzYiLCIxMzQ1YzBlZmVhM2VhZjYwODgwMDhhZGU2YzU0MzZjMiJd.\"\n \"BZEw_Q.lQyo3npdPZtcJ_sNHVHP103syjM\"\n \"&url_id=fbb89a8328e58c181ea7d064c2987874bc54a23d\"\n )\n response = client.get(\"/login/\" + token)\n assert response.status_code == 302\n split = urlsplit(response.headers[\"Location\"])\n assert \"localhost:8081\" == split.netloc\n assert \"/login-error\" == split.path\n qparams = dict(parse_qsl(split.query))\n assert len(qparams) == 1\n assert all(k in qparams for k in [\"error\"])\n\n msg = get_message(\"INVALID_LOGIN_TOKEN\")\n assert msg == qparams[\"error\"].encode(\"utf-8\")\n assert len(flashes) == 0",
"def _get_plain_message (self) :\n return self._message",
"def get_message(self, user):\n return None",
"def optional_login(request):\n try:\n login_url = reverse('rest_framework:login')\n except NoReverseMatch:\n return ''\n\n snippet = \"<li><a href='{href}?next={next}'>Sing in</a></li>\"\n snippet = format_html(snippet, href=login_url, next=escape(request.path))\n\n return mark_safe(snippet)",
"def authenticate():\n return \"Please log in... Log in page\"",
"def optional_login(request):\n try:\n login_url = reverse('rest_framework:login')\n except NoReverseMatch:\n return ''\n\n snippet = \"<li><a href='{href}?next={next}'>Log in</a></li>\"\n snippet = format_html(snippet, href=login_url, next=escape(request.path))\n\n return mark_safe(snippet)",
"def assertLoginFailure(self, response):\n return self.assertInHTML(\n '<h1>Social Network Login Failure</h1>',\n str(response.content),\n )",
"def test_login_OK(self):\n rv = self.login('super',\n '1b3231655cebb7a1f783eddf27d254ca')\n assert 'Bienvenido' in rv.data",
"def loginAfterFeed():\n label = loginFunc(Camera())\n print(\"loginAfterFeed label:\", label)\n if label is None:\n return json.dumps({\"name\":\"error\"})\n else:\n return json.dumps({\"name\":label})",
"def getMessage():\n return message",
"def test_show_login_page(self):\n with self.client as c:\n\n res = c.get(\"/login\")\n html = res.get_data(as_text=True)\n\n self.assertEqual(res.status_code, 200)\n self.assertIn(\"Don't have an account?\", html)",
"def _show_login_page(self, ticket: SSOLoginData, requested_authn_context: Optional[str], redirect_uri) -> bytes:\n argv = eduid_idp.mischttp.get_default_template_arguments(self.context.config)\n argv.update(\n {\n \"action\": \"/verify\",\n \"username\": \"\",\n \"password\": \"\",\n \"key\": ticket.key,\n \"authn_reference\": requested_authn_context,\n \"redirect_uri\": redirect_uri,\n \"alert_msg\": \"\",\n \"sp_entity_id\": \"\",\n \"failcount\": ticket.FailCount,\n # SAMLRequest, RelayState and binding are used to re-create the ticket state if not found using `key'\n \"SAMLRequest\": escape(ticket.SAMLRequest, quote=True),\n \"RelayState\": escape(ticket.RelayState, quote=True),\n \"binding\": escape(ticket.binding, quote=True),\n }\n )\n\n # Set alert msg if FailCount is greater than zero\n if ticket.FailCount:\n argv[\"alert_msg\"] = \"INCORRECT\" # \"Incorrect username or password ({!s} attempts)\".format(ticket.FailCount)\n\n try:\n argv[\"sp_entity_id\"] = ticket.saml_req.sp_entity_id\n except KeyError:\n pass\n\n self.logger.debug(\"Login page HTML substitution arguments :\\n{!s}\".format(pprint.pformat(argv)))\n\n # Look for login page in user preferred language\n content = eduid_idp.mischttp.localized_resource(self.start_response, 'login.html', self.config, self.logger)\n if not content:\n raise eduid_idp.error.NotFound()\n\n # apply simplistic HTML formatting to template in 'res'\n return content.format(**argv).encode('utf-8')",
"def view_login(self):\n with self.client.get(\"/login\", 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.failure(\"Logged on: Got redirect to /home\")",
"def login_page():\n text = '<a href=\"%s\">Authenticate with Okta</a>'\n return text % create_auth_url()",
"def test_login_responser(self):\n response = self.client.get(reverse('cookbook:login'))\n self.assertContains(response, \"Sign in\")",
"def test_sad_login_empty_email(self):\n\n rv = self.login(\"\")\n assert rv.status_code in [404]\n assert b\"The provided email is invalid\" in rv.data",
"def get_message_link(self,message):\n \n data = {'chat_id': message.get('sender',{}).get('chat_id',None),\n 'message_id': message.get('id',None)\n }\n result = self._send_data('getMessageLink',data)\n if result.update:\n return result.update.get('link','')",
"def test_login_url(self):\r\n res = self.testapp.get('/login', status=200)\r\n\r\n body_str = u\"Log In\"\r\n form_str = u'name=\"login\"'\r\n\r\n self.assertTrue(\r\n body_str in res.body,\r\n msg=\"Request should contain Log In: \" + res.body)\r\n\r\n # There should be a login form on there.\r\n self.assertTrue(\r\n form_str in res.body,\r\n msg=\"The login input should be visible in the body:\" + res.body)"
] | [
"0.7230947",
"0.70962363",
"0.67971355",
"0.67545116",
"0.6748592",
"0.643117",
"0.6277573",
"0.5884468",
"0.5872838",
"0.5719129",
"0.5480234",
"0.5345491",
"0.5312241",
"0.53114134",
"0.5304375",
"0.52877814",
"0.52394485",
"0.5218567",
"0.52141786",
"0.5196675",
"0.5196465",
"0.5178575",
"0.5177982",
"0.5143283",
"0.5141931",
"0.5137977",
"0.5127364",
"0.51200795",
"0.51117986",
"0.5097591"
] | 0.7386957 | 0 |
The get_login_message response for link_only and no text passed returns as expected. | def test_message_default_no_text(self):
kwargs = dict(link_text=None, link_only=False, reset=False)
urls = self.get_or_make_links(('login', 'password_reset'))
for url in urls:
self.assertIsNotNone(url)
expected = self.mock_get_login_message(urls, **kwargs)
actual = self.form.get_login_message(**kwargs)
self.assertEqual(expected, actual) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_message_link_only_no_text(self):\n kwargs = dict(link_text=None, link_only=False, reset=False)\n kwargs['link_only'] = True\n urls = self.get_or_make_links(('login', 'password_reset'))\n for url in urls:\n self.assertIsNotNone(url)\n expected = self.mock_get_login_message(urls, **kwargs)\n actual = self.form.get_login_message(**kwargs)\n\n self.assertEqual(expected, actual)",
"def test_message_link_only_with_text(self):\n kwargs = dict(link_text=None, link_only=False, reset=False)\n kwargs['link_only'] = True\n kwargs['link_text'] = 'This is the text for the test - test_message_link_only_with_text'\n urls = self.get_or_make_links(('login', 'password_reset'))\n for url in urls:\n self.assertIsNotNone(url)\n expected = self.mock_get_login_message(urls, **kwargs)\n actual = self.form.get_login_message(**kwargs)\n\n self.assertEqual(expected, actual)",
"def test_message_default_with_text(self):\n kwargs = dict(link_text=None, link_only=False, reset=False)\n link_names = ('login', 'password_reset')\n text_template = 'The {} test text - test_message_default_with_text'\n kwargs['link_text'] = [text_template.format(name) for name in link_names]\n urls = self.get_or_make_links(link_names)\n for url in urls:\n self.assertIsNotNone(url)\n expected = self.mock_get_login_message(urls, **kwargs)\n actual = self.form.get_login_message(**kwargs)\n\n self.assertEqual(expected, actual)",
"def test_message_reset_link_only_no_text(self):\n kwargs = dict(link_text=None, link_only=False, reset=False)\n kwargs['link_only'] = True\n kwargs['reset'] = True\n urls = self.get_or_make_links(('login', 'password_reset'))\n for url in urls:\n self.assertIsNotNone(url)\n expected = self.mock_get_login_message(urls, **kwargs)\n actual = self.form.get_login_message(**kwargs)\n\n self.assertEqual(expected, actual)",
"def test_message_reset_link_only_with_text(self):\n kwargs = dict(link_text=None, link_only=False, reset=False)\n kwargs['link_only'] = True\n kwargs['reset'] = True\n kwargs['link_text'] = 'This is the text for the test - test_message_link_only_with_text'\n urls = self.get_or_make_links(('login', 'password_reset'))\n for url in urls:\n self.assertIsNotNone(url)\n expected = self.mock_get_login_message(urls, **kwargs)\n actual = self.form.get_login_message(**kwargs)\n\n self.assertEqual(expected, actual)",
"def test_message_reset_no_text(self):\n kwargs = dict(link_text=None, link_only=False, reset=False)\n kwargs['reset'] = True\n urls = self.get_or_make_links(('login', 'password_reset'))\n for url in urls:\n self.assertIsNotNone(url)\n expected = self.mock_get_login_message(urls, **kwargs)\n actual = self.form.get_login_message(**kwargs)\n\n self.assertEqual(expected, actual)",
"def test_message_reset_with_text(self):\n kwargs = dict(link_text=None, link_only=False, reset=False)\n kwargs['reset'] = True\n link_names = ('login', 'password_reset')\n text_template = 'The {} test text - test_message_default_with_text'\n kwargs['link_text'] = [text_template.format(name) for name in link_names]\n urls = self.get_or_make_links(link_names)\n for url in urls:\n self.assertIsNotNone(url)\n expected = self.mock_get_login_message(urls, **kwargs)\n actual = self.form.get_login_message(**kwargs)\n\n self.assertEqual(expected, actual)",
"def get_msg_login(self, username):\n return \"Welcome\"",
"def login_link(self):\n\t\tresponse = self.client.post(self._endpoint + \"/loginLink\")\n\t\treturn response.json[\"link\"]",
"def get_msg_login(self, username):\n return self.user_table[username]['msg_login']",
"def format_message(self, login: str, message: dict) -> str:\n login_from = login if message['incoming'] else self.username\n login_to = self.username if message['incoming'] else login\n return f'{login_from} -> {login_to}:\\n{message[\"text\"]}'",
"def test_login_page_content(self):\n response = self.app.get(\"/accounts/login/\")\n self.assertEqual(response.status_code, 200,\n \"Could not access /accounts/login/ route\")\n self.assertIn(b\"/accounts/create/\", response.data,\n \"Couldn't find link to /accounts/create/\")",
"def test_spa_get_bad_token(app, client, get_message):\n with capture_flashes() as flashes:\n with capture_passwordless_login_requests() as requests:\n response = client.post(\n \"/login\",\n json=dict(email=\"[email protected]\"),\n headers={\"Content-Type\": \"application/json\"},\n )\n assert response.headers[\"Content-Type\"] == \"application/json\"\n token = requests[0][\"login_token\"]\n time.sleep(1)\n\n response = client.get(\"/login/\" + token)\n assert response.status_code == 302\n split = urlsplit(response.headers[\"Location\"])\n assert \"localhost:8081\" == split.netloc\n assert \"/login-error\" == split.path\n qparams = dict(parse_qsl(split.query))\n assert all(k in qparams for k in [\"email\", \"error\", \"identity\"])\n\n msg = get_message(\"LOGIN_EXPIRED\", within=\"1 milliseconds\", email=\"[email protected]\")\n assert msg == qparams[\"error\"].encode(\"utf-8\")\n\n # Test mangled token\n token = (\n \"WyIxNjQ2MzYiLCIxMzQ1YzBlZmVhM2VhZjYwODgwMDhhZGU2YzU0MzZjMiJd.\"\n \"BZEw_Q.lQyo3npdPZtcJ_sNHVHP103syjM\"\n \"&url_id=fbb89a8328e58c181ea7d064c2987874bc54a23d\"\n )\n response = client.get(\"/login/\" + token)\n assert response.status_code == 302\n split = urlsplit(response.headers[\"Location\"])\n assert \"localhost:8081\" == split.netloc\n assert \"/login-error\" == split.path\n qparams = dict(parse_qsl(split.query))\n assert len(qparams) == 1\n assert all(k in qparams for k in [\"error\"])\n\n msg = get_message(\"INVALID_LOGIN_TOKEN\")\n assert msg == qparams[\"error\"].encode(\"utf-8\")\n assert len(flashes) == 0",
"def _get_plain_message (self) :\n return self._message",
"def get_message(self, user):\n return None",
"def optional_login(request):\n try:\n login_url = reverse('rest_framework:login')\n except NoReverseMatch:\n return ''\n\n snippet = \"<li><a href='{href}?next={next}'>Sing in</a></li>\"\n snippet = format_html(snippet, href=login_url, next=escape(request.path))\n\n return mark_safe(snippet)",
"def authenticate():\n return \"Please log in... Log in page\"",
"def optional_login(request):\n try:\n login_url = reverse('rest_framework:login')\n except NoReverseMatch:\n return ''\n\n snippet = \"<li><a href='{href}?next={next}'>Log in</a></li>\"\n snippet = format_html(snippet, href=login_url, next=escape(request.path))\n\n return mark_safe(snippet)",
"def assertLoginFailure(self, response):\n return self.assertInHTML(\n '<h1>Social Network Login Failure</h1>',\n str(response.content),\n )",
"def test_login_OK(self):\n rv = self.login('super',\n '1b3231655cebb7a1f783eddf27d254ca')\n assert 'Bienvenido' in rv.data",
"def loginAfterFeed():\n label = loginFunc(Camera())\n print(\"loginAfterFeed label:\", label)\n if label is None:\n return json.dumps({\"name\":\"error\"})\n else:\n return json.dumps({\"name\":label})",
"def getMessage():\n return message",
"def test_show_login_page(self):\n with self.client as c:\n\n res = c.get(\"/login\")\n html = res.get_data(as_text=True)\n\n self.assertEqual(res.status_code, 200)\n self.assertIn(\"Don't have an account?\", html)",
"def _show_login_page(self, ticket: SSOLoginData, requested_authn_context: Optional[str], redirect_uri) -> bytes:\n argv = eduid_idp.mischttp.get_default_template_arguments(self.context.config)\n argv.update(\n {\n \"action\": \"/verify\",\n \"username\": \"\",\n \"password\": \"\",\n \"key\": ticket.key,\n \"authn_reference\": requested_authn_context,\n \"redirect_uri\": redirect_uri,\n \"alert_msg\": \"\",\n \"sp_entity_id\": \"\",\n \"failcount\": ticket.FailCount,\n # SAMLRequest, RelayState and binding are used to re-create the ticket state if not found using `key'\n \"SAMLRequest\": escape(ticket.SAMLRequest, quote=True),\n \"RelayState\": escape(ticket.RelayState, quote=True),\n \"binding\": escape(ticket.binding, quote=True),\n }\n )\n\n # Set alert msg if FailCount is greater than zero\n if ticket.FailCount:\n argv[\"alert_msg\"] = \"INCORRECT\" # \"Incorrect username or password ({!s} attempts)\".format(ticket.FailCount)\n\n try:\n argv[\"sp_entity_id\"] = ticket.saml_req.sp_entity_id\n except KeyError:\n pass\n\n self.logger.debug(\"Login page HTML substitution arguments :\\n{!s}\".format(pprint.pformat(argv)))\n\n # Look for login page in user preferred language\n content = eduid_idp.mischttp.localized_resource(self.start_response, 'login.html', self.config, self.logger)\n if not content:\n raise eduid_idp.error.NotFound()\n\n # apply simplistic HTML formatting to template in 'res'\n return content.format(**argv).encode('utf-8')",
"def view_login(self):\n with self.client.get(\"/login\", 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.failure(\"Logged on: Got redirect to /home\")",
"def login_page():\n text = '<a href=\"%s\">Authenticate with Okta</a>'\n return text % create_auth_url()",
"def test_login_responser(self):\n response = self.client.get(reverse('cookbook:login'))\n self.assertContains(response, \"Sign in\")",
"def test_sad_login_empty_email(self):\n\n rv = self.login(\"\")\n assert rv.status_code in [404]\n assert b\"The provided email is invalid\" in rv.data",
"def get_message_link(self,message):\n \n data = {'chat_id': message.get('sender',{}).get('chat_id',None),\n 'message_id': message.get('id',None)\n }\n result = self._send_data('getMessageLink',data)\n if result.update:\n return result.update.get('link','')",
"def test_login_url(self):\r\n res = self.testapp.get('/login', status=200)\r\n\r\n body_str = u\"Log In\"\r\n form_str = u'name=\"login\"'\r\n\r\n self.assertTrue(\r\n body_str in res.body,\r\n msg=\"Request should contain Log In: \" + res.body)\r\n\r\n # There should be a login form on there.\r\n self.assertTrue(\r\n form_str in res.body,\r\n msg=\"The login input should be visible in the body:\" + res.body)"
] | [
"0.7386957",
"0.70962363",
"0.67971355",
"0.67545116",
"0.6748592",
"0.643117",
"0.6277573",
"0.5884468",
"0.5872838",
"0.5719129",
"0.5480234",
"0.5345491",
"0.5312241",
"0.53114134",
"0.5304375",
"0.52877814",
"0.52394485",
"0.5218567",
"0.52141786",
"0.5196675",
"0.5196465",
"0.5178575",
"0.5177982",
"0.5143283",
"0.5141931",
"0.5137977",
"0.5127364",
"0.51200795",
"0.51117986",
"0.5097591"
] | 0.7230947 | 1 |
If user has already confirmed an atypical username, it is used without further confirmation checks. | def test_confirmed_username(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_confirmation_username_not_email(self):\n pass",
"def confirm(key):\n manager = EmailManager.find_key(key)\n if not manager:\n # If key is wrong, return False\n return False\n\n if manager.is_active:\n # Do not reactivate users\n return False\n\n if manager.other_email:\n # If other_email\n if EmailManager.email_used(manager.other_email):\n # Other_email already being used by someone\n return False\n # Other email is not being used by anybody else, make it the active one\n\n # if username == email, set it as new email\n if manager.user.email == manager.user.username:\n manager.user.username = manager.other_email\n manager.user.email = manager.other_email\n\n manager.user.is_active = True\n manager.user.save()\n\n # Activate email\n manager.active = True\n manager.save()\n\n # Returns the activated User's obj\n return manager.user",
"def confirm_name_change(user, pending_name_change):\n user_profile = _UserProfile.objects.get(user=user)\n\n # Store old name in profile metadata\n meta = user_profile.get_meta()\n if 'old_names' not in meta:\n meta['old_names'] = []\n meta['old_names'].append(\n [user_profile.name, pending_name_change.rationale, datetime.datetime.now(UTC).isoformat()]\n )\n user_profile.set_meta(meta)\n\n user_profile.name = pending_name_change.new_name\n user_profile.save()\n pending_name_change.delete()",
"def username_prompt(): \n\n print(\"Valid usernames contain only the characters 'a-z', e.g. pdiddy.\")\n\n while True: \n username = str(input(\"Enter username to add: \"))\n confirm_name = str(input(\"To confirm, re-enter username: \"))\n \n if username != confirm_name or not re.match(\"^[a-z]+$\", username):\n print(TRY_AGAIN)\n continue \n \n else:\n print(\"OK, checking if user: %s exists...\" %(username))\n return username",
"def clean_username(self):\r\n username = self.cleaned_data.get(\"username\")\r\n\r\n if not username: \r\n return username\r\n\r\n \r\n if User.objects.filter(username__iexact=username).exclude(pk=self.instance.pk):\r\n raise forms.ValidationError(\"That username is already used.\")\r\n else:\r\n return username",
"def clean_username(self):\r\n try:\r\n user = User.objects.get(username__iexact=self.cleaned_data['username'])\r\n except User.DoesNotExist:\r\n return self.cleaned_data['username']\r\n raise forms.ValidationError(_(u'This username is already taken. Please choose another.'))",
"def validate_username(self, username):\n if username.data != current_user.username:\n user = User.query.filter_by(username=username.data).first()\n if user:\n raise ValidationError('That username already exists. Please choose another username.')",
"def clean_username(self):\n existing = User.objects.filter(username__iexact=self.cleaned_data['username'])\n if existing.exists():\n raise forms.ValidationError(_(\"This username is already taken.\"))\n else:\n return self.cleaned_data['username']",
"def __check_if_username_has_changed(self, input_username):\n\n user_id = get_data.get_id_by_username_from_db(input_username)\n if user_id:\n username = get_data.get_username_by_id(user_id)\n if username:\n if input_username != username:\n update_data.rename_user(user_id, username)\n helper.rename_user_dir(input_username, username)\n return username\n return input_username",
"def clean_username(self):\n existing = UserModel().objects.filter(username__iexact=self.cleaned_data['username'])\n if existing.exists():\n raise forms.ValidationError(_(\"A user with that username already exists.\"))\n else:\n return self.cleaned_data['username']",
"def test_configure_username_confirmation(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n # valid = self.form.is_valid()\n self.form.full_clean()\n names = (original_data.get(field_name, None) for field_name in self.form.constructor_fields)\n expected_name = '_'.join(name for name in names if name is not None).casefold()\n normalize = self.form.user_model.normalize_username\n if callable(normalize):\n expected_name = normalize(expected_name)\n expected_flag = 'False'\n\n self.assertNotIn(self.form.name_for_user, original_data)\n self.assertNotIn(self.form.name_for_user, original_fields)\n self.assertIn(get_html_name(self.form, self.form.name_for_user), self.form.data)\n self.assertIn(self.form.name_for_user, self.form.fields)\n self.assertNotIn(self.form.USERNAME_FLAG_FIELD, original_data)\n self.assertNotIn(self.form.USERNAME_FLAG_FIELD, original_fields)\n self.assertIn(get_html_name(self.form, self.form.USERNAME_FLAG_FIELD), self.form.data)\n self.assertIn(self.form.USERNAME_FLAG_FIELD, self.form.fields)\n self.assertEqual(expected_name, self.form.data.get(get_html_name(self.form, self.form.name_for_user), None))\n self.assertEqual(expected_flag, self.form.data.get(get_html_name(self.form, self.form.USERNAME_FLAG_FIELD)))\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields",
"def confirm_email(self, request, email_address):\n email_address.verified = True\n email_address.set_as_primary(conditional=True)\n email_address.save()\n\n u = get_user_model().objects.get(pk=email_address.user.id)\n u.is_active = True\n u.save()",
"async def confirm_user(self, name, splits_list=None):\n\n # Generates a list if not provided \n if splits_list is None:\n splits_list = await self._get_all_splits()\n\n # Returns True if name exists, False if name does not\n index = await self._exact_search(name, splits_list)\n return index != -1",
"def save(self, *args, **kwargs):\n if not self.require_confirm_email:\n User.objects.filter(is_active=False, deactivation_reason=\"pending\").update(\n is_active=True, deactivation_reason=None\n )\n if not self.invite_question_text:\n self.invite_question_text = \"What is your favourite book?\"\n super().save(*args, **kwargs)",
"def clean_username(self):\n username = self.cleaned_data['username']\n\n try:\n User.objects.get(username=username)\n except ObjectDoesNotExist:\n return username\n\n raise forms.ValidationError('Login is already in use.')",
"def testUsernameAlreadyThere(self):\r\n email = '[email protected]'\r\n new_user = UserMgr.signup_user(email, u'invite')\r\n DBSession.add(new_user)\r\n\r\n transaction.commit()\r\n\r\n user = DBSession.query(User).filter(User.username == email).one()\r\n\r\n url = quote('/{0}/reset/{1}'.format(\r\n user.email,\r\n user.activation.code\r\n ))\r\n\r\n res = self.app.post(\r\n url,\r\n params={\r\n 'password': u'testing',\r\n 'username': user.username,\r\n 'code': user.activation.code,\r\n 'new_username': u'admin',\r\n })\r\n self.assertIn('Username already', res.body)",
"def clean_email(self):\n # NOTE: all emails are stored in lower-case\n e = self.cleaned_data['email'].lower()\n try:\n user = User.objects.get(email=e)\n if not user.is_active:\n msg = 'This user account has not been confirmed yet'\n raise forms.ValidationError(msg)\n except User.DoesNotExist:\n msg = 'This email is not associated with an account'\n raise forms.ValidationError(msg)\n return e",
"def greet_user():\r\n username = get_stored_username()\r\n if username:\r\n correct = input(\"Are you \" + username + \"? (y/n) \")\r\n if correct == 'y':\r\n print(\"Welcome back, \" + username + \"!\")\r\n else:\r\n username = get_new_username()\r\n print(\"We'll remember you when you come back, \" + username + \"!\")\r\n else:\r\n username = get_new_username()\r\n print(\"We'll remember you when you come back, \" + username + \"!\")",
"def clean_username(self):\n username = self.cleaned_data.get(\"username\")\n if User.objects.filter(username=username).exists():\n LOGGER.warning(\"username already exists\", username=username)\n raise ValidationError(_(\"Username already exists\"))\n return username",
"def user_suggested(username):\n raise NotImplementedError()",
"def confirm_email(self):\n # The base class' implementation does nothing\n pass",
"def login_on_confirm(self, confirmation):\n date = timezone.now()\n user = confirmation.email_address.user\n user.is_active = True\n user.date_joined = date\n user.last_login = date\n user.save()\n confirmation.delete()\n if not self.request.user.is_anonymous():\n logout(self.request)\n return perform_login(self.request,\n user,\n app_settings.EmailVerificationMethod.NONE,\n redirect_url=self.success_url)",
"def UserName_availabity():\r\n try:\r\n \r\n UserName=request.args.get(\"UserName\")\r\n user_details=fetch_details(UserName)\r\n user_name=user_details[0]['UserName']\r\n if str(UserName)==str(user_name):\r\n msg=\"UserName is already taken kindly choose another one\"\r\n except IndexError:\r\n msg=\"UserName is available.\"\r\n return msg",
"def clean_username(self):\n data = self.cleaned_data['username']\n if '@' in data or '|' in data or ' ' in data or '+' in data:\n raise forms.ValidationError(_(u'Usernames should not have special characters.'))\n try:\n user = User.objects.get(username__exact=self.cleaned_data['username'])\n except User.DoesNotExist:\n return self.cleaned_data['username']\n raise forms.ValidationError(_(u'This username is already taken. Please choose another.'))",
"def password_confirm(self, password, confirm_password):\n return password == confirm_password",
"def clean_email(self):\n e = self.cleaned_data['email']\n try:\n user = User.objects.get(email=e)\n if not user.is_active:\n msg = 'This user account has not been confirmed yet'\n raise forms.ValidationError(msg)\n except User.DoesNotExist:\n pass\n # msg = 'This email is not associated with an account'\n # raise forms.ValidationError(msg)\n return e",
"def test_confirmation_required(self):\n with self._replace_stdin('confirm'):\n call_command(self.command, self.provider_hogwarts.slug)\n\n with pytest.raises(User.DoesNotExist):\n User.objects.get(username='harry')\n with pytest.raises(UserSocialAuth.DoesNotExist):\n self.find_user_social_auth_entry('harry')",
"def clean_username(self):\n c_d = self.cleaned_data\n if User.objects.exclude(id=c_d['id']).filter(\n username=c_d['username']):\n raise forms.ValidationError(u'The Username is already registered.')\n return c_d['username']",
"def verification_unique_username(value: str) -> str:\n\n user = User.objects.filter(username=value)\n if len(user) == 0:\n return value\n else:\n raise serializers.ValidationError('User with given credentials already exist')",
"def clean_username_again(self):\n if 'username' in self.cleaned_data:\n username = self.cleaned_data['username']\n username_again = self.cleaned_data['username_again']\n\n if username == username_again:\n return username\n else:\n return None\n\n raise forms.ValidationError('Logins do not match.')"
] | [
"0.6546913",
"0.645693",
"0.6228912",
"0.6119424",
"0.61139166",
"0.61052537",
"0.6049774",
"0.6000137",
"0.5972646",
"0.5958401",
"0.59570193",
"0.5955518",
"0.5894199",
"0.5881494",
"0.5861639",
"0.5856036",
"0.5800832",
"0.57938457",
"0.5792791",
"0.5792492",
"0.57751834",
"0.5774213",
"0.5769009",
"0.5767795",
"0.575458",
"0.57278657",
"0.57080495",
"0.5685194",
"0.56833714",
"0.5653143"
] | 0.692972 | 0 |
The computed_fields are added to fields if there is no error in username or other computed fields. | def test_fields_updated_with_computed(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_use_existing_computed_field_dict(self):\n if isinstance(self.form.computed_fields, list):\n self.form.computed_fields = self.form.get_computed_fields(self.form.computed_fields)\n self.form.fields.update(self.form.computed_fields) # only names in fields included in get_computed_field_names.\n result_names = self.form.get_computed_field_names([], self.form.fields)\n\n self.assertIsInstance(self.form.computed_fields, dict)\n self.assertIn('test_field', result_names)",
"def test_raise_on_corrupt_computed_fields(self):\n initial = self.form.computed_fields\n self.form.computed_fields = 'This is a broken value'\n with self.assertRaises(ImproperlyConfigured):\n self.form.get_computed_field_names([], self.form.fields)\n self.form.computed_fields = None\n with self.assertRaises(ImproperlyConfigured):\n self.form.get_computed_field_names([], self.form.fields)\n self.form.computed_fields = initial",
"def test_validation_errors_assigned_in_clean_computed_fields(self):\n name = 'test_field'\n message = \"This is the test error on test_field. \"\n response = ValidationError(message)\n expected_compute_errors = ErrorDict({name: response}) # similar to return of _clean_computed_fields\n original_func = deepcopy(self.form.test_func)\n def make_error(value): raise response\n self.form.test_func = make_error\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n self.form.cleaned_data = getattr(self.form, 'cleaned_data', {}) # mimic full_clean: cleaned_data is present\n actual_compute_errors = self.form._clean_computed_fields()\n\n self.assertDictEqual(expected_compute_errors, actual_compute_errors)\n self.form.test_func = original_func",
"def test_init_update_computed_field_names(self):\n original_request = self.request\n original_form = self.form\n computed = getattr(self.form, 'computed_fields', None)\n get_form = self.make_form_request()\n computed_fields = getattr(get_form, 'computed_fields', None)\n\n self.assertIsNotNone(computed)\n self.assertIsNotNone(computed_fields)\n self.assertIsNotNone(self.form.country_field_name)\n self.assertIn(self.form.country_field_name, computed_fields)\n\n self.request = original_request\n self.form = original_form",
"def test_field_compute_method_called_in_clean_computed_fields(self):\n name = 'test_field'\n expected = 'compute_confirmed'\n self.form.test_value = expected\n modified = self.form.test_func(expected)\n original_func = deepcopy(self.form.test_func)\n def pass_through(value): return value\n self.form.test_func = pass_through\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n original_errors = deepcopy(self.form._errors)\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n self.form.cleaned_data = getattr(self.form, 'cleaned_data', {}) # mimic full_clean: cleaned_data is present\n compute_errors = self.form._clean_computed_fields()\n actual = self.form.cleaned_data.get(name, None)\n\n self.assertFalse(compute_errors)\n self.assertEqual(expected, actual)\n\n self.form.test_func = original_func\n restored = self.form.test_func(expected)\n self.assertEqual(modified, restored)\n self.form._errors = original_errors",
"def test_get_critical_from_existing_fields(self):\n name = 'generic_field'\n opts = {'names': (name, ), 'alt_field': '', 'computed': False}\n expected_field = self.form.fields.get(name, None)\n actual_name, actual_field = self.form.get_critical_field(opts['names'])\n self.assertEqual(name, actual_name)\n self.assertEqual(expected_field, actual_field)",
"def test_validation_error_for_compute_error(self):\n name = 'test_field'\n message = \"This is the test error on test_field. \"\n response = ValidationError(message)\n original_errors = deepcopy(self.form._errors)\n expected_errors = ErrorDict() # similar to Form.full_clean\n expected_errors[name] = self.form.error_class()\n expected_errors[name].append(response) # similar to add_error(None, message) in _clean_computed...\n clean_message_on_compute_errors = \"Error occurred with the computed fields. \"\n clean_error_on_compute_errors = ValidationError(clean_message_on_compute_errors)\n expected_errors[NON_FIELD_ERRORS] = self.form.error_class(error_class='nonfield') # first add_error(None, err)\n expected_errors[NON_FIELD_ERRORS].append(clean_error_on_compute_errors) # similar to add_error(None, string)\n original_func = deepcopy(self.form.test_func)\n def make_error(value): raise response\n self.form.test_func = make_error\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.cleaned_data = getattr(self.form, 'cleaned_data', {}) # mimic full_clean: cleaned_data is present\n self.form._clean_form() # adds to Form._error if ValidationError raised by Form.clean.\n\n self.assertNotEqual(original_errors, self.form._errors)\n self.assertEqual(expected_errors, self.form._errors)\n\n if original_cleaned_data is None:\n del self.form.cleaned_data\n else:\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors\n self.form.test_func = original_func",
"def _validate_fields(self, change_fields):\n pass",
"def test_interface_compute_name_for_user(self):\n self.form.name_for_user = self.form._meta.model.USERNAME_FIELD\n self.form.name_for_email = self.form._meta.model.get_email_field_name()\n expected = \"Unique test response value\"\n\n def confirm_func(username_field_name=None, email_field_name=None): return expected\n original_func = self.form.username_from_email_or_names\n self.form.username_from_email_or_names = confirm_func\n actual = self.form.compute_name_for_user()\n self.form.username_from_email_or_names = original_func\n\n self.assertEqual(expected, actual)",
"def test_clean_moves_computed_fields_to_fields(self):\n name = 'test_field'\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n computed_names = list(self.form.computed_fields.keys())\n field_names = list(self.form.fields.keys())\n field_data = {f_name: f\"input_{f_name}_{i}\" for i, f_name in enumerate(field_names)}\n field_data.update({name: f\"value_{f_name}_{i}\" for i, f_name in enumerate(computed_names)})\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy() # mimic full_clean\n populated_cleaned_data = deepcopy(original_cleaned_data or {})\n populated_cleaned_data.update(field_data)\n self.form.cleaned_data = populated_cleaned_data.copy() # ensure cleaned_data is present (mimic full_clean)\n final_cleaned_data = self.form.clean()\n\n self.assertIn(name, computed_names)\n self.assertNotIn(name, field_names)\n self.assertEqual(1, len(computed_names))\n self.assertIn(name, self.form.fields)\n self.assertNotEqual(original_cleaned_data, final_cleaned_data)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def test_cleaned_data_modified_by_clean_computed_fields(self):\n name = 'test_field'\n field = self.form.computed_fields.get(name) # getattr(self.form, name) for BoundField instance for Field.\n value = self.form.compute_test_field()\n value = field.clean(value)\n expected = self.form.test_func(value)\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n original_errors = deepcopy(self.form._errors)\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n self.form.cleaned_data = getattr(self.form, 'cleaned_data', {}) # mimic full_clean: cleaned_data is present\n original = self.form.cleaned_data.get(name, None)\n compute_errors = self.form._clean_computed_fields()\n actual = self.form.cleaned_data.get(name, '')\n\n self.assertFalse(compute_errors)\n self.assertNotEqual(original, actual)\n self.assertNotEqual(original, expected)\n self.assertEqual(expected, actual)\n\n self.form._errors = original_errors",
"def set_up_fields(self, fields):\n self.fields = {\n 'name': self.name,\n 'email': self.email\n }\n for key in fields.keys():\n # special keys first, not to be used in the template\n if key.upper() == 'CC':\n self.is_cc = fields[key]\n elif key.upper() == 'BCC':\n self.is_bcc = fields[key]\n else:\n self.fields[key] = fields[key]",
"def build_custom_user_fields(\n form_cls,\n include_entries=False,\n fields_kwargs=None,\n field_entries_kwargs=None,\n blacklisted_items=(),\n):\n if fields_kwargs is None:\n fields_kwargs = {}\n if field_entries_kwargs is None:\n field_entries_kwargs = {}\n\n fields = []\n new_fields = UserFields.query.filter_by(**fields_kwargs).all()\n user_fields = {}\n\n # Only include preexisting values if asked\n if include_entries is True:\n for f in UserFieldEntries.query.filter_by(**field_entries_kwargs).all():\n user_fields[f.field_id] = f.value\n\n for field in new_fields:\n if field.name.lower() in blacklisted_items:\n continue\n\n form_field = getattr(form_cls, f\"fields[{field.id}]\")\n\n # Add the field_type to the field so we know how to render it\n form_field.field_type = field.field_type\n\n # Only include preexisting values if asked\n if include_entries is True:\n initial = user_fields.get(field.id, \"\")\n form_field.data = initial\n if form_field.render_kw:\n form_field.render_kw[\"data-initial\"] = initial\n else:\n form_field.render_kw = {\"data-initial\": initial}\n\n fields.append(form_field)\n return fields",
"def test_field_clean_method_called_in_clean_computed_fields(self):\n name = 'test_field'\n expected = 'clean_confirmed'\n original_func = deepcopy(self.form.test_func)\n def replace_value(value): return expected\n self.form.test_func = replace_value\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n field = self.form.computed_fields.get(name) # getattr(self.form, name)\n # initial_value = self.get_initial_for_field(field, name)\n value = getattr(self.form, 'compute_%s' % name)()\n value = field.clean(value)\n original_errors = deepcopy(self.form._errors)\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n cleaned_data = getattr(self.form, 'cleaned_data', {})\n cleaned_data.update({name: value}) # make sure the original cleaned_data for the field is set.\n self.form.cleaned_data = cleaned_data # ensure cleaned_data is present (mimic full_clean)\n compute_errors = self.form._clean_computed_fields()\n actual = self.form.cleaned_data.get(name, None)\n\n self.assertFalse(compute_errors)\n self.assertEqual(expected, actual)\n self.assertNotEqual(expected, value)\n self.assertNotEqual(expected, self.form.test_value)\n\n self.form.test_func = original_func\n self.form._errors = original_errors",
"def test_constructor_fields_used_when_email_fails(self):\n self.form.name_for_user = self.form._meta.model.USERNAME_FIELD\n self.form.name_for_email = self.form._meta.model.get_email_field_name()\n existing_email = self.user.email\n new_info = {'first_name': \"Newbie\", 'last_name': \"Newsome\", 'email': existing_email}\n original_data = self.form.data\n test_data = original_data.copy()\n test_data.update(new_info)\n test_data._mutable = False\n self.form.data = test_data\n self.form.is_bound = True\n self.form.cleaned_data = new_info.copy()\n names = (new_info[field_name] for field_name in self.form.constructor_fields)\n expected = '_'.join(names).casefold()\n UserModel = get_user_model()\n cur_user = self.user\n found_user = UserModel.objects.get(username=cur_user.username)\n\n self.assertEqual(cur_user, found_user)\n for key, value in new_info.items():\n self.assertIn(key, self.form.cleaned_data)\n if key in (self.form.name_for_user, self.form.name_for_email):\n continue\n self.assertNotEqual(getattr(self.user, key, None), value)\n result = self.form.username_from_email_or_names(self.form.name_for_user, self.form.name_for_email)\n self.assertEqual(expected, result)\n\n self.form.data = original_data\n del self.form.cleaned_data",
"def test_cleaned_data_for_compute_success(self):\n name = 'test_field'\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n computed_names = list(self.form.computed_fields.keys())\n field_names = list(self.form.fields.keys())\n field_data = {f_name: f\"input_{f_name}_{i}\" for i, f_name in enumerate(field_names)}\n field_data.update({name: f\"value_{f_name}_{i}\" for i, f_name in enumerate(computed_names)})\n original_errors = deepcopy(self.form._errors)\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n original_cleaned_data = deepcopy(getattr(self.form, 'cleaned_data', None))\n populated_cleaned_data = deepcopy(original_cleaned_data or {})\n populated_cleaned_data.update(field_data)\n self.form.cleaned_data = populated_cleaned_data.copy() # ensure cleaned_data is present (mimic full_clean)\n final_cleaned_data = self.form.clean()\n\n self.assertIn(name, computed_names)\n self.assertNotIn(name, field_names)\n self.assertIn(name, populated_cleaned_data)\n self.assertIn(name, final_cleaned_data)\n self.assertNotEqual(original_cleaned_data, final_cleaned_data)\n\n if original_cleaned_data is None:\n del self.form.cleaned_data\n else:\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors",
"def generate_altered_fields(self):\n result = super(MigrationAutodetector, self).generate_altered_fields()\n self.generate_sql_changes()\n return result",
"def get_missing_field(self, name):\n source = getattr(self.form, 'removed_fields', {})\n if issubclass(self.form.__class__, ComputedFieldsMixIn):\n source = self.form.computed_fields\n field = source.pop(name, None)\n return field",
"def getcustomfields():\n for idx in range(len(user.collection_fields)):\n query = None\n\n # Check field table for field\n db_instance = dbq.exec_db_query_dict(dbq.get_field, user.collection_fields[idx].id)\n\n if db_instance == None:\n query = dbq.custom_field_insert\n query_data = {'field_id': user.collection_fields[idx].id,\n 'field_name': user.collection_fields[idx].name, \n 'insert_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S') }\n\n elif db_instance['field_name'] != user.collection_fields[idx].name :\n query = dbq.custom_field_update\n query_data = {'field_id': user.collection_fields[idx].id,\n 'field_name': user.collection_fields[idx].name, \n 'update_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S') }\n\n if query != None:\n dbq.exec_db_query(query, query_data, query_type='insert')",
"def set_fields(self, fields: FieldDict):\n super().set_fields(fields)\n # bind fields to attrs\n for attr in ('a', 'b'):\n setattr(self, f'field_{attr}', self.fields[getattr(self, attr)])\n # get error messages\n dump_error = self.error_cls(self.get_error_message(\n self.op, a=self.field_a.dump_source, b=self.field_b.dump_source))\n load_error = self.error_cls(self.get_error_message(\n self.op, a=self.field_a.load_source, b=self.field_b.load_source))\n # set partial arguments for `validate`\n self.validate_dump = partial(\n self.validate,\n a_key=self.field_a.dump_target,\n b_key=self.field_b.dump_target,\n error=dump_error)\n self.validate_load = partial(\n self.validate,\n a_key=self.field_a.load_target,\n b_key=self.field_b.load_target,\n error=load_error)",
"def attach_custom_user_fields(form_cls, **kwargs):\n new_fields = UserFields.query.filter_by(**kwargs).all()\n for field in new_fields:\n validators = []\n if field.required:\n validators.append(InputRequired())\n\n if field.field_type == \"text\":\n input_field = StringField(\n field.name, description=field.description, validators=validators\n )\n elif field.field_type == \"boolean\":\n input_field = BooleanField(\n field.name, description=field.description, validators=validators\n )\n\n setattr(form_cls, f\"fields[{field.id}]\", input_field)",
"def test_cleaned_data_for_compute_error(self):\n name = 'test_field'\n message = \"This is the test error on test_field. \"\n original_errors = deepcopy(self.form._errors)\n response = ValidationError(message)\n original_func = deepcopy(self.form.test_func)\n def make_error(value): raise response\n self.form.test_func = make_error\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n computed_names = list(self.form.computed_fields.keys())\n field_names = list(self.form.fields.keys())\n field_data = {f_name: f\"input_{f_name}_{i}\" for i, f_name in enumerate(field_names)}\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n original_cleaned_data = deepcopy(getattr(self.form, 'cleaned_data', None))\n populated_cleaned_data = deepcopy(original_cleaned_data or {})\n populated_cleaned_data.update(field_data)\n populated_cleaned_data.update({name: f\"value_{f_name}_{i}\" for i, f_name in enumerate(computed_names)})\n self.form.cleaned_data = populated_cleaned_data.copy() # ensure cleaned_data is present (mimic full_clean)\n\n with self.assertRaises(ValidationError):\n self.form.clean()\n final_cleaned_data = self.form.cleaned_data\n self.assertIn(name, computed_names)\n self.assertNotIn(name, field_names)\n self.assertIn(name, populated_cleaned_data)\n self.assertNotIn(name, final_cleaned_data)\n self.assertNotEqual(original_cleaned_data, final_cleaned_data)\n self.assertNotEqual(populated_cleaned_data, final_cleaned_data)\n\n if original_cleaned_data is None:\n del self.form.cleaned_data\n else:\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors\n self.form.test_func = original_func",
"def __createFields(self):\n fields = self.updateFields\n for field in fields:\n self.__createField(field)",
"def _modify(self, fields):\n return fields",
"def _add_fields(self, fields):\n for field in fields:\n self.add(field)",
"def __call__(self, form, field):\n\t\tif not hasattr(self.model, self.field_name):\n\t\t\tmessage = \"Terjadi kesalahan, hubungi administrator!\"\n\t\t\tfield.errors = []\n\t\t\traise validators.StopValidation(message)\n\n\t\tif field.data and isinstance(field.data, string_types) and \\\n\t\t\tfield.data.strip():\n\t\t\t\tobj = getattr(self.model, self.field_name)\n\t\t\t\tuser = self.model.query.filter(obj == field.data).first()\n\t\t\t\tif user:\n\t\t\t\t\tfield.errors = []\n\t\t\t\t\tif self.message is None:\n\t\t\t\t\t\tmessage = \"Data {} sudah ada!\".format(self.field_name)\n\t\t\t\t\telse:\n\t\t\t\t\t\tmessage = self.message\n\t\t\t\t\traise validators.StopValidation(message)",
"def _post_clean(self):\r\n super(NgModelFormMixin, self)._post_clean()\r\n if self._errors and self.prefix:\r\n self._errors = ErrorDict((self.add_prefix(name), value) for name, value in self._errors.items())",
"def _check_name_composing_fields(cls, **_kwargs: Any) -> List[checks.CheckMessage]:\n if not cls.name_composing_fields:\n return [\n checks.Warning(\n \"You must specify the fields that make up the name by \"\n \"listing them in name_composing_fields.\",\n obj=cls.__name__\n )\n ]\n errors = []\n for field in cls.name_composing_fields:\n try:\n get_fields_and_lookups(cls, field)\n except (exceptions.FieldDoesNotExist, exceptions.FieldError) as e:\n errors.append(\n checks.Error(\n \"Attribute 'name_composing_fields' contains invalid item: \"\n \"'%s'. %s\" % (field, e),\n obj=cls\n )\n )\n return errors",
"def _set_additional_fields(self, data):\n # Remove the non required rules data.\n if 'rules' in data:\n del data['rules']\n # Change description into proper string.\n data['description'] = re.sub(\"[\\'\\\"]\", \"\", data['description'])\n # Calculate and update the premium field.\n premium = str(data.get('premium', \"false\")).lower() == 'true'\n data['pvtVuln'] = premium\n return data",
"def _process_plugin_data(self, fields, fetch_related_data=False):\n for field, default_value in fields:\n try:\n setattr(\n self.data,\n field,\n self.plugin_data.get(field, default_value)\n )\n except Exception:\n setattr(self.data, field, default_value)"
] | [
"0.63890314",
"0.62018245",
"0.6116187",
"0.59539616",
"0.5692047",
"0.55805045",
"0.5535306",
"0.5493999",
"0.5454478",
"0.54456073",
"0.5443392",
"0.5390811",
"0.53575176",
"0.53219974",
"0.5263193",
"0.524624",
"0.52195275",
"0.515524",
"0.5153089",
"0.51446986",
"0.50882757",
"0.50820595",
"0.50573677",
"0.5054569",
"0.50526315",
"0.503235",
"0.5030486",
"0.49954978",
"0.49953526",
"0.49890208"
] | 0.654207 | 0 |
Raises ImproperlyConfigured if flag field cannot be found for configure_username_confirmation. | def test_raise_missing_flag_field(self):
original_data = self.form.data
original_fields = self.form.fields
original_flag = self.form.USERNAME_FLAG_FIELD
original_cleaned_data = getattr(self.form, 'cleaned_data', None)
original_errors = getattr(self.form, '_errors', None)
self.form.data = original_data.copy()
self.form.fields = original_fields.copy()
self.form.USERNAME_FLAG_FIELD = 'Not a valid field name'
self.form.cleaned_data = {self.form.name_for_user: 'test_username', self.form.name_for_email: 'test_email'}
# self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()
self.form._errors = None if original_errors is None else original_errors.copy()
with self.assertRaises(ImproperlyConfigured):
self.form.configure_username_confirmation()
self.form.data = original_data
self.form.fields = original_fields
self.form.USERNAME_FLAG_FIELD = original_flag
self.form.cleaned_data = original_cleaned_data
self.form._errors = original_errors
if original_cleaned_data is None:
del self.form.cleaned_data
if original_errors is None:
del self.form._errors | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_no_flag_handle_flag_field(self):\n original_flag_name = self.form.USERNAME_FLAG_FIELD\n self.form.USERNAME_FLAG_FIELD = \"This is not a valid field name\"\n expected = None\n actual = self.form.handle_flag_field(self.form.name_for_email, self.form.name_for_user)\n\n self.assertEqual(expected, actual)\n self.form.USERNAME_FLAG_FIELD = original_flag_name",
"def AddUsernameFlag(parser, required=False):\n help_text = \"\"\"\\\n Username that Database Migration Service uses to connect to the\n database. Database Migration Service encrypts the value when storing it.\n \"\"\"\n parser.add_argument('--username', help=help_text, required=required)",
"def test_configure_username_confirmation(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n # valid = self.form.is_valid()\n self.form.full_clean()\n names = (original_data.get(field_name, None) for field_name in self.form.constructor_fields)\n expected_name = '_'.join(name for name in names if name is not None).casefold()\n normalize = self.form.user_model.normalize_username\n if callable(normalize):\n expected_name = normalize(expected_name)\n expected_flag = 'False'\n\n self.assertNotIn(self.form.name_for_user, original_data)\n self.assertNotIn(self.form.name_for_user, original_fields)\n self.assertIn(get_html_name(self.form, self.form.name_for_user), self.form.data)\n self.assertIn(self.form.name_for_user, self.form.fields)\n self.assertNotIn(self.form.USERNAME_FLAG_FIELD, original_data)\n self.assertNotIn(self.form.USERNAME_FLAG_FIELD, original_fields)\n self.assertIn(get_html_name(self.form, self.form.USERNAME_FLAG_FIELD), self.form.data)\n self.assertIn(self.form.USERNAME_FLAG_FIELD, self.form.fields)\n self.assertEqual(expected_name, self.form.data.get(get_html_name(self.form, self.form.name_for_user), None))\n self.assertEqual(expected_flag, self.form.data.get(get_html_name(self.form, self.form.USERNAME_FLAG_FIELD)))\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields",
"def test_confirmed_username(self):\n pass",
"def test_confirmation_username_not_email(self):\n pass",
"def test_email_works_as_username_handle_flag_field(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n email_val = self.form_test_data.get(self.form.name_for_email) # was overwritten for form request.\n new_cleaned_data = {self.form.name_for_user: 'test_value', self.form.name_for_email: email_val}\n new_cleaned_data[self.form.USERNAME_FLAG_FIELD] = False\n user_field = self.form.computed_fields.pop(self.form.name_for_user, None)\n self.form.fields.update({self.form.name_for_user: user_field})\n email_field = self.form.fields[self.form.name_for_email]\n email_field.initial = getattr(self.user, self.form.name_for_user)\n self.form.cleaned_data = new_cleaned_data.copy()\n expected = {}\n actual = self.form.handle_flag_field(self.form.name_for_email, self.form.name_for_user)\n actual_username = self.form.cleaned_data.get(self.form.name_for_user, None)\n\n self.assertIsNotNone(email_val)\n self.assertIsNotNone(user_field)\n self.assertTrue(email_field.has_changed(email_field.initial, self.form.cleaned_data[self.form.name_for_email]))\n self.assertNotEqual(getattr(self.user, self.form.name_for_user), email_val)\n self.assertNotEqual(new_cleaned_data[self.form.name_for_user], actual_username)\n self.assertEqual(email_val, actual_username)\n self.assertEqual(expected, actual)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def test_bad_flag_handle_flag_field(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n email_val = self.form_test_data.get(self.form.name_for_email) # was overwritten for form request.\n new_cleaned_data = {self.form.name_for_user: 'test_value', self.form.name_for_email: email_val}\n new_cleaned_data[self.form.USERNAME_FLAG_FIELD] = True\n user_field = self.form.computed_fields.pop(self.form.name_for_user, None)\n self.form.fields.update({self.form.name_for_user: user_field})\n email_field = self.form.fields[self.form.name_for_email]\n email_field.initial = getattr(self.user, self.form.name_for_user)\n self.form.cleaned_data = new_cleaned_data.copy()\n message = \"Un-check the box, or leave empty, if you want to use this email address. \"\n expected = {self.form.USERNAME_FLAG_FIELD: message}\n actual = self.form.handle_flag_field(self.form.name_for_email, self.form.name_for_user)\n actual_username = self.form.cleaned_data.get(self.form.name_for_user, None)\n\n self.assertIsNotNone(email_val)\n self.assertIsNotNone(user_field)\n self.assertTrue(email_field.has_changed(email_field.initial, self.form.cleaned_data[self.form.name_for_email]))\n self.assertNotEqual(getattr(self.user, self.form.name_for_user), email_val)\n self.assertEqual(new_cleaned_data[self.form.name_for_user], actual_username)\n self.assertNotEqual(email_val, actual_username)\n self.assertEqual(expected, actual)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def test_message_configure_username_confirmation(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n original_clean = self.form.clean\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n self.form.cleaned_data = {self.form.name_for_user: 'test_username', self.form.name_for_email: 'test_email'}\n def replace_clean(): raise ImproperlyConfigured(\"Unexpected Clean Method Called. \")\n self.form.clean = replace_clean\n\n login_link = self.form.get_login_message(link_text='login to existing account', link_only=True)\n expected_email_error = \"Use a non-shared email, or {}. \".format(login_link)\n e_note = \"Typically people have their own unique email address, which you can update. \"\n e_note += \"If you share an email with another user, then you will need to create a username for your login. \"\n expected_user_error = e_note\n title = \"Login with existing account, change to a non-shared email, or create a username. \"\n message = \"Did you already make an account, or have one because you've had classes with us before? \"\n expected_message = format_html(\n \"<h3>{}</h3> <p>{} <br />{}</p>\",\n title,\n message,\n self.form.get_login_message(reset=True),\n )\n # print(\"=============== test_configure_username_confirmation ===================\")\n actual_message = self.form.configure_username_confirmation()\n actual_email_error = ''.join(self.form._errors.get(self.form.name_for_email))\n actual_user_error = ''.join(self.form._errors.get(self.form.name_for_user))\n # print(\"-----------------------------------------------------------\")\n # pprint(self.form)\n # print(\"-----------------------------------------------------------\")\n # pprint(expected_message)\n # print(\"*********************************\")\n # pprint(actual_message)\n # print(\"-----------------------------------------------------------\")\n # pprint(expected_email_error)\n # print(\"*********************************\")\n # pprint(actual_email_error)\n # print(\"-----------------------------------------------------------\")\n # pprint(expected_user_error)\n # print(\"*********************************\")\n # pprint(actual_user_error)\n # print(\"-----------------------------------------------------------\")\n\n self.assertEqual(expected_message, actual_message)\n self.assertEqual(expected_email_error, actual_email_error)\n self.assertEqual(expected_user_error, actual_user_error)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.clean = original_clean\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def test_username_of_email_exists_handle_flag_field(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n email_val = getattr(self.user, self.form.name_for_user, None)\n new_cleaned_data = {self.form.name_for_user: email_val, self.form.name_for_email: email_val}\n new_cleaned_data[self.form.USERNAME_FLAG_FIELD] = False\n user_field = self.form.computed_fields.pop(self.form.name_for_user, None)\n self.form.fields.update({self.form.name_for_user: user_field})\n self.form.cleaned_data = new_cleaned_data.copy()\n expected_message = \"You must give a unique email not shared with other users (or create a username). \"\n expected = {self.form.name_for_email: expected_message}\n actual = self.form.handle_flag_field(self.form.name_for_email, self.form.name_for_user)\n\n self.assertIsNotNone(email_val)\n self.assertIsNotNone(user_field)\n self.assertEqual(email_val, self.form.data.get(get_html_name(self.form, self.form.name_for_email), None))\n self.assertEqual(expected, actual)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def require_setting(name, feature='this feature'):\n if not self.settings.get(name):\n raise Exception('You must define the \"%s\" setting in your '\n 'application to use %s' % (name, feature))",
"def check_settings(self):\r\n pass",
"def _check_config(self):",
"def test_clean_country_flag(self):\n # country_flag = self.cleaned_data.get('country_flag', None)\n # field = self.fields.get(self.country_field_name, None)\n # if not field and hasattr(self, 'computed_fields'):\n # field = self.computed_fields.get(self.country_field_name, None)\n # if field.initial == self.cleaned_data.get(self.country_field_name, None)\n pass",
"def _check_settings(self):\n if self.api_key is None:\n raise ImproperlyConfigured(\"You must provide an API key.\")",
"def check_settings(self):\n pass",
"def confirmation_failed(self):",
"def test_handle_flag_error(self):\n pass",
"def AddPasswordFlag(parser):\n parser.add_argument(\n '--password',\n required=True,\n help=\"Initial password for the 'postgres' user.\")",
"def username_required(func):\n @wraps(func)\n def wrap(self, *args, **kwargs):\n if not self.username:\n raise AssertionError('CPT information needs to be configured')\n return func(self, *args, **kwargs)\n return wrap",
"def enable_user(UserName=None, AuthenticationType=None):\n pass",
"def test_setup(self):\n self.assertEqual(self.form._meta.model.USERNAME_FIELD, self.form.name_for_user)\n self.assertEqual(self.form._meta.model.get_email_field_name(), self.form.name_for_email)\n self.assertIn(self.form._meta.model.get_email_field_name(), self.form.fields)\n self.assertNotIn('email_field', self.form.fields)",
"def enable_confirmation_mode(self, nFlags = 0):\n\t\treturn Job(SDK.PrlSrv_EnableConfirmationMode(self.handle, nFlags)[0])",
"def check_for_setup_error(self):\n super(RBDISCSIDriver, self).check_for_setup_error()\n\n required_options = ['rbd_iscsi_api_user',\n 'rbd_iscsi_api_password',\n 'rbd_iscsi_api_url',\n 'rbd_iscsi_target_iqn']\n\n for attr in required_options:\n val = getattr(self.configuration, attr)\n if not val:\n raise exception.InvalidConfigurationValue(option=attr,\n value=val)",
"def ajax_enable(request):\r\n if not request.user.is_authenticated():\r\n raise PermissionDenied\r\n\r\n UserPreference.objects.get_or_create(\r\n user=request.user,\r\n key=NOTIFICATION_PREF_KEY,\r\n defaults={\r\n \"value\": UsernameCipher.encrypt(request.user.username)\r\n }\r\n )\r\n\r\n return HttpResponse(status=204)",
"def _username(self):\n if 'username' not in self._config:\n self._config['username'] = self._UI.get_input(\"Please enter your trac username: \")\n self._config._write_config()\n return self._config['username']",
"def validate_config(self):\n pass",
"def validate_config(self):\n pass",
"def _validate_config(self):\n pass",
"def accounts_setup(request):\n if request.method == 'POST':\n form = UsernameSetupForm(request.POST, instance=request.user)\n if form.is_valid():\n username = form.clean_username()\n request.user.username = username\n request.user.save()\n request.user.userprofile.first_time = False\n request.user.userprofile.save()\n return HttpResponseRedirect('/p/')\n else:\n form = UsernameSetupForm()\n return render(request, \"accounts_setup.html\", {\"form\":form})",
"def test_confirmation_required(self):\n with self._replace_stdin('confirm'):\n call_command(self.command, self.provider_hogwarts.slug)\n\n with pytest.raises(User.DoesNotExist):\n User.objects.get(username='harry')\n with pytest.raises(UserSocialAuth.DoesNotExist):\n self.find_user_social_auth_entry('harry')"
] | [
"0.59824324",
"0.5870834",
"0.55834264",
"0.55595756",
"0.54770535",
"0.5310007",
"0.5213108",
"0.5159476",
"0.5083913",
"0.50675964",
"0.5053425",
"0.4969892",
"0.49602443",
"0.49582785",
"0.49546963",
"0.4833263",
"0.48224783",
"0.48180395",
"0.48155475",
"0.47795367",
"0.47565943",
"0.47550955",
"0.473663",
"0.4708724",
"0.46970522",
"0.46913102",
"0.46913102",
"0.46904016",
"0.4686674",
"0.46773466"
] | 0.62331486 | 0 |
The configure_username_confirmation method modifies the data, & fields, and returns expected message. | def test_configure_username_confirmation(self):
original_data = self.form.data
original_fields = self.form.fields
original_computed_fields = self.form.computed_fields
self.form.data = original_data.copy()
self.form.fields = original_fields.copy()
self.form.computed_fields = original_computed_fields.copy()
# valid = self.form.is_valid()
self.form.full_clean()
names = (original_data.get(field_name, None) for field_name in self.form.constructor_fields)
expected_name = '_'.join(name for name in names if name is not None).casefold()
normalize = self.form.user_model.normalize_username
if callable(normalize):
expected_name = normalize(expected_name)
expected_flag = 'False'
self.assertNotIn(self.form.name_for_user, original_data)
self.assertNotIn(self.form.name_for_user, original_fields)
self.assertIn(get_html_name(self.form, self.form.name_for_user), self.form.data)
self.assertIn(self.form.name_for_user, self.form.fields)
self.assertNotIn(self.form.USERNAME_FLAG_FIELD, original_data)
self.assertNotIn(self.form.USERNAME_FLAG_FIELD, original_fields)
self.assertIn(get_html_name(self.form, self.form.USERNAME_FLAG_FIELD), self.form.data)
self.assertIn(self.form.USERNAME_FLAG_FIELD, self.form.fields)
self.assertEqual(expected_name, self.form.data.get(get_html_name(self.form, self.form.name_for_user), None))
self.assertEqual(expected_flag, self.form.data.get(get_html_name(self.form, self.form.USERNAME_FLAG_FIELD)))
self.form.data = original_data
self.form.fields = original_fields
self.form.computed_fields = original_computed_fields | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_message_configure_username_confirmation(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n original_clean = self.form.clean\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n self.form.cleaned_data = {self.form.name_for_user: 'test_username', self.form.name_for_email: 'test_email'}\n def replace_clean(): raise ImproperlyConfigured(\"Unexpected Clean Method Called. \")\n self.form.clean = replace_clean\n\n login_link = self.form.get_login_message(link_text='login to existing account', link_only=True)\n expected_email_error = \"Use a non-shared email, or {}. \".format(login_link)\n e_note = \"Typically people have their own unique email address, which you can update. \"\n e_note += \"If you share an email with another user, then you will need to create a username for your login. \"\n expected_user_error = e_note\n title = \"Login with existing account, change to a non-shared email, or create a username. \"\n message = \"Did you already make an account, or have one because you've had classes with us before? \"\n expected_message = format_html(\n \"<h3>{}</h3> <p>{} <br />{}</p>\",\n title,\n message,\n self.form.get_login_message(reset=True),\n )\n # print(\"=============== test_configure_username_confirmation ===================\")\n actual_message = self.form.configure_username_confirmation()\n actual_email_error = ''.join(self.form._errors.get(self.form.name_for_email))\n actual_user_error = ''.join(self.form._errors.get(self.form.name_for_user))\n # print(\"-----------------------------------------------------------\")\n # pprint(self.form)\n # print(\"-----------------------------------------------------------\")\n # pprint(expected_message)\n # print(\"*********************************\")\n # pprint(actual_message)\n # print(\"-----------------------------------------------------------\")\n # pprint(expected_email_error)\n # print(\"*********************************\")\n # pprint(actual_email_error)\n # print(\"-----------------------------------------------------------\")\n # pprint(expected_user_error)\n # print(\"*********************************\")\n # pprint(actual_user_error)\n # print(\"-----------------------------------------------------------\")\n\n self.assertEqual(expected_message, actual_message)\n self.assertEqual(expected_email_error, actual_email_error)\n self.assertEqual(expected_user_error, actual_user_error)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.clean = original_clean\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def test_confirmed_username(self):\n pass",
"def test_confirmation_username_not_email(self):\n pass",
"def configure_username(device, username, pwd, encryption=0, privilege=''):\n try:\n # Update str with password encryption level\n if encryption:\n pwd = '{encryption} {pwd}'.format(encryption=encryption,pwd=pwd)\n if privilege:\n username = '{username} privilege {privilege}'.format(username=username,privilege=privilege)\n device.configure('username {username} password {pwd}'.format(username=username,pwd=pwd))\n except SubCommandFailure:\n raise SubCommandFailure(\n \"Failed to configure user {username}\".format(username=username)\n )",
"def test_focus_update_for_configure_username_confirmation(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n original_errors = getattr(self.form, '_errors', None)\n original_focus = getattr(self.form, 'named_focus', None)\n original_focus_method = getattr(self.form, 'assign_focus_field', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form.cleaned_data = {self.form.name_for_user: 'test_username', self.form.name_for_email: 'test_email'}\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n self.form.named_focus = ''\n if original_focus_method is None:\n def mock_focus_method(name, *args, **kwargs): return name\n setattr(self.form, 'assign_focus_field', mock_focus_method)\n message = self.form.configure_username_confirmation()\n message = None if not message else message\n expected = self.form.name_for_email\n actual = getattr(self.form, 'named_focus', None)\n\n self.assertIsNotNone(message)\n self.assertTrue(hasattr(self.form, 'assign_focus_field'))\n self.assertEqual(expected, self.form.assign_focus_field(expected))\n self.assertEqual(expected, actual)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form.named_focus = original_focus\n self.form.assign_focus_field = original_focus_method\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors\n if original_focus is None:\n del self.form.named_focus\n if original_focus_method is None:\n del self.form.assign_focus_field\n if original_cleaned_data is None:\n del self.form.cleaned_data\n if original_errors is None:\n del self.form._errors",
"def _username(self):\n if 'username' not in self._config:\n self._config['username'] = self._UI.get_input(\"Please enter your trac username: \")\n self._config._write_config()\n return self._config['username']",
"def test_email_works_as_username_handle_flag_field(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n email_val = self.form_test_data.get(self.form.name_for_email) # was overwritten for form request.\n new_cleaned_data = {self.form.name_for_user: 'test_value', self.form.name_for_email: email_val}\n new_cleaned_data[self.form.USERNAME_FLAG_FIELD] = False\n user_field = self.form.computed_fields.pop(self.form.name_for_user, None)\n self.form.fields.update({self.form.name_for_user: user_field})\n email_field = self.form.fields[self.form.name_for_email]\n email_field.initial = getattr(self.user, self.form.name_for_user)\n self.form.cleaned_data = new_cleaned_data.copy()\n expected = {}\n actual = self.form.handle_flag_field(self.form.name_for_email, self.form.name_for_user)\n actual_username = self.form.cleaned_data.get(self.form.name_for_user, None)\n\n self.assertIsNotNone(email_val)\n self.assertIsNotNone(user_field)\n self.assertTrue(email_field.has_changed(email_field.initial, self.form.cleaned_data[self.form.name_for_email]))\n self.assertNotEqual(getattr(self.user, self.form.name_for_user), email_val)\n self.assertNotEqual(new_cleaned_data[self.form.name_for_user], actual_username)\n self.assertEqual(email_val, actual_username)\n self.assertEqual(expected, actual)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def post(self):\n data = request.get_json()\n username, password = actions.get_user(data['confirmation_code'])\n actions.confirm_user(username)\n return \"\", 200\n pass",
"def send_confirmation_email(self, *args, **kwargs):\n raise NotImplementedError",
"def test_interface_compute_name_for_user(self):\n self.form.name_for_user = self.form._meta.model.USERNAME_FIELD\n self.form.name_for_email = self.form._meta.model.get_email_field_name()\n expected = \"Unique test response value\"\n\n def confirm_func(username_field_name=None, email_field_name=None): return expected\n original_func = self.form.username_from_email_or_names\n self.form.username_from_email_or_names = confirm_func\n actual = self.form.compute_name_for_user()\n self.form.username_from_email_or_names = original_func\n\n self.assertEqual(expected, actual)",
"def OnTextCtrlLoginText(self, event):\r\n\t\tself._configtmp[\"username\"] = event.GetString()",
"def send_confirmation(self):\r\n c.user.email_validated = False\r\n c.user.confirmation_code = random_key(6)\r\n c.user._commit()\r\n emailer.confirmation_email(c.user)",
"def test_email_from_username_from_email_or_names(self):\n self.form.name_for_user = self.form._meta.model.USERNAME_FIELD\n self.form.name_for_email = self.form._meta.model.get_email_field_name()\n new_info = OTHER_USER.copy()\n original_data = self.form.data\n test_data = original_data.copy()\n test_data.update(new_info)\n test_data._mutable = False\n self.form.data = test_data\n self.form.is_bound = True\n self.form.cleaned_data = new_info.copy()\n expected = new_info['email']\n UserModel = get_user_model()\n\n self.assertEqual(1, UserModel.objects.count())\n self.assertEqual(self.user, UserModel.objects.first())\n for key in (self.form.name_for_user, self.form.name_for_email):\n new_info.get(key, None) != getattr(self.user, key, '')\n for key, value in new_info.items():\n self.assertIn(key, self.form.cleaned_data)\n result = self.form.username_from_email_or_names(self.form.name_for_user, self.form.name_for_email)\n self.assertEqual(expected, result)\n\n self.form.data = original_data\n del self.form.cleaned_data",
"def save(self, commit=True):\n\n email_local_part = self.cleaned_data['email'].split('@')[0]\n username_start = email_local_part[:5] if len(email_local_part) >= 5 else email_local_part\n self.instance.username = username_start + ''.join(\n [choice(ascii_letters) for _ in range(30 - len(username_start))])\n\n return super(RegisterForm, self).save(commit=commit)",
"def accounts_setup(request):\n if request.method == 'POST':\n form = UsernameSetupForm(request.POST, instance=request.user)\n if form.is_valid():\n username = form.clean_username()\n request.user.username = username\n request.user.save()\n request.user.userprofile.first_time = False\n request.user.userprofile.save()\n return HttpResponseRedirect('/p/')\n else:\n form = UsernameSetupForm()\n return render(request, \"accounts_setup.html\", {\"form\":form})",
"def register_username(self):\n while True:\n message = self.receive()\n if message == Message.OK:\n break\n print(message.decode(\"UTF-8\"))\n while True:\n self.username = input(\"Username: \")\n if len(self.username) > 0:\n self.send(self.username.encode(\"UTF-8\"))\n break\n else:\n print(\"Empty username!\")",
"def test_username_of_email_exists_handle_flag_field(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n email_val = getattr(self.user, self.form.name_for_user, None)\n new_cleaned_data = {self.form.name_for_user: email_val, self.form.name_for_email: email_val}\n new_cleaned_data[self.form.USERNAME_FLAG_FIELD] = False\n user_field = self.form.computed_fields.pop(self.form.name_for_user, None)\n self.form.fields.update({self.form.name_for_user: user_field})\n self.form.cleaned_data = new_cleaned_data.copy()\n expected_message = \"You must give a unique email not shared with other users (or create a username). \"\n expected = {self.form.name_for_email: expected_message}\n actual = self.form.handle_flag_field(self.form.name_for_email, self.form.name_for_user)\n\n self.assertIsNotNone(email_val)\n self.assertIsNotNone(user_field)\n self.assertEqual(email_val, self.form.data.get(get_html_name(self.form, self.form.name_for_email), None))\n self.assertEqual(expected, actual)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def enter_username(self):",
"def unconfigure_username(device, username):\n try:\n device.configure('no username {username}'.format(username=username))\n except SubCommandFailure:\n raise SubCommandFailure(\n \"Failed to unconfigure user {username}\".format(username=username)\n )",
"def set_username(self, value):\n self.username = value",
"def update_username(self, old_username, new_username):\n raise NotImplementedError()",
"def update_user(self, username):\n parser_update.add_argument('email', type=validate_email,\n required=False, nullable=False,\n help=\"Email must be formatted correctly\")\n\n parser_update.add_argument('phoneNumber', type=validate_phonenumber,\n required=False, nullable=False,\n help=\"Enter a valid phone number\")\n\n parser_update.add_argument('firstname', type=validate_characters,\n required=False, nullable=False,\n help=\"First name must be formatted correctly\")\n\n parser_update.add_argument('lastname', type=validate_characters,\n required=False, nullable=False,\n help=\"Last name must be formatted correctly\")\n\n parser_update.add_argument('othernames', type=validate_characters,\n required=False, nullable=False,\n help=\"Other name must be formatted correctly\")\n\n user = self.get_user(username)\n if user is None:\n return None\n\n args = parser_update.parse_args()\n new_data = {\n 'email': request.json.get('email', user['email']).lower(),\n 'firstname': request.json.get('firstname', user['firstname']).capitalize(),\n 'lastname': request.json.get('lastname', user['lastname']).capitalize(),\n 'othernames': request.json.get('othernames', user['othernames']).capitalize(),\n 'phoneNumber': request.json.get('phoneNumber', user['phonenumber']),\n }\n\n getEmail = self.get_user(new_data['email'])\n verification_status = True\n\n if user['email'] != new_data['email']:\n if getEmail is not None:\n return 'email exists'\n verification_status = False\n\n query = \"\"\"UPDATE users SET firstname=%s,lastname=%s,othernames=%s,\\\n email=%s,phonenumber=%s,emailverified=%s WHERE username=%s\"\"\"\n values = new_data['firstname'], new_data['lastname'], new_data['othernames'], new_data['email'], new_data['phoneNumber'], verification_status, username\n\n conn = self.db\n cursor = conn.cursor()\n cursor.execute(query, values)\n conn.commit()\n return new_data",
"def username_error(self, msg):\n print('\\nusername error: %s' % msg, file=self.console)\n self.username = input('Username: ')",
"def send_confirmation_email(user_pk):\n pass",
"def confirmation_failed(self):",
"async def handle_username_prompt(self):\n self.applog.info(\"sending username %s\" % self.username)\n self._flush_buffer()\n self.pexpect_child.sendline(self.username)\n ret = self.pexpect_child.expect([\"(?i)password\", pexpect.TIMEOUT, pexpect.EOF], timeout=10)\n self.applog.info(\"handle_username %s ret:%s\" % (self.username, ret))\n if ret == 0:\n return await self.handle_password_prompt()\n elif ret == 2:\n self.applog.info(\"Login username prompt failed with %s\" % ret)\n return False",
"def clean_confirm(self):\n password = self.cleaned_data.get('password')\n confirm = self.cleaned_data.get('confirm')\n\n if len(password) < 6:\n raise forms.ValidationError(\"Password must be at least 6 characters long\")\n if password != confirm:\n raise forms.ValidationError(\"Passwords do not match\")\n return confirm",
"def username(self) -> undefined.UndefinedOr[str]:",
"def user_registration_confirmation(new_user: CreateUser):\n user: User = User.get_user(username=new_user.username)\n\n if not user.confirmed:\n raise HTTPException(detail=\"User's email is not confirmed\", status_code=400)\n\n hashed_password = auth_handler.get_password_hash(new_user.password)\n user.hashed_password = hashed_password\n user.confirmed = True\n user.update()\n return APIResponse(msg=\"Successfully registered\")",
"def test_create_with_username(self):\n properties = self.portal.portal_properties.site_properties\n properties.manage_changeProperties(use_email_as_login=True)\n\n user = api.user.create(\n username='chuck',\n email='[email protected]',\n password='secret',\n )\n self.assertEquals(user.getUserName(), '[email protected]')\n\n properties = self.portal.portal_properties.site_properties\n properties.manage_changeProperties(use_email_as_login=False)\n\n user = api.user.create(\n username='chuck',\n email='[email protected]',\n password='secret',\n )\n self.assertEquals(user.getUserName(), 'chuck')"
] | [
"0.763387",
"0.6376398",
"0.6138468",
"0.5720694",
"0.57202744",
"0.5622012",
"0.53528005",
"0.53144443",
"0.52047443",
"0.52019894",
"0.5201963",
"0.52017576",
"0.51772255",
"0.5149077",
"0.5143668",
"0.5108457",
"0.5105089",
"0.50788605",
"0.50777745",
"0.5037037",
"0.50273734",
"0.5009986",
"0.50046813",
"0.49741828",
"0.49475592",
"0.49427256",
"0.4927853",
"0.4918789",
"0.48966694",
"0.4873827"
] | 0.6913565 | 1 |
The configure_username_confirmation method adds 'email' and 'username' errors and returns a message. | def test_message_configure_username_confirmation(self):
original_data = self.form.data
original_fields = self.form.fields
original_computed_fields = self.form.computed_fields
original_errors = getattr(self.form, '_errors', None)
original_cleaned_data = getattr(self.form, 'cleaned_data', None)
original_clean = self.form.clean
self.form.data = original_data.copy()
self.form.fields = original_fields.copy()
self.form.computed_fields = original_computed_fields.copy()
self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()
self.form.cleaned_data = {self.form.name_for_user: 'test_username', self.form.name_for_email: 'test_email'}
def replace_clean(): raise ImproperlyConfigured("Unexpected Clean Method Called. ")
self.form.clean = replace_clean
login_link = self.form.get_login_message(link_text='login to existing account', link_only=True)
expected_email_error = "Use a non-shared email, or {}. ".format(login_link)
e_note = "Typically people have their own unique email address, which you can update. "
e_note += "If you share an email with another user, then you will need to create a username for your login. "
expected_user_error = e_note
title = "Login with existing account, change to a non-shared email, or create a username. "
message = "Did you already make an account, or have one because you've had classes with us before? "
expected_message = format_html(
"<h3>{}</h3> <p>{} <br />{}</p>",
title,
message,
self.form.get_login_message(reset=True),
)
# print("=============== test_configure_username_confirmation ===================")
actual_message = self.form.configure_username_confirmation()
actual_email_error = ''.join(self.form._errors.get(self.form.name_for_email))
actual_user_error = ''.join(self.form._errors.get(self.form.name_for_user))
# print("-----------------------------------------------------------")
# pprint(self.form)
# print("-----------------------------------------------------------")
# pprint(expected_message)
# print("*********************************")
# pprint(actual_message)
# print("-----------------------------------------------------------")
# pprint(expected_email_error)
# print("*********************************")
# pprint(actual_email_error)
# print("-----------------------------------------------------------")
# pprint(expected_user_error)
# print("*********************************")
# pprint(actual_user_error)
# print("-----------------------------------------------------------")
self.assertEqual(expected_message, actual_message)
self.assertEqual(expected_email_error, actual_email_error)
self.assertEqual(expected_user_error, actual_user_error)
self.form.data = original_data
self.form.fields = original_fields
self.form.computed_fields = original_computed_fields
self.form._errors = original_errors
self.form.clean = original_clean
self.form.cleaned_data = original_cleaned_data
if original_errors is None:
del self.form._errors
if original_cleaned_data is None:
del self.form.cleaned_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_confirmation_username_not_email(self):\n pass",
"def test_confirmed_username(self):\n pass",
"def test_configure_username_confirmation(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n # valid = self.form.is_valid()\n self.form.full_clean()\n names = (original_data.get(field_name, None) for field_name in self.form.constructor_fields)\n expected_name = '_'.join(name for name in names if name is not None).casefold()\n normalize = self.form.user_model.normalize_username\n if callable(normalize):\n expected_name = normalize(expected_name)\n expected_flag = 'False'\n\n self.assertNotIn(self.form.name_for_user, original_data)\n self.assertNotIn(self.form.name_for_user, original_fields)\n self.assertIn(get_html_name(self.form, self.form.name_for_user), self.form.data)\n self.assertIn(self.form.name_for_user, self.form.fields)\n self.assertNotIn(self.form.USERNAME_FLAG_FIELD, original_data)\n self.assertNotIn(self.form.USERNAME_FLAG_FIELD, original_fields)\n self.assertIn(get_html_name(self.form, self.form.USERNAME_FLAG_FIELD), self.form.data)\n self.assertIn(self.form.USERNAME_FLAG_FIELD, self.form.fields)\n self.assertEqual(expected_name, self.form.data.get(get_html_name(self.form, self.form.name_for_user), None))\n self.assertEqual(expected_flag, self.form.data.get(get_html_name(self.form, self.form.USERNAME_FLAG_FIELD)))\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields",
"def username_error(self, msg):\n raise NotImplementedError('username_error')",
"def clean_username(self):\n username = self.cleaned_data['username']\n\n try:\n User.objects.get(email=username)\n except ObjectDoesNotExist:\n raise forms.ValidationError('Selected user does not exist.')\n\n return username",
"def username_error(self, msg):\n print('\\nusername error: %s' % msg, file=self.console)\n self.username = input('Username: ')",
"def get_user_email(username):\r\n return '{0}@test.com'.format(username)",
"def configure_username(device, username, pwd, encryption=0, privilege=''):\n try:\n # Update str with password encryption level\n if encryption:\n pwd = '{encryption} {pwd}'.format(encryption=encryption,pwd=pwd)\n if privilege:\n username = '{username} privilege {privilege}'.format(username=username,privilege=privilege)\n device.configure('username {username} password {pwd}'.format(username=username,pwd=pwd))\n except SubCommandFailure:\n raise SubCommandFailure(\n \"Failed to configure user {username}\".format(username=username)\n )",
"def save(self, commit=True):\n\n email_local_part = self.cleaned_data['email'].split('@')[0]\n username_start = email_local_part[:5] if len(email_local_part) >= 5 else email_local_part\n self.instance.username = username_start + ''.join(\n [choice(ascii_letters) for _ in range(30 - len(username_start))])\n\n return super(RegisterForm, self).save(commit=commit)",
"def _username(self):\n if 'username' not in self._config:\n self._config['username'] = self._UI.get_input(\"Please enter your trac username: \")\n self._config._write_config()\n return self._config['username']",
"def __email_for_user(self, username):\n user_3tuple = self.usermap.lookup_by_p4user(username)\n if not user_3tuple:\n return _('Unknown Perforce User <{}>').format(username)\n return \"<{0}>\".format(user_3tuple[p4gf_usermap.TUPLE_INDEX_EMAIL])",
"def accounts_setup(request):\n if request.method == 'POST':\n form = UsernameSetupForm(request.POST, instance=request.user)\n if form.is_valid():\n username = form.clean_username()\n request.user.username = username\n request.user.save()\n request.user.userprofile.first_time = False\n request.user.userprofile.save()\n return HttpResponseRedirect('/p/')\n else:\n form = UsernameSetupForm()\n return render(request, \"accounts_setup.html\", {\"form\":form})",
"def clean_username_or_email(self):\n username_or_email = self.cleaned_data['username_or_email']\n try:\n user = User.objects.get(username__iexact=username_or_email)\n self.profile = user.profile\n except User.DoesNotExist:\n try:\n self.profile = Profile.objects.get(\n settings__email__iexact=username_or_email)\n except Profile.DoesNotExist:\n raise forms.ValidationError(ERRORS['invalid_username'])\n return username_or_email",
"def clean_username(self):\n username = self.cleaned_data['username']\n if User.objects.filter(username=username):\n raise forms.ValidationError('Nombre de usuario ya registrado.')\n return username",
"def clean_username(self):\n username = self.cleaned_data['username']\n if User.objects.filter(username=username):\n raise forms.ValidationError('Nombre de usuario ya registrado.')\n return username",
"def create_email(username, provider):\n print(f\"Your new email is {username}@{provider}.com\")",
"def usernamesuggestion(request):\n if request.POST:\n email = request.POST.get('username', '')\n if email:\n usrobj = get_or_none(model=CustomUser, email=email)\n if not usrobj:\n logger_stats.info('Username is Available %s ' % (email))\n return HttpResponse(\"Username is Available\", content_type=\"text/plain\")\n # return \"Username is Available\"\n else:\n \"\"\"\n Check whether the input is email or username, if email return error message\n \"\"\"\n if '@' in email:\n is_valid = validate_email(email)\n if is_valid:\n returnmsg = \"Entered Email ID already taken \"\n logger_stats.info('Entered Email ID already taken %s ' % (email))\n return HttpResponse(returnmsg, content_type=\"text/plain\")\n returnmsg = \"Email is not in correct format\"\n logger_stats.info('Email is not in correct format %s ' % (email))\n return HttpResponse(returnmsg, content_type=\"text/plain\")\n returnmsg = \"Entered username already taken \" + email\n numlist = re.findall(r'\\d+', email)\n if numlist:\n replacenum = int(numlist[0])\n while (True):\n replacenum += 1\n newusername = str(replacenum)\n usrobj = get_or_none(\n model=CustomUser, email=email + newusername)\n if not usrobj:\n returnmsg += '\\n Available username is ' + \\\n email + newusername\n logger_stats.info(returnmsg)\n return HttpResponse(returnmsg, content_type=\"text/plain\")\n else:\n startno = 0\n while (True):\n startno += 1\n usrobj = get_or_none(\n model=CustomUser, email=email + str(startno))\n if not usrobj:\n returnmsg += '\\n Available username is ' + \\\n email + str(startno)\n logger_stats.info(returnmsg)\n return HttpResponse(returnmsg, content_type=\"text/plain\")\n return render_to_response('login.html', context_instance=RequestContext(request))",
"def clean_username(self):\n\t\tusername = self.cleaned_data['username']\n\t\tif User.objects.filter(username=username):\n\t\t\traise forms.ValidationError('username de usuario ya registrado.')\n\t\treturn username",
"def clean_username(self):\n username = self.cleaned_data.get(\"username\")\n if User.objects.filter(username=username).exists():\n LOGGER.warning(\"username already exists\", username=username)\n raise ValidationError(_(\"Username already exists\"))\n return username",
"def send_confirmation_email(self, *args, **kwargs):\n raise NotImplementedError",
"def clean_username(self):\n username = self.cleaned_data.get('username')\n user_exists = User.objects.filter(username=username).exists()\n\n if user_exists:\n raise forms.ValidationError(\n 'El usuario ya existe en nuestros registros.'\n )\n\n return username",
"def get_username_validation_error(username):\n return _validate(_validate_username, errors.AccountUsernameInvalid, username)",
"def clean_username(self):\r\n try:\r\n user = User.objects.get(username__iexact=self.cleaned_data['username'])\r\n except User.DoesNotExist:\r\n return self.cleaned_data['username']\r\n raise forms.ValidationError(_(u'This username is already taken. Please choose another.'))",
"def validate_username(form, field):\n\n user = User.query.filter_by(username=form.username.data).first()\n\n if user and not user == g.user:\n form.username.errors = [\n \"Username already taken!\",\n *form.username.errors\n ]\n raise ValidationError",
"def clean_username(self):\n username = self.cleaned_data['username']\n\n try:\n User.objects.get(username=username)\n except ObjectDoesNotExist:\n return username\n\n raise forms.ValidationError('Login is already in use.')",
"def update_username(self, old_username, new_username):\n raise NotImplementedError()",
"def validate_username(self, username):\n if username.data != current_user.username:\n user = User.query.filter_by(username=username.data).first()\n if user:\n raise ValidationError('That username already exists. Please choose another username.')",
"def test_user_cannot_register_with_short_username(self):\n response = self.client.post(SIGNUP_URL,\n data=json.dumps(\n {'username': 'dan', 'email': '[email protected]', 'password': 'pass12345'}),\n content_type='application/json')\n self.assertEqual(response.status_code, 400)\n result = json.loads(response.data.decode())\n self.assertEqual(result[\"message\"],\n \"Username should be atleast 4 characters\")",
"def unconfigure_username(device, username):\n try:\n device.configure('no username {username}'.format(username=username))\n except SubCommandFailure:\n raise SubCommandFailure(\n \"Failed to unconfigure user {username}\".format(username=username)\n )",
"def test_username_not_unique(bot):\n expect_error(register, InputError, bot.username, \"abcdef\", \"a\", \"a\", \"a\")"
] | [
"0.60055816",
"0.5580558",
"0.54387224",
"0.540235",
"0.5364039",
"0.5363893",
"0.536015",
"0.52718633",
"0.51772916",
"0.51737255",
"0.5053862",
"0.5028276",
"0.50114393",
"0.49868944",
"0.49868944",
"0.4983278",
"0.49651885",
"0.4959728",
"0.4954731",
"0.4945962",
"0.4923809",
"0.49061906",
"0.48991287",
"0.48810694",
"0.48417673",
"0.48341838",
"0.48300195",
"0.48232204",
"0.48042905",
"0.48000032"
] | 0.684493 | 0 |
If not compute errors, clean method raises ValidationError for nonempty return from handle_flag_field. | def test_clean_calls_handle_flag_field(self):
original_data = self.form.data
original_fields = self.form.fields
original_computed_fields = self.form.computed_fields
original_errors = getattr(self.form, '_errors', None)
original_cleaned_data = getattr(self.form, 'cleaned_data', None)
self.form.data = original_data.copy()
self.form.fields = original_fields.copy()
self.form.computed_fields = original_computed_fields.copy()
self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()
new_cleaned_data = {self.form.name_for_user: 'test_value', self.form.name_for_email: 'test_value'}
self.form.cleaned_data = new_cleaned_data.copy()
# expected_error = {self.form.name_for_email: "test email error", self.form.name_for_user: "test user error"}
expected_error = "The replace_handle_flag_field test return value. "
def replace_handle_flag_field(email, user): return expected_error
self.form.handle_flag_field = replace_handle_flag_field
with self.assertRaisesMessage(ValidationError, expected_error):
self.form.clean()
self.form.data = original_data
self.form.fields = original_fields
self.form.computed_fields = original_computed_fields
self.form._errors = original_errors
self.form.cleaned_data = original_cleaned_data
if original_errors is None:
del self.form._errors
if original_cleaned_data is None:
del self.form.cleaned_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def full_clean(self):\n self._errors = ErrorDict()\n if not self.is_bound: # Stop further processing.\n return\n self.cleaned_data = {}\n if self.empty_permitted and not self.has_changed():\n self.cleaned_data = None\n return\n for name, field in self.fields.items():\n self.clean_field(name, field)\n try:\n self.cleaned_data = self.clean()\n except ValidationError, e:\n self._errors[NON_FIELD_ERRORS] = e.messages\n if self._errors:\n delattr(self, 'cleaned_data')",
"def clean(self, *args, **kwargs):\n self.is_cleaned = True",
"def clean(self):\r\n cleaned_data = super(RPEventCreateForm, self).clean()\r\n self.check_risk()\r\n self.check_costs()\r\n self.check_location_or_plotroom()\r\n return cleaned_data",
"def clean(self):\n\n if self.max_result_size is not None and self.max_result_size < 1:\n raise ValidationError(\"Max Result Size must be blank or greater than 1!\")",
"def run_validation(self, data=empty):\n\n if data is not empty:\n unknown = set(data) - set(self.fields)\n if unknown:\n errors = ['Unknown field: {}'.format(f) for f in unknown]\n raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: errors})\n return super().run_validation(data)",
"def clean(self):\n cleaned_data = super().clean()\n if all(val == \"\" for val in cleaned_data.values()):\n raise ValidationError(\"You must fill at least one field!\")\n\n return cleaned_data",
"def test_clean_uses_computed(self):\n original_request = self.request\n original_form = self.form\n original_cleaned = getattr(self.form, 'cleaned_data', None)\n self.form = self.make_form_request()\n name = self.form.country_field_name\n initial = self.form.base_fields[name].initial\n cleaned = {'country_flag': True, name: initial}\n self.form.cleaned_data = cleaned\n\n self.assertNotIn(name, self.form.fields)\n self.assertIn(name, self.form.computed_fields)\n with self.assertRaisesMessage(ValidationError, \"You can input your address. \"):\n clean_flag = self.form.clean_country_flag()\n self.form.cleaned_data[name] = ''\n clean_flag = self.form.clean_country_flag()\n self.assertEqual(True, clean_flag)\n\n self.request = original_request\n self.form = original_form\n self.form.cleaned_data = original_cleaned\n if original_cleaned is None:\n del self.form.cleaned_data",
"def clean(self):\n cleaned_data = super().clean()\n if any(self.errors):\n # Don't bother validating unless each field is valid on its own\n return\n if not self.household.editing:\n raise forms.ValidationError(\"Household is not in editing mode.\")",
"def clean(self):\n cleaned_data = super(ManageLearnersForm, self).clean()\n\n # Here we take values from `data` (and not `cleaned_data`) as we need raw values - field clean methods\n # might \"invalidate\" the value and set it to None, while all we care here is if it was provided at all or not\n email_or_username = self.data.get(self.Fields.EMAIL_OR_USERNAME, None)\n bulk_upload_csv = self.files.get(self.Fields.BULK_UPLOAD, None)\n\n if not email_or_username and not bulk_upload_csv:\n raise ValidationError(ValidationMessages.NO_FIELDS_SPECIFIED)\n\n if email_or_username and bulk_upload_csv:\n raise ValidationError(ValidationMessages.BOTH_FIELDS_SPECIFIED)\n\n if email_or_username:\n mode = self.Modes.MODE_SINGULAR\n else:\n mode = self.Modes.MODE_BULK\n\n cleaned_data[self.Fields.MODE] = mode\n cleaned_data[self.Fields.NOTIFY] = self.clean_notify()\n\n self._validate_course()\n self._validate_program()\n\n if self.data.get(self.Fields.PROGRAM, None) and self.data.get(self.Fields.COURSE, None):\n raise ValidationError(ValidationMessages.COURSE_AND_PROGRAM_ERROR)\n\n return cleaned_data",
"def clean(self):\n super(RequireOneFormSet, self).clean()\n for error in self.errors:\n if error:\n return\n completed = 0\n for cleaned_data in self.cleaned_data:\n # form has data and we aren't deleting it.\n if cleaned_data and not cleaned_data.get('DELETE', False):\n completed += 1\n\n if completed < 1:\n raise forms.ValidationError(\"At least one %s is required.\" %\n self.model._meta.object_name.lower())",
"def clean(self):\n if not self.is_input and not self.is_output:\n raise ValidationError(\"TransformationXput with pk={} is neither an input nor an output\".format(self.pk))\n if self.has_structure:\n self.structure.clean()",
"def clean(self, value):\n if not value:\n raise ValidationError(\n 'Error found in Form Field: Nothing to validate')\n\n data = dict((bf.name, value[i]) for i, bf in enumerate(self.form))\n self.form = form = self.form.__class__(data)\n if not form.is_valid():\n error_dict = list(form.errors.items())\n errors = striptags(\n \", \".join([\"%s (%s)\" % (v, k) for k, v in error_dict]))\n raise ValidationError('Error(s) found: %s' % errors)\n\n # This call will ensure compress is called as expected.\n return super(FormField, self).clean(value)",
"def run_validation(self, data=empty):\n\n # no idea why there is no such built in feature in DRF\n if data is not empty:\n unknown = set(data) - set(self.fields)\n if unknown:\n errors = ['Unknown field: {}'.format(f) for f in unknown]\n raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: errors})\n return super().run_validation(data)",
"def validate(self, value, clean=True):\n pass",
"def validate(self, value, clean=True):\n pass",
"def clean(self):\n cleaned_data = super(AddressForm, self).clean()\n state = cleaned_data.get('state')\n country = cleaned_data.get('country') # A Country instance\n postal_code = cleaned_data.get('postal_code')\n\n # The state must be valid for the country\n if state and country and not self.checkState(state, country):\n self.add_error('state', forms.ValidationError('Invalid state for {0}.'.format(country)))\n\n # The postal code must be valid for the country\n if postal_code and country:\n try:\n self.checkPostalCode(postal_code, country)\n except forms.ValidationError as e:\n self.add_error('postal_code', e)\n return cleaned_data",
"def _post_clean(self):\r\n super(NgModelFormMixin, self)._post_clean()\r\n if self._errors and self.prefix:\r\n self._errors = ErrorDict((self.add_prefix(name), value) for name, value in self._errors.items())",
"def clean(self):\n\n self._can_be_controlled = bool(self.ipi_name) & bool(self.pr_society)\n if self.ipi_name == \"00000000000\":\n self.ipi_name = None\n if self.pr_society == \"99\":\n self.pr_society = None\n\n d = {}\n if not self.generally_controlled:\n if self.saan:\n d[\"saan\"] = \"Only for a general agreement.\"\n if self.publisher_fee:\n d[\"publisher_fee\"] = \"Only for a general agreement.\"\n else:\n if not self._can_be_controlled:\n d[\"generally_controlled\"] = (\n \"IPI name number and PR society fields are required for \"\n 'a controlled writer. See \"Writers\" in the user manual.'\n )\n if d:\n raise django.core.exceptions.ValidationError(d)",
"def _clean(self):\n self.cleaned_data = super().clean()\n # Use bound data to set the value if we both have bound and initial data.\n if self.is_bound and self.initial:\n self._set_and_validate_data(self.data)\n return\n else:\n # Set values according to bound data\n if self.is_bound:\n self._set_and_validate_data(self.data)\n return\n # Set values according to initial data\n if self.initial:\n self._set_and_validate_data(self.initial)\n return",
"def clean(self):\n if self.name is None or self.address is None or self.city_name is None or self.post_code is None:\n raise ValidationError",
"def __validate():\n # TODO: implement",
"def test_no_error_handle_flag_field(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n new_cleaned_data = {self.form.name_for_user: 'test_value', self.form.name_for_email: 'test_value'}\n new_cleaned_data[self.form.USERNAME_FLAG_FIELD] = True # False\n user_field = self.form.computed_fields.pop(self.form.name_for_user, None)\n self.form.fields.update({self.form.name_for_user: user_field})\n email_field = self.form.fields[self.form.name_for_email]\n email_field.initial = new_cleaned_data[self.form.name_for_email]\n self.form.cleaned_data = new_cleaned_data.copy()\n expected = {}\n actual = self.form.handle_flag_field(self.form.name_for_email, self.form.name_for_user)\n\n self.assertIsNotNone(user_field)\n self.assertFalse(email_field.has_changed(email_field.initial, self.form.cleaned_data[self.form.name_for_email]))\n self.assertEqual(expected, actual)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def clean_form_with_field_errors(original_function, self):\n \n from django.core.exceptions import ValidationError\n try:\n self.cleaned_data = self.clean()\n except ValidationError, e:\n if hasattr(e, 'message_dict'):\n for field, error_strings in e.message_dict.items():\n self._errors[field] = self.error_class(error_strings)\n else:\n self._errors[NON_FIELD_ERRORS] = self.error_class(e.messages)",
"def clean(self):\n character_id = self.cleaned_data['character_id']\n character = Character.objects.get(pk=character_id)\n if character.concept_approved_flag:\n raise ValidationError(f\"The concept for {character} has already been approved.\")\n return super().clean()",
"def clean(self):\n return",
"def test_field_clean_method_called_in_clean_computed_fields(self):\n name = 'test_field'\n expected = 'clean_confirmed'\n original_func = deepcopy(self.form.test_func)\n def replace_value(value): return expected\n self.form.test_func = replace_value\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n field = self.form.computed_fields.get(name) # getattr(self.form, name)\n # initial_value = self.get_initial_for_field(field, name)\n value = getattr(self.form, 'compute_%s' % name)()\n value = field.clean(value)\n original_errors = deepcopy(self.form._errors)\n if self.form._errors is None:\n self.form._errors = ErrorDict() # mimic full_clean: _error is an ErrorDict\n cleaned_data = getattr(self.form, 'cleaned_data', {})\n cleaned_data.update({name: value}) # make sure the original cleaned_data for the field is set.\n self.form.cleaned_data = cleaned_data # ensure cleaned_data is present (mimic full_clean)\n compute_errors = self.form._clean_computed_fields()\n actual = self.form.cleaned_data.get(name, None)\n\n self.assertFalse(compute_errors)\n self.assertEqual(expected, actual)\n self.assertNotEqual(expected, value)\n self.assertNotEqual(expected, self.form.test_value)\n\n self.form.test_func = original_func\n self.form._errors = original_errors",
"def clean(self):\n if any(self.errors):\n # Don't bother validating unless each form is valid on its own\n return\n if self.get_total_weights() != 100:\n raise forms.ValidationError(\"Weights must sum to 100; try normalizing.\")",
"def validate(self):\n self.valid = True\n\n if self._value is None and self._strict:\n self.valid = False\n raise self.MissingFieldData\n\n elif self._value is not None:\n self._type_specific_validation()",
"def test_validation_errors_assigned_in_clean_computed_fields(self):\n name = 'test_field'\n message = \"This is the test error on test_field. \"\n response = ValidationError(message)\n expected_compute_errors = ErrorDict({name: response}) # similar to return of _clean_computed_fields\n original_func = deepcopy(self.form.test_func)\n def make_error(value): raise response\n self.form.test_func = make_error\n if isinstance(self.form.computed_fields, (list, tuple)):\n self.form.computed_fields = self.form.get_computed_fields([name])\n self.form.cleaned_data = getattr(self.form, 'cleaned_data', {}) # mimic full_clean: cleaned_data is present\n actual_compute_errors = self.form._clean_computed_fields()\n\n self.assertDictEqual(expected_compute_errors, actual_compute_errors)\n self.form.test_func = original_func",
"def test_clean_country_flag(self):\n # country_flag = self.cleaned_data.get('country_flag', None)\n # field = self.fields.get(self.country_field_name, None)\n # if not field and hasattr(self, 'computed_fields'):\n # field = self.computed_fields.get(self.country_field_name, None)\n # if field.initial == self.cleaned_data.get(self.country_field_name, None)\n pass"
] | [
"0.67317265",
"0.66701466",
"0.65613997",
"0.6491003",
"0.6457058",
"0.63930887",
"0.6362819",
"0.6361536",
"0.63591117",
"0.63257307",
"0.6325247",
"0.6292585",
"0.6270345",
"0.6267574",
"0.6267574",
"0.62562644",
"0.6236502",
"0.6181659",
"0.6137063",
"0.6129618",
"0.6125542",
"0.60758835",
"0.6032611",
"0.59983104",
"0.5993756",
"0.59933144",
"0.59845227",
"0.5962239",
"0.5934888",
"0.5929133"
] | 0.66912293 | 1 |
If there is no error found during handle_flag_field, expected return of an empty Dict. | def test_no_error_handle_flag_field(self):
original_data = self.form.data
original_fields = self.form.fields
original_computed_fields = self.form.computed_fields
original_errors = getattr(self.form, '_errors', None)
original_cleaned_data = getattr(self.form, 'cleaned_data', None)
self.form.data = original_data.copy()
self.form.fields = original_fields.copy()
self.form.computed_fields = original_computed_fields.copy()
self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()
new_cleaned_data = {self.form.name_for_user: 'test_value', self.form.name_for_email: 'test_value'}
new_cleaned_data[self.form.USERNAME_FLAG_FIELD] = True # False
user_field = self.form.computed_fields.pop(self.form.name_for_user, None)
self.form.fields.update({self.form.name_for_user: user_field})
email_field = self.form.fields[self.form.name_for_email]
email_field.initial = new_cleaned_data[self.form.name_for_email]
self.form.cleaned_data = new_cleaned_data.copy()
expected = {}
actual = self.form.handle_flag_field(self.form.name_for_email, self.form.name_for_user)
self.assertIsNotNone(user_field)
self.assertFalse(email_field.has_changed(email_field.initial, self.form.cleaned_data[self.form.name_for_email]))
self.assertEqual(expected, actual)
self.form.data = original_data
self.form.fields = original_fields
self.form.computed_fields = original_computed_fields
self.form._errors = original_errors
self.form.cleaned_data = original_cleaned_data
if original_errors is None:
del self.form._errors
if original_cleaned_data is None:
del self.form.cleaned_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_handle_flag_error(self):\n pass",
"def test_raise_missing_flag_field(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_flag = self.form.USERNAME_FLAG_FIELD\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n original_errors = getattr(self.form, '_errors', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.USERNAME_FLAG_FIELD = 'Not a valid field name'\n self.form.cleaned_data = {self.form.name_for_user: 'test_username', self.form.name_for_email: 'test_email'}\n # self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n self.form._errors = None if original_errors is None else original_errors.copy()\n\n with self.assertRaises(ImproperlyConfigured):\n self.form.configure_username_confirmation()\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.USERNAME_FLAG_FIELD = original_flag\n self.form.cleaned_data = original_cleaned_data\n self.form._errors = original_errors\n if original_cleaned_data is None:\n del self.form.cleaned_data\n if original_errors is None:\n del self.form._errors",
"def test_no_flag_handle_flag_field(self):\n original_flag_name = self.form.USERNAME_FLAG_FIELD\n self.form.USERNAME_FLAG_FIELD = \"This is not a valid field name\"\n expected = None\n actual = self.form.handle_flag_field(self.form.name_for_email, self.form.name_for_user)\n\n self.assertEqual(expected, actual)\n self.form.USERNAME_FLAG_FIELD = original_flag_name",
"def test_bad_flag_handle_flag_field(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n email_val = self.form_test_data.get(self.form.name_for_email) # was overwritten for form request.\n new_cleaned_data = {self.form.name_for_user: 'test_value', self.form.name_for_email: email_val}\n new_cleaned_data[self.form.USERNAME_FLAG_FIELD] = True\n user_field = self.form.computed_fields.pop(self.form.name_for_user, None)\n self.form.fields.update({self.form.name_for_user: user_field})\n email_field = self.form.fields[self.form.name_for_email]\n email_field.initial = getattr(self.user, self.form.name_for_user)\n self.form.cleaned_data = new_cleaned_data.copy()\n message = \"Un-check the box, or leave empty, if you want to use this email address. \"\n expected = {self.form.USERNAME_FLAG_FIELD: message}\n actual = self.form.handle_flag_field(self.form.name_for_email, self.form.name_for_user)\n actual_username = self.form.cleaned_data.get(self.form.name_for_user, None)\n\n self.assertIsNotNone(email_val)\n self.assertIsNotNone(user_field)\n self.assertTrue(email_field.has_changed(email_field.initial, self.form.cleaned_data[self.form.name_for_email]))\n self.assertNotEqual(getattr(self.user, self.form.name_for_user), email_val)\n self.assertEqual(new_cleaned_data[self.form.name_for_user], actual_username)\n self.assertNotEqual(email_val, actual_username)\n self.assertEqual(expected, actual)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def test_clean_calls_handle_flag_field(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n new_cleaned_data = {self.form.name_for_user: 'test_value', self.form.name_for_email: 'test_value'}\n self.form.cleaned_data = new_cleaned_data.copy()\n # expected_error = {self.form.name_for_email: \"test email error\", self.form.name_for_user: \"test user error\"}\n expected_error = \"The replace_handle_flag_field test return value. \"\n def replace_handle_flag_field(email, user): return expected_error\n self.form.handle_flag_field = replace_handle_flag_field\n with self.assertRaisesMessage(ValidationError, expected_error):\n self.form.clean()\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def get_dict(self):\n # type: () -> dict\n self.is_valid()\n return self._get_dict()",
"def _parse_from_dict(self, arg_dict):\n missing = {}\n for key, value in arg_dict.items():\n flag_desc = self._defs.get(key.replace(\"-\", \"_\"), None)\n if flag_desc is None:\n missing[key] = value\n else:\n flag_desc.parse(value)\n return missing",
"def check_for_dict(check):",
"def _get_form_error(self):\n errors = {}\n if self._form_error:\n errors[\"base\"] = self._form_error\n self._form_error = None\n return errors",
"def test_empty_dict(self):\n read_on_template = field_template_read({})\n self.assertFalse(read_on_template)\n self.assertEqual(read_on_template, {})",
"def get_value(self) -> Dict[str, any]:",
"def test_clean_country_flag(self):\n # country_flag = self.cleaned_data.get('country_flag', None)\n # field = self.fields.get(self.country_field_name, None)\n # if not field and hasattr(self, 'computed_fields'):\n # field = self.computed_fields.get(self.country_field_name, None)\n # if field.initial == self.cleaned_data.get(self.country_field_name, None)\n pass",
"def testFlagHandler(self):\n schema = lsst.afw.table.SourceTable.makeMinimalSchema()\n\n # This is a FlagDefinition structure like a plugin might have\n flagDefs = FlagDefinitionList()\n FAILURE = flagDefs.addFailureFlag()\n FIRST = flagDefs.add(\"1st error\", \"this is the first failure type\")\n SECOND = flagDefs.add(\"2nd error\", \"this is the second failure type\")\n fh = FlagHandler.addFields(schema, \"test\", flagDefs)\n # Check to be sure that the FlagHandler was correctly initialized\n for index in range(len(flagDefs)):\n self.assertEqual(flagDefs.getDefinition(index).name, fh.getFlagName(index))\n\n catalog = lsst.afw.table.SourceCatalog(schema)\n\n # Now check to be sure that all of the known failures set the bits correctly\n record = catalog.addNew()\n fh.handleFailure(record)\n self.assertTrue(fh.getValue(record, FAILURE.number))\n self.assertFalse(fh.getValue(record, FIRST.number))\n self.assertFalse(fh.getValue(record, SECOND.number))\n record = catalog.addNew()\n\n error = MeasurementError(FAILURE.doc, FAILURE.number)\n fh.handleFailure(record, error.cpp)\n self.assertTrue(fh.getValue(record, FAILURE.number))\n self.assertFalse(fh.getValue(record, FIRST.number))\n self.assertFalse(fh.getValue(record, SECOND.number))\n\n record = catalog.addNew()\n error = MeasurementError(FIRST.doc, FIRST.number)\n fh.handleFailure(record, error.cpp)\n self.assertTrue(fh.getValue(record, FAILURE.number))\n self.assertTrue(fh.getValue(record, FIRST.number))\n self.assertFalse(fh.getValue(record, SECOND.number))\n\n record = catalog.addNew()\n error = MeasurementError(SECOND.doc, SECOND.number)\n fh.handleFailure(record, error.cpp)\n self.assertTrue(fh.getValue(record, FAILURE.number))\n self.assertFalse(fh.getValue(record, FIRST.number))\n self.assertTrue(fh.getValue(record, SECOND.number))",
"def get_flag(self):\n price_data = self.get_price_data()\n if price_data.get('flag'):\n return price_data.get('flag')\n return None",
"def missing_information(self, info, field):\n raise NoData",
"def _do_status(self) -> Dict[str, Any]:\n return {}",
"def _do_status(self) -> Dict[str, Any]:\n return {}",
"def _validate_or_make_feature(dic_fc, num_img):\n # bol_found_numf = False\n num_il = -999 # number in list initialise\n if isinstance(dic_fc, dict):\n if isinstance(num_img, int):\n # print(f\" = dic_fc: {dic_fc}\")\n if \"type\" in dic_fc.keys() and dic_fc[\"type\"] == \"FeatureCollection\":\n if \"features\" in dic_fc.keys() and isinstance(dic_fc[\"features\"], list):\n num_feat = -1\n for fet in dic_fc[\"features\"]:\n num_feat += 1\n if isinstance(fet, dict):\n if fet[\"type\"] == \"Feature\":\n if \"properties\" in fet.keys():\n if dic_fc[\"features\"][num_feat][\"properties\"][\"numi\"] == num_img:\n num_il = num_feat\n break\n else:\n print(f\"ERR: in _val_or_make...() dic_fc feature has no properties key\")\n return dic_fc\n else:\n print(f\"ERR: in _val_or_make...() dic_fc has element of not-Feature type: {fet['type']}\")\n return dic_fc\n else:\n print(f\"ERR: in _val_or_make...() dic_fc feature is not dict: {str(type(fet))}\")\n return dic_fc\n else:\n print(f\"ERR: in _val_or_make...() dic_fc has no key: features of type list\")\n return dic_fc\n else:\n print(f\"ERR: in _val_or_make...() dic_fc has no key: type == FeatureCollection\")\n return dic_fc\n else:\n print(f\"ERR: in _val_or_make...() received non-int as num_f\")\n return dic_fc\n else:\n print(f\"ERR: in _val_or_make...() received non-dict as dict_fc\")\n return dic_fc\n if num_il < 0:\n new_feature = {\"type\": \"Feature\", \"geometry\": {\"type\": \"Point\", \"coordinates\": [0, 0]}, \"properties\": {\"numi\": 0}}\n new_feature[\"properties\"][\"numi\"] = num_img\n dic_fc[\"features\"].append(new_feature)\n num_il = len(dic_fc[\"features\"]) - 1\n return dic_fc, num_il",
"def _LoadDataModelValues( self, reason ):\n return {}",
"def flags(self) -> undefined.UndefinedOr[UserFlag]:",
"def _get_info(self):\n\n info = {}\n if self.field is not None and self.field.check_not_in_enum is not None:\n info.update(not_in_enum=self.field.check_not_in_enum.options(),\n not_in_enum_lookup=self.field.check_not_in_enum.to_dict())\n\n elif self.invalid_values_provider is not None and \\\n not callable(self.invalid_values_provider):\n info.update(not_in_enum=dict_utils.create_options(self.invalid_values),\n not_in_enum_lookup=dict_utils.create_dict(self.invalid_values))\n\n base_info = super()._get_info()\n if base_info:\n info.update(base_info)\n\n return info",
"def parse_response(flag_response, flag):\n\n if NO_SUCH_FLAG in flag_response:\n message_type = NO_SUCH_FLAG\n\n if OWN_FLAG in flag_response:\n message_type = OWN_FLAG\n\n if ERRORED in flag_response:\n message_type = ERRORED\n\n if NOT_RECOGNIZED in flag_response:\n message_type = NOT_RECOGNIZED\n\n if CONTEST_NOT_STARTED in flag_response:\n message_type = CONTEST_NOT_STARTED\n\n if CONTEST_OVER in flag_response:\n message_type = CONTEST_OVER\n\n if INVALID_CHARS in flag_response:\n message_type = INVALID_CHARS\n\n if EXPIRED in flag_response:\n message_type = EXPIRED\n\n if TEAPOT in flag_response:\n message_type = TEAPOT\n\n if ACCEPTED in flag_response:\n message_type = ACCEPTED\n\n return {\n \"flag\" : flag,\n \"message_type\" : message_type,\n }",
"def error_false(self):\n self.errors = self.errors[0:-1]\n if not self.errors:\n self.update_info()",
"def get_unrecognized_field_info(self, key, value_default=None,\n variant_default=None):\n value, variant = self.__unrecognized_fields.get(key, (value_default,\n variant_default))\n return value, variant",
"def test_get_return_default(self):\n ars = self.ar[2009][11]['general']\n self.assertTrue(ars.get('invalid_row') is None)",
"def getFlag(self, flag) -> bool:\n ...",
"def get_ml_data(self,redcap):\n\t\tmldata = {}\n\t\tfor item in self.get_metadata():\n\t\t\tif (item['field_name'] == redcap):\n\t\t\t\tif (item['field_type'] != \"yesno\"):\n\t\t\t\t\tprint(\"get_data called on invalid redcap field: {}\\nget_ml_data can only be called on fields of field_type yesno but field type of {} is: '{}'\".format(redcap,redcap,item['field_type']))\n\t\t\t\t\treturn\n\t\ttry:\n\t\t\tfor eachdict in self.get_data(redcap):\n\t\t\t\t#mldata[eachdict['record_id'].strip()] = 1 if (eachdict[redcap].strip()=='1') else 0\n\t\t\t\tmldata[eachdict['record_id'].strip()] = eachdict[redcap].strip() == '1'\n\t\texcept KeyError as e:\n\t\t\traise KeyError(\"redcap field: '{}'\\nin get_ml_data() call not found. did you mean: '{}'?\\nverify and try again\".format(redcap,get_close_matches(redcap,[d['field_name'] for d in self.get_metadata()])))\n\t\treturn mldata",
"def testNoFailureFlag(self):\n schema = lsst.afw.table.SourceTable.makeMinimalSchema()\n\n # This is a FlagDefinition structure like a plugin might have\n flagDefs = FlagDefinitionList()\n FIRST = flagDefs.add(\"1st error\", \"this is the first failure type\")\n SECOND = flagDefs.add(\"2nd error\", \"this is the second failure type\")\n fh = FlagHandler.addFields(schema, \"test\", flagDefs)\n # Check to be sure that the FlagHandler was correctly initialized\n for index in range(len(flagDefs)):\n self.assertEqual(flagDefs.getDefinition(index).name, fh.getFlagName(index))\n\n catalog = lsst.afw.table.SourceCatalog(schema)\n\n # Now check to be sure that all of the known failures set the bits correctly\n record = catalog.addNew()\n fh.handleFailure(record)\n self.assertFalse(fh.getValue(record, FIRST.number))\n self.assertFalse(fh.getValue(record, SECOND.number))\n record = catalog.addNew()\n\n record = catalog.addNew()\n error = MeasurementError(FIRST.doc, FIRST.number)\n fh.handleFailure(record, error.cpp)\n self.assertTrue(fh.getValue(record, FIRST.number))\n self.assertFalse(fh.getValue(record, SECOND.number))\n\n record = catalog.addNew()\n error = MeasurementError(SECOND.doc, SECOND.number)\n fh.handleFailure(record, error.cpp)\n self.assertFalse(fh.getValue(record, FIRST.number))\n self.assertTrue(fh.getValue(record, SECOND.number))",
"def non_field_errors(self):\n result = self.errors.get(NON_FIELD_ERRORS, None)\n if not result:\n result = self.errors[NON_FIELD_ERRORS] = self.error_class()\n return result",
"def failure(operation: str, msg: str) -> Mapping[str, Union[str, bool]]:\n return {\n \"operation\": operation,\n \"success\": False,\n \"message\": msg,\n }"
] | [
"0.60706633",
"0.58114743",
"0.5689423",
"0.5565528",
"0.54922634",
"0.54514563",
"0.5435839",
"0.5322094",
"0.52672726",
"0.51822263",
"0.5164868",
"0.5127669",
"0.51257294",
"0.51159257",
"0.51143193",
"0.50291574",
"0.50291574",
"0.5001778",
"0.49994832",
"0.49979964",
"0.4983259",
"0.49795333",
"0.4979204",
"0.49715745",
"0.49702182",
"0.49615353",
"0.49570855",
"0.49344742",
"0.49223766",
"0.4897747"
] | 0.5925116 | 1 |
If current email matches an existing username, handle_flag_field returns a Dict with that error. | def test_username_of_email_exists_handle_flag_field(self):
original_data = self.form.data
original_fields = self.form.fields
original_computed_fields = self.form.computed_fields
original_errors = getattr(self.form, '_errors', None)
original_cleaned_data = getattr(self.form, 'cleaned_data', None)
self.form.data = original_data.copy()
self.form.fields = original_fields.copy()
self.form.computed_fields = original_computed_fields.copy()
self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()
email_val = getattr(self.user, self.form.name_for_user, None)
new_cleaned_data = {self.form.name_for_user: email_val, self.form.name_for_email: email_val}
new_cleaned_data[self.form.USERNAME_FLAG_FIELD] = False
user_field = self.form.computed_fields.pop(self.form.name_for_user, None)
self.form.fields.update({self.form.name_for_user: user_field})
self.form.cleaned_data = new_cleaned_data.copy()
expected_message = "You must give a unique email not shared with other users (or create a username). "
expected = {self.form.name_for_email: expected_message}
actual = self.form.handle_flag_field(self.form.name_for_email, self.form.name_for_user)
self.assertIsNotNone(email_val)
self.assertIsNotNone(user_field)
self.assertEqual(email_val, self.form.data.get(get_html_name(self.form, self.form.name_for_email), None))
self.assertEqual(expected, actual)
self.form.data = original_data
self.form.fields = original_fields
self.form.computed_fields = original_computed_fields
self.form._errors = original_errors
self.form.cleaned_data = original_cleaned_data
if original_errors is None:
del self.form._errors
if original_cleaned_data is None:
del self.form.cleaned_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_email_works_as_username_handle_flag_field(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n email_val = self.form_test_data.get(self.form.name_for_email) # was overwritten for form request.\n new_cleaned_data = {self.form.name_for_user: 'test_value', self.form.name_for_email: email_val}\n new_cleaned_data[self.form.USERNAME_FLAG_FIELD] = False\n user_field = self.form.computed_fields.pop(self.form.name_for_user, None)\n self.form.fields.update({self.form.name_for_user: user_field})\n email_field = self.form.fields[self.form.name_for_email]\n email_field.initial = getattr(self.user, self.form.name_for_user)\n self.form.cleaned_data = new_cleaned_data.copy()\n expected = {}\n actual = self.form.handle_flag_field(self.form.name_for_email, self.form.name_for_user)\n actual_username = self.form.cleaned_data.get(self.form.name_for_user, None)\n\n self.assertIsNotNone(email_val)\n self.assertIsNotNone(user_field)\n self.assertTrue(email_field.has_changed(email_field.initial, self.form.cleaned_data[self.form.name_for_email]))\n self.assertNotEqual(getattr(self.user, self.form.name_for_user), email_val)\n self.assertNotEqual(new_cleaned_data[self.form.name_for_user], actual_username)\n self.assertEqual(email_val, actual_username)\n self.assertEqual(expected, actual)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def validate_email(self, data, field_name):\n existing = User.objects.filter(email__iexact=data['email'])\n if existing.exists():\n raise fields.ValidationError(\"A user with that email already exists.\")\n else:\n return data",
"def validate_email(self, data):\n user = account_models.User.objects.filter(username__iexact=data, is_active=True)\n if user:\n return data\n raise serializers.ValidationError(\"Email address not verified for any user account\")",
"def clean_username_or_email(self):\n username_or_email = self.cleaned_data['username_or_email']\n try:\n user = User.objects.get(username__iexact=username_or_email)\n self.profile = user.profile\n except User.DoesNotExist:\n try:\n self.profile = Profile.objects.get(\n settings__email__iexact=username_or_email)\n except Profile.DoesNotExist:\n raise forms.ValidationError(ERRORS['invalid_username'])\n return username_or_email",
"def clean_email(self):\n try:\n user = User.objects.get(email__iexact=self.cleaned_data['email'])\n except User.DoesNotExist:\n return self.cleaned_data['email']\n except User.MultipleObjectsReturned:\n pass\n raise forms.ValidationError(_(u'This email address is already in use. Please supply a different email address.')\n )",
"def clean_email(self):\n try:\n user = User.objects.get(email__iexact=self.cleaned_data['email'])\n except User.DoesNotExist:\n return self.cleaned_data['email']\n raise forms.ValidationError(_(\"A user with that email already exists.\"))",
"def validate_email(self, data):\n users = User.objects.filter(email=data)\n if not self.instance and len(users) != 0:\n raise serializers.ValidationError(data+\" ya esta registrado\")\n\n elif self.instance and self.instance.username != data and len(users) != 0:\n raise serializers.ValidationError(data+\" ya esta registrado\")\n\n else:\n return data",
"def clean_email(self):\n if User.objects.filter(email__iexact=self.cleaned_data['email']):\n raise forms.ValidationError(_(\"This email address is already in use. Please supply a different email address.\"))\n return self.cleaned_data['email']",
"def clean_email(self):\n if User.objects.filter(email__iexact=self.cleaned_data['email']):\n raise forms.ValidationError(_(\"This email address is already in use. Please supply a different email address.\"))\n return self.cleaned_data['email']",
"def clean_email(self):\r\n if User.objects.filter(email__iexact=self.cleaned_data['email']):\r\n raise forms.ValidationError(_(u'This email address is already in use. Please supply a different email address.'))\r\n return self.cleaned_data['email']",
"def clean_email(self):\n try:\n user = User.objects.get(email__exact=self.cleaned_data['email'])\n except User.DoesNotExist:\n return self.cleaned_data['email']\n raise forms.ValidationError(_(u'This email address is already in use. Please supply a different email address.'))",
"def matches_email(handle, email):\n matching_handle = find_user(handle)\n user = matching_handle and get_user(matching_handle)\n if not user:\n log.debug('password reset failed, no such user {0} for email {1}.'\n .format(handle, email))\n return False\n elif not user.email.strip():\n log.debug('password reset failed, user {0} has no email on file.'\n .format(handle))\n return False\n elif email.lower() != user.email.lower():\n log.debug('pasword reset failed, email mismatch: {0} != {1}.'\n .format(email, user.email))\n return False\n\n # success !\n return user",
"def clean_email(self):\n existing = User.objects.filter(email__iexact=self.cleaned_data['email'])\n if existing.exists():\n raise forms.ValidationError(_(\"This email address is already in use. Please enter a different email \"\n \"address!\"))\n else:\n return self.cleaned_data['email']",
"def clean_email(self):\n if User.objects.filter(email__iexact=self.cleaned_data['email']):\n raise forms.ValidationError('This email address is already in use. Please supply a different email address.')\n return self.cleaned_data['email']",
"def verification_email_and_return_username(value: str) -> str:\n\n user = User.objects.filter(email=value)\n if len(user) != 0:\n return user[0].username\n else:\n raise serializers.ValidationError('User with given credentials are not found')",
"def test_bad_flag_handle_flag_field(self):\n original_data = self.form.data\n original_fields = self.form.fields\n original_computed_fields = self.form.computed_fields\n original_errors = getattr(self.form, '_errors', None)\n original_cleaned_data = getattr(self.form, 'cleaned_data', None)\n self.form.data = original_data.copy()\n self.form.fields = original_fields.copy()\n self.form.computed_fields = original_computed_fields.copy()\n self.form._errors = ErrorDict() if original_errors is None else original_errors.copy()\n email_val = self.form_test_data.get(self.form.name_for_email) # was overwritten for form request.\n new_cleaned_data = {self.form.name_for_user: 'test_value', self.form.name_for_email: email_val}\n new_cleaned_data[self.form.USERNAME_FLAG_FIELD] = True\n user_field = self.form.computed_fields.pop(self.form.name_for_user, None)\n self.form.fields.update({self.form.name_for_user: user_field})\n email_field = self.form.fields[self.form.name_for_email]\n email_field.initial = getattr(self.user, self.form.name_for_user)\n self.form.cleaned_data = new_cleaned_data.copy()\n message = \"Un-check the box, or leave empty, if you want to use this email address. \"\n expected = {self.form.USERNAME_FLAG_FIELD: message}\n actual = self.form.handle_flag_field(self.form.name_for_email, self.form.name_for_user)\n actual_username = self.form.cleaned_data.get(self.form.name_for_user, None)\n\n self.assertIsNotNone(email_val)\n self.assertIsNotNone(user_field)\n self.assertTrue(email_field.has_changed(email_field.initial, self.form.cleaned_data[self.form.name_for_email]))\n self.assertNotEqual(getattr(self.user, self.form.name_for_user), email_val)\n self.assertEqual(new_cleaned_data[self.form.name_for_user], actual_username)\n self.assertNotEqual(email_val, actual_username)\n self.assertEqual(expected, actual)\n\n self.form.data = original_data\n self.form.fields = original_fields\n self.form.computed_fields = original_computed_fields\n self.form._errors = original_errors\n self.form.cleaned_data = original_cleaned_data\n if original_errors is None:\n del self.form._errors\n if original_cleaned_data is None:\n del self.form.cleaned_data",
"def clean_email_or_username(self):\n email_or_username = self.cleaned_data[self.Fields.EMAIL_OR_USERNAME].strip()\n\n if not email_or_username:\n # The field is blank; we just return the existing blank value.\n return email_or_username\n\n email = email_or_username__to__email(email_or_username)\n validate_email_to_link(email, email_or_username, ValidationMessages.INVALID_EMAIL_OR_USERNAME)\n\n return email",
"def validate_email(self, data):\n if User.objects.filter(email=data.lower()).exists():\n raise serializers.ValidationError('Already registered email!')\n return data.lower()",
"def clean_email(self):\r\n email = self.cleaned_data.get(\"email\")\r\n\r\n if not email: \r\n return email\r\n\r\n if User.objects.filter(email__iexact=email).exclude(pk=self.instance.pk):\r\n raise forms.ValidationError(\"That e-mail is already used.\")\r\n else:\r\n return email",
"def clean_email(self):\n # NOTE: all emails are stored in lower-case\n e = self.cleaned_data['email'].lower()\n try:\n user = User.objects.get(email=e)\n if not user.is_active:\n msg = 'This user account has not been confirmed yet'\n raise forms.ValidationError(msg)\n except User.DoesNotExist:\n msg = 'This email is not associated with an account'\n raise forms.ValidationError(msg)\n return e",
"def validate_username(self, field):\n if User.query.filter_by(username=field.data).first():\n raise ValidationError(\"Username already in use.\")",
"def validate_email(self, value):\n if not User.objects.filter(email=value).exists():\n raise serializers.ValidationError('User with this email does not exist.')\n return value",
"def validate_email(self, value):\n if not User.objects.filter(email=value).exists():\n raise serializers.ValidationError('User with this email does not exist.')\n return value",
"def clean_email(self):\r\n email = self.cleaned_data[\"email\"]\r\n #The line below contains the only change, removing is_active=True\r\n self.users_cache = User.objects.filter(email__iexact=email)\r\n if not len(self.users_cache):\r\n raise forms.ValidationError(self.error_messages['unknown'])\r\n if any((user.password == UNUSABLE_PASSWORD)\r\n for user in self.users_cache):\r\n raise forms.ValidationError(self.error_messages['unusable'])\r\n return email",
"def clean_email(self):\n # NOTE: all emails are stored in lower case\n e = self.cleaned_data['email'].lower()\n if User.objects.filter(email=e).count() > 0:\n raise forms.ValidationError('An existing account is using that email address.')\n return e",
"def clean_email(self):\n e = self.cleaned_data['email']\n try:\n user = User.objects.get(email=e)\n if not user.is_active:\n msg = 'This user account has not been confirmed yet'\n raise forms.ValidationError(msg)\n except User.DoesNotExist:\n pass\n # msg = 'This email is not associated with an account'\n # raise forms.ValidationError(msg)\n return e",
"def test_no_flag_handle_flag_field(self):\n original_flag_name = self.form.USERNAME_FLAG_FIELD\n self.form.USERNAME_FLAG_FIELD = \"This is not a valid field name\"\n expected = None\n actual = self.form.handle_flag_field(self.form.name_for_email, self.form.name_for_user)\n\n self.assertEqual(expected, actual)\n self.form.USERNAME_FLAG_FIELD = original_flag_name",
"def usernamesuggestion(request):\n if request.POST:\n email = request.POST.get('username', '')\n if email:\n usrobj = get_or_none(model=CustomUser, email=email)\n if not usrobj:\n logger_stats.info('Username is Available %s ' % (email))\n return HttpResponse(\"Username is Available\", content_type=\"text/plain\")\n # return \"Username is Available\"\n else:\n \"\"\"\n Check whether the input is email or username, if email return error message\n \"\"\"\n if '@' in email:\n is_valid = validate_email(email)\n if is_valid:\n returnmsg = \"Entered Email ID already taken \"\n logger_stats.info('Entered Email ID already taken %s ' % (email))\n return HttpResponse(returnmsg, content_type=\"text/plain\")\n returnmsg = \"Email is not in correct format\"\n logger_stats.info('Email is not in correct format %s ' % (email))\n return HttpResponse(returnmsg, content_type=\"text/plain\")\n returnmsg = \"Entered username already taken \" + email\n numlist = re.findall(r'\\d+', email)\n if numlist:\n replacenum = int(numlist[0])\n while (True):\n replacenum += 1\n newusername = str(replacenum)\n usrobj = get_or_none(\n model=CustomUser, email=email + newusername)\n if not usrobj:\n returnmsg += '\\n Available username is ' + \\\n email + newusername\n logger_stats.info(returnmsg)\n return HttpResponse(returnmsg, content_type=\"text/plain\")\n else:\n startno = 0\n while (True):\n startno += 1\n usrobj = get_or_none(\n model=CustomUser, email=email + str(startno))\n if not usrobj:\n returnmsg += '\\n Available username is ' + \\\n email + str(startno)\n logger_stats.info(returnmsg)\n return HttpResponse(returnmsg, content_type=\"text/plain\")\n return render_to_response('login.html', context_instance=RequestContext(request))",
"def username_exist_check(form, field):\n username = field.data\n user = UserModel.query(UserModel.username==username).get()\n if user:\n raise validators.ValidationError('username exists, choose a different one!')",
"def clean_username(self):\n username = self.cleaned_data['username']\n\n try:\n User.objects.get(email=username)\n except ObjectDoesNotExist:\n raise forms.ValidationError('Selected user does not exist.')\n\n return username"
] | [
"0.66981214",
"0.6349816",
"0.62762165",
"0.604796",
"0.5953749",
"0.5908456",
"0.59008956",
"0.58932865",
"0.58932865",
"0.58898187",
"0.5876202",
"0.58696085",
"0.5861591",
"0.58554953",
"0.58522695",
"0.5841933",
"0.5832264",
"0.58276683",
"0.5810914",
"0.57974815",
"0.57880896",
"0.5785035",
"0.5785035",
"0.5763644",
"0.57393813",
"0.5732695",
"0.56489754",
"0.5600786",
"0.5597124",
"0.5593124"
] | 0.6850138 | 0 |
Remove & return the named field if it had been moved from fields to removed_fields or computed_fields. | def get_missing_field(self, name):
source = getattr(self.form, 'removed_fields', {})
if issubclass(self.form.__class__, ComputedFieldsMixIn):
source = self.form.computed_fields
field = source.pop(name, None)
return field | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def item_remove_field(self, item, field_name):\n\t\treturn self._modify_object(item=item, field_name=field_name, new_value=None, new_field_name=None)",
"def remove_field():\n _id = request.form['_id']\n data, code, message = FIELD_SERVICE.remove_field(_id)\n return __result(data, code, message)",
"def remove_field_name(a, name):\n names = list(a.dtype.names)\n if name in names:\n names.remove(name)\n b = a[names]\n return b",
"def test_handle_removals_remove_field_names(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n remove_names = ['second', 'last']\n expected_fields = {name: field for name, field in fields.items() if name not in remove_names}\n self.form.removed_fields = {}\n self.form.remove_field_names = remove_names\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result) + len(remove_names))\n self.assertEqual(len(remove_names), len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(expected_fields, result)\n self.assertIs(fields, result)",
"def test_handle_removals_named_fields_not_in_data(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n remove_names = ['second', 'last']\n original_data = self.form.data\n data = original_data.copy()\n data.appendlist(remove_names[1], 'test_data_last')\n data._mutable = False\n self.form.data = data\n expected_fields = {name: field for name, field in fields.items() if name != remove_names[0]}\n self.form.removed_fields = {}\n self.form.remove_field_names = remove_names\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result) + len(remove_names) - 1)\n self.assertEqual(len(remove_names) - 1, len(self.form.removed_fields))\n self.assertEqual(1, len(self.form.remove_field_names))\n self.assertDictEqual(expected_fields, result)\n self.assertIs(fields, result)\n\n self.form.data = original_data",
"def test_entities__Entity__removeField__2(entity_with_field, field):\n entity_with_field.removeField(field)\n assert field.interface is None",
"def remove(self, field_name, value, **kwargs):\n self.properties.update(kwargs)\n model = self.model.get_subclass_model(**self.properties)\n\n self.array_validate(field_name, value, model)\n return self.array_process(field_name, value, operation_type='remove')",
"def drop(self, name: str):\n del self._fields[name]",
"def drop_field(self, field):\r\n self.dropped_fields.add(field)",
"def remove(self, field, **kwargs):\n current_values = self.get_field(field)\n if isinstance(current_values, dict):\n return current_values\n elif isinstance(current_values, InstrumentedList):\n if kwargs:\n key = [i for i in kwargs][0]\n try:\n item_index = current_values.index([\n i for i in current_values\n if getattr(i, key) == kwargs[key]\n ][0])\n current_values.pop(item_index)\n except Exception as e:\n return {\n \"message\": \"Ensure the arguments passed are valid.\",\n \"help\": \"Should be of an existent object and unique.\",\n \"exception\": str(e)\n }\n else:\n setattr(self, field, InstrumentedList([]))\n else:\n setattr(self, field, None)\n self.save()",
"def del_column(self, fieldname):\n ...",
"def delete_field(self):\n self.exec_command(b\"DeleteField\")",
"def test_entities__Entity__removeField__1(entities, entity_with_field, field):\n assert field in entities.values()\n entity_with_field.removeField(field)\n assert field not in entities.values()",
"def get_field(self, name):\n for field_name, field in self._all_fields.iteritems():\n if name == self._sanitize_field_name(field_name):\n return field",
"def test_handle_removals_missing_removed_fields(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n self.form.remove_field_names = []\n if hasattr(self.form, 'removed_fields'):\n del self.form.removed_fields\n result = self.form.handle_removals(fields)\n\n self.assertTrue(hasattr(self.form, 'removed_fields'))\n self.assertEqual(len(original_fields), len(result))\n self.assertEqual(0, len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(original_fields, result)\n self.assertIs(fields, result)",
"def drem(self, name):\n return self.rem(name)",
"def revive(self):\n field_name = self.get_delete_flag_field_name()\n return self.update(**{field_name: None})",
"def test_entities__Entity__removeField__3(entity_with_field, field):\n entity_with_field.removeField(field)\n assert None is zope.component.queryMultiAdapter(\n (entity, Dummy()), IField, name=u'Field')\n assert None is IEntity(field, None)",
"def test_unchanged_handle_removals(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n self.form.removed_fields = {}\n self.form.remove_field_names = []\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result))\n self.assertEqual(0, len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(original_fields, result)\n self.assertIs(fields, result)",
"def drop(self, fields, inplace=True):\n if inplace:\n obj = self\n else:\n obj = copy.deepcopy(self)\n\n for field in list(fields):\n del obj[field]\n\n return obj",
"def test_handle_removals_missing_remove_field_names(self):\n original_fields = self.form.fields\n fields = original_fields.copy()\n if hasattr(self.form, 'remove_field_names'):\n del self.form.remove_field_names\n\n with self.assertRaises(ImproperlyConfigured):\n self.form.handle_removals(fields)",
"def deletefield_serialized(self, serialized_dict_fieldname, keyname):\n # create on first use\n sdict = self.getcreate_serializedbdict_forfield(serialized_dict_fieldname)\n sdict.delete_keyval(keyname)\n self.set_isdirty(True)",
"def deletefield_serialized(self, serialized_dict_fieldname, keyname):\n # create on first use\n sdict = self.getcreate_serializedbdict_forfield(serialized_dict_fieldname)\n sdict.delete_keyval(keyname)\n self.set_isdirty(True)",
"def delete(self, using=None):\n self.model.remove_field(self)\n\n field_attr = field_registry.field_map[self.type]\n specific = getattr(self, field_attr, None)\n specific.delete()\n\n super(Field, self).delete(using)",
"def remove_filter_field(self, field):\n if self.filters:\n category_filter = self.filters.get(str(field.category.id), None)\n\n if category_filter:\n field_filter = category_filter.pop(field.key, None)\n\n if field_filter:\n self.save()",
"def get_field(self, field_name):\n for f in self.fields:\n if f.name.lower() == field_name.lower():\n return f\n return None",
"def test_handle_removals_add_if_named_in_data(self):\n original_data = self.form.data\n original_fields = self.form.fields\n fields = original_fields.copy()\n remove_names = ['second', 'last']\n self.form.removed_fields = {name: fields.pop(name) for name in remove_names if name in fields}\n self.form.remove_field_names = []\n expected_fields = dict(**fields, **self.form.removed_fields)\n test_data = original_data.copy()\n test_data.update({name: f\"value_{name}\" for name in remove_names})\n test_data._mutable = False\n self.form.data = test_data\n result = self.form.handle_removals(fields)\n\n self.assertEqual(len(original_fields), len(result))\n self.assertEqual(0, len(self.form.removed_fields))\n self.assertEqual(0, len(self.form.remove_field_names))\n self.assertDictEqual(expected_fields, result)\n self.assertDictEqual(original_fields, result)\n self.assertIs(fields, result)\n\n self.data = original_data",
"def delete_field(model, *arg):\n return model._pw_index_.delete_field(*arg)",
"def renamed(self, name: typing.Optional[str]) -> 'Field':\n return self if name == self.name else Field(self.kind, name)",
"def getFieldValue (self, fieldname):\n return self._modified_values.get(fieldname, None) or self._original_values[fieldname]"
] | [
"0.6972614",
"0.6878197",
"0.6414154",
"0.60368294",
"0.5986027",
"0.59363645",
"0.5931434",
"0.59127325",
"0.59127206",
"0.58696914",
"0.5852019",
"0.58399874",
"0.5787753",
"0.5703484",
"0.56468785",
"0.5598534",
"0.5577256",
"0.55616206",
"0.555367",
"0.5531378",
"0.5515201",
"0.549952",
"0.549952",
"0.5457292",
"0.5440753",
"0.54242676",
"0.540514",
"0.5380767",
"0.5366829",
"0.5339482"
] | 0.73546433 | 0 |
Returns True if form.country_optional and form.data['country_flag'] are True, else returns False. | def test_condition_alt_country(self):
original_flag = self.form.country_optional
self.form.country_optional = True
original_data = getattr(self.form, 'data', None)
test_data = original_data.copy()
test_data['country_flag'] = True
self.form.data = test_data
first_expect = True
first_actual = self.form.condition_alt_country()
self.form.data['country_flag'] = False
second_expect = False
second_actual = self.form.condition_alt_country()
self.form.data['country_flag'] = True
self.form.country_optional = False
third_expect = False
third_actual = self.form.condition_alt_country()
self.assertEqual(first_expect, first_actual)
self.assertEqual(second_expect, second_actual)
self.assertEqual(third_expect, third_actual)
self.form.country_optional = original_flag
self.form.data = original_data
if original_data is None:
del self.form.data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_clean_country_flag(self):\n # country_flag = self.cleaned_data.get('country_flag', None)\n # field = self.fields.get(self.country_field_name, None)\n # if not field and hasattr(self, 'computed_fields'):\n # field = self.computed_fields.get(self.country_field_name, None)\n # if field.initial == self.cleaned_data.get(self.country_field_name, None)\n pass",
"def validateCountry(self, country_name):\n if country_name in self.travel_db.countries:\n return True\n else:\n return False",
"def _is_valid_country(flag: str) -> bool:\n\n return bool(\n COUNTRY_CODE_FLAGS_REGEX.findall(flag)\n )",
"def checkState(self, state, country):\n if country == 'US':\n # US_STATES is tuple of tuples like (('KY', 'Kentucky'), ...)\n states = [s[0] for s in US_STATES]\n# elif:\n # TODO other countries for which localflavor submodules exist\n else:\n return True # No local flavor data to use \n return state in states",
"def _is_form_filled_out(self):\n\t\tif self.entry_amount.get() == \"\":\n\t\t\treturn False\n\n\t\tif self.selected_food.get() == \"Select food\":\n\t\t\treturn False\n\n\t\treturn True",
"def is_country_selection_criteria_field_present_in_re_analysis_page(self):\n return self.is_specific_selection_criteria_filter_present(self.re_analysis_page_div_id, self.country_label_name)",
"def test_pass_through_prep_country_fields(self):\n original_flag = self.form.country_optional\n self.form.country_optional = False # True\n original_fields = self.form.fields\n self.form.fields = original_fields.copy()\n remaining_fields = original_fields.copy()\n opts, field_rows = {'fake_opts': 'fake'}, [{'name': 'assigned_field'}]\n args = ['arbitrary', 'input', 'args']\n kwargs = {'test_1': 'data_1', 'test_2': 'data_2'}\n\n expected = (opts.copy(), field_rows.copy(), remaining_fields.copy(), *args, kwargs.copy())\n actual = self.form.prep_country_fields(opts, field_rows, remaining_fields, *args, **kwargs)\n self.assertEqual(expected, actual)\n\n self.form.country_optional = original_flag\n self.form.fields = original_fields",
"def is_country_selection_criteria_field_present_in_vendor_profile_page(self):\n return self.is_specific_selection_criteria_filter_present(self.vendor_profile_page_div_id, self.country_label_name)",
"def is_country_selection_criteria_field_present_in_compare_price_list_pop_up(self):\n return self.is_specific_selection_criteria_filter_present(self.compare_price_list_pop_up_div_id, self.country_label_name)",
"def is_country_selection_criteria_field_present_in_view_price_list_details_rate_page(self):\n return self.is_specific_selection_criteria_filter_present(self.view_price_list_details_rate_page_div_id, self.country_label_name)",
"def test_on_post_display_local_to_foreign(self):\n # data.get('country_flag', None)\n # address_display_version = 'foreign' if country_flag else 'local'\n # form.set_alt_data(name='country_display', field=self.fields['country_display'], value=address_display_version)\n pass",
"def is_optional(self) -> bool:\n return bool(AnnotationWrapper.opt_field_re.match(self.data))",
"def is_country_selection_criteria_field_present_in_vendor_profile_dialed_digits_page(self):\n return self.is_specific_selection_criteria_filter_present(self.vendor_profile_dialed_digits_page_div_id, self.country_label_name)",
"def is_country_selection_criteria_field_present_in_view_price_list_details_ref_rates_page(self):\n return self.is_specific_selection_criteria_filter_present(self.view_price_list_ref_rates_page_div_id, self.country_label_name)",
"def test_country_overrides(self):\n # Retrieve the registration form description\n with override_settings(REGISTRATION_EXTRA_FIELDS={\"country\": \"required\"}):\n response = self.client.get(self.url)\n self.assertHttpOK(response)\n\n self.assertContains(response, 'Kosovo')",
"def is_country_selection_criteria_field_present_in_vendor_profile_destinations_page(self):\n return self.is_specific_selection_criteria_filter_present(self.vendor_profile_destinations_page_div_id, self.country_label_name)",
"def is_country_selection_criteria_field_present_in_view_price_list_details_dialed_digits_page(self):\n return self.is_specific_selection_criteria_filter_present(self.view_price_list_dialed_digits_page_div_id, self.country_label_name)",
"def test_prep_country_fields(self):\n original_flag = self.form.country_optional\n self.form.country_optional = True\n original_fields = self.form.fields\n original_removed = getattr(self.form, 'removed_fields', None)\n original_computed = getattr(self.form, 'computed_fields', None)\n self.form.fields = original_fields.copy()\n if original_removed is not None:\n self.form.removed_fields = original_removed.copy()\n if original_computed is not None:\n self.form.computed_fields = original_computed.copy()\n remaining = original_fields.copy()\n opts, field_rows = {'fake_opts': 'fake', 'fields': ['nope']}, [{'name': 'assigned_field'}]\n args = ['arbitrary', 'input', 'args']\n kwargs = {'test_1': 'data_1', 'test_2': 'data_2'}\n field_names = (self.form.country_field_name, 'country_flag', )\n if not any(remaining.get(name, None) for name in field_names):\n fix_fields = {name: self.get_missing_field(name) for name in field_names if name not in remaining}\n remaining.update(fix_fields)\n expected_add = {name: remaining[name] for name in field_names if name in remaining}\n expected_field_rows = field_rows.copy()\n expected_field_rows.append(expected_add)\n expected_remaining = {name: field for name, field in remaining.items() if name not in expected_add}\n expected_opts = deepcopy(opts)\n expected_opts['fields'].append(field_names)\n\n sent = (opts, field_rows, remaining, *args)\n r_opts, r_rows, r_remaining, *r_args, r_kwargs = self.form.prep_country_fields(*sent, **kwargs)\n self.assertEqual(expected_opts, r_opts)\n self.assertEqual(expected_field_rows, r_rows)\n self.assertEqual(expected_remaining, r_remaining)\n self.assertEqual(args, r_args)\n self.assertEqual(kwargs, r_kwargs)\n\n self.form.country_optional = original_flag\n self.form.fields = original_fields\n if original_removed is not None:\n self.form.removed_fields = original_removed\n if original_computed is not None:\n self.form.computed_fields = original_computed",
"def required(label, field, data, **kwargs):\n if not field in data:\n return False\n\n value = data[field]\n\n if value == None:\n return False\n elif type(value) is bool:\n return True\n elif not value:\n return False\n\n return True",
"def test_on_post_display_foreign_to_foreign(self):\n # data.get('country_flag', None)\n # address_display_version = 'foreign' if country_flag else 'local'\n # form.set_alt_data(name='country_display', field=self.fields['country_display'], value=address_display_version)\n pass",
"def test_on_post_display_foreign_to_local(self):\n # data.get('country_flag', None)\n # address_display_version = 'foreign' if country_flag else 'local'\n # form.set_alt_data(name='country_display', field=self.fields['country_display'], value=address_display_version)\n pass",
"def test_zip_state_requirements(self):\n form_data = self.form_data(clear=['billing_state'])\n form = DonationPaymentForm(data=form_data)\n self.assertFalse(form.is_valid())\n\n form_data = self.form_data(billing_state='')\n form = DonationPaymentForm(data=form_data)\n self.assertFalse(form.is_valid())\n\n form_data = self.form_data(clear=['billing_zip'])\n form = DonationPaymentForm(data=form_data)\n self.assertFalse(form.is_valid())\n\n form_data = self.form_data(clear=['billing_state', 'billing_zip'])\n form_data['country'] = 'CAN'\n form = DonationPaymentForm(data=form_data)\n self.assertTrue(form.is_valid())",
"def valid(self) -> bool:\n are_populated = [bool(getattr(self, fld_nm)) for fld_nm in self.necessary_fields]\n return all(are_populated)",
"def IsCountryOrStateOf(country1, country2):\n return (country1 == country2 or\n (country2 is not None and country1.startswith(country2 + \"_\")))",
"def clean(self):\n cleaned_data = super(AddressForm, self).clean()\n state = cleaned_data.get('state')\n country = cleaned_data.get('country') # A Country instance\n postal_code = cleaned_data.get('postal_code')\n\n # The state must be valid for the country\n if state and country and not self.checkState(state, country):\n self.add_error('state', forms.ValidationError('Invalid state for {0}.'.format(country)))\n\n # The postal code must be valid for the country\n if postal_code and country:\n try:\n self.checkPostalCode(postal_code, country)\n except forms.ValidationError as e:\n self.add_error('postal_code', e)\n return cleaned_data",
"def country_flag(country):\n\tif not country:\n\t\treturn u''\n\tresult = Country.objects.filter(name__icontains=country)\n\tif result:\n\t\tc = result[0]\n\t\tiso = c.iso\n\t\tflag_location = iso_flag(iso)\n\t\treturn flag_location\n\treturn u''",
"def valid(self, has_inputs: bool) -> bool:\n if self.value == 'dynamic':\n return has_inputs\n else:\n return self.value == 'always'",
"def test_prep_country_fields_flat(self):\n original_flag = self.form.country_optional\n self.form.country_optional = True\n original_fields = self.form.fields\n original_removed = getattr(self.form, 'removed_fields', None)\n original_computed = getattr(self.form, 'computed_fields', None)\n self.form.fields = original_fields.copy()\n if original_removed is not None:\n self.form.removed_fields = original_removed.copy()\n if original_computed is not None:\n self.form.computed_fields = original_computed.copy()\n remaining = original_fields.copy()\n opts, field_rows = {'fake_opts': 'fake', 'fields': ['nope']}, [{'name': 'assigned_field'}]\n args = ['arbitrary', 'input', 'args']\n kwargs = {'test_1': 'data_1', 'test_2': 'data_2'}\n field_names = (self.form.country_field_name, 'country_flag', )\n if not any(remaining.get(name, None) for name in field_names):\n fix_fields = {name: self.get_missing_field(name) for name in field_names if name not in remaining}\n remaining.update(fix_fields)\n expected_add = {name: remaining[name] for name in field_names if name in remaining}\n expected_field_rows = field_rows.copy()\n expected_field_rows.append(expected_add)\n expected_remaining = {name: field for name, field in remaining.items() if name not in expected_add}\n expected_opts = deepcopy(opts)\n # expected_opts['fields'].append(field_names)\n kwargs['flat_fields'] = True\n expected_remaining.update(expected_add)\n\n sent = (opts, field_rows, remaining, *args)\n r_opts, r_rows, r_remaining, *r_args, r_kwargs = self.form.prep_country_fields(*sent, **kwargs)\n self.assertEqual(expected_opts, r_opts)\n self.assertEqual(expected_field_rows, r_rows)\n self.assertEqual(expected_remaining, r_remaining)\n self.assertEqual(args, r_args)\n self.assertEqual(kwargs, r_kwargs)\n\n self.form.country_optional = original_flag\n self.form.fields = original_fields\n if original_removed is not None:\n self.form.removed_fields = original_removed\n if original_computed is not None:\n self.form.computed_fields = original_computed\n pass",
"def validate(self, attrs):\n if 'filled_out' in attrs and not attrs['filled_out']:\n raise ValidationError(\"filled_out cannot be set to false\")\n\n if 'agreed_to_terms_of_service' in attrs and not attrs['agreed_to_terms_of_service']:\n raise ValidationError(\"agreed_to_terms_of_service cannot be set to false\")\n\n # Postal code is only required in United States and Canada\n country = attrs.get(\"country\", \"\")\n postal_code = attrs.get(\"postal_code\", \"\")\n if country in (\"US\", \"CA\") and not postal_code:\n raise ValidationError(\"postal_code may not be blank\")\n\n return super().validate(attrs)",
"def no_flags_set(self):\n # TODO: unit test me\n return not any(\n (\n self.flag_bookmarked,\n self.flag_candidate,\n self.flag_final_causative,\n self.flag_for_validation,\n self.flag_molecular != \"empty\",\n self.flag_visual != \"empty\",\n self.flag_validation != \"empty\",\n self.flag_phenotype_match != \"empty\",\n self.flag_summary != \"empty\",\n )\n )"
] | [
"0.7646883",
"0.6458368",
"0.64384305",
"0.61835104",
"0.61295354",
"0.61058503",
"0.60980874",
"0.60951024",
"0.59862053",
"0.5962255",
"0.5935159",
"0.59304583",
"0.5924629",
"0.5859196",
"0.58489645",
"0.58467984",
"0.5841211",
"0.5815134",
"0.57613146",
"0.5755242",
"0.57274115",
"0.5686373",
"0.55912447",
"0.55575097",
"0.5554145",
"0.55525917",
"0.5537167",
"0.5470278",
"0.54670995",
"0.5462394"
] | 0.6825711 | 1 |
Returns unmodified inputs if form.country_optional is False. | def test_pass_through_prep_country_fields(self):
original_flag = self.form.country_optional
self.form.country_optional = False # True
original_fields = self.form.fields
self.form.fields = original_fields.copy()
remaining_fields = original_fields.copy()
opts, field_rows = {'fake_opts': 'fake'}, [{'name': 'assigned_field'}]
args = ['arbitrary', 'input', 'args']
kwargs = {'test_1': 'data_1', 'test_2': 'data_2'}
expected = (opts.copy(), field_rows.copy(), remaining_fields.copy(), *args, kwargs.copy())
actual = self.form.prep_country_fields(opts, field_rows, remaining_fields, *args, **kwargs)
self.assertEqual(expected, actual)
self.form.country_optional = original_flag
self.form.fields = original_fields | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_prep_country_fields(self):\n original_flag = self.form.country_optional\n self.form.country_optional = True\n original_fields = self.form.fields\n original_removed = getattr(self.form, 'removed_fields', None)\n original_computed = getattr(self.form, 'computed_fields', None)\n self.form.fields = original_fields.copy()\n if original_removed is not None:\n self.form.removed_fields = original_removed.copy()\n if original_computed is not None:\n self.form.computed_fields = original_computed.copy()\n remaining = original_fields.copy()\n opts, field_rows = {'fake_opts': 'fake', 'fields': ['nope']}, [{'name': 'assigned_field'}]\n args = ['arbitrary', 'input', 'args']\n kwargs = {'test_1': 'data_1', 'test_2': 'data_2'}\n field_names = (self.form.country_field_name, 'country_flag', )\n if not any(remaining.get(name, None) for name in field_names):\n fix_fields = {name: self.get_missing_field(name) for name in field_names if name not in remaining}\n remaining.update(fix_fields)\n expected_add = {name: remaining[name] for name in field_names if name in remaining}\n expected_field_rows = field_rows.copy()\n expected_field_rows.append(expected_add)\n expected_remaining = {name: field for name, field in remaining.items() if name not in expected_add}\n expected_opts = deepcopy(opts)\n expected_opts['fields'].append(field_names)\n\n sent = (opts, field_rows, remaining, *args)\n r_opts, r_rows, r_remaining, *r_args, r_kwargs = self.form.prep_country_fields(*sent, **kwargs)\n self.assertEqual(expected_opts, r_opts)\n self.assertEqual(expected_field_rows, r_rows)\n self.assertEqual(expected_remaining, r_remaining)\n self.assertEqual(args, r_args)\n self.assertEqual(kwargs, r_kwargs)\n\n self.form.country_optional = original_flag\n self.form.fields = original_fields\n if original_removed is not None:\n self.form.removed_fields = original_removed\n if original_computed is not None:\n self.form.computed_fields = original_computed",
"def test_prep_country_fields_flat(self):\n original_flag = self.form.country_optional\n self.form.country_optional = True\n original_fields = self.form.fields\n original_removed = getattr(self.form, 'removed_fields', None)\n original_computed = getattr(self.form, 'computed_fields', None)\n self.form.fields = original_fields.copy()\n if original_removed is not None:\n self.form.removed_fields = original_removed.copy()\n if original_computed is not None:\n self.form.computed_fields = original_computed.copy()\n remaining = original_fields.copy()\n opts, field_rows = {'fake_opts': 'fake', 'fields': ['nope']}, [{'name': 'assigned_field'}]\n args = ['arbitrary', 'input', 'args']\n kwargs = {'test_1': 'data_1', 'test_2': 'data_2'}\n field_names = (self.form.country_field_name, 'country_flag', )\n if not any(remaining.get(name, None) for name in field_names):\n fix_fields = {name: self.get_missing_field(name) for name in field_names if name not in remaining}\n remaining.update(fix_fields)\n expected_add = {name: remaining[name] for name in field_names if name in remaining}\n expected_field_rows = field_rows.copy()\n expected_field_rows.append(expected_add)\n expected_remaining = {name: field for name, field in remaining.items() if name not in expected_add}\n expected_opts = deepcopy(opts)\n # expected_opts['fields'].append(field_names)\n kwargs['flat_fields'] = True\n expected_remaining.update(expected_add)\n\n sent = (opts, field_rows, remaining, *args)\n r_opts, r_rows, r_remaining, *r_args, r_kwargs = self.form.prep_country_fields(*sent, **kwargs)\n self.assertEqual(expected_opts, r_opts)\n self.assertEqual(expected_field_rows, r_rows)\n self.assertEqual(expected_remaining, r_remaining)\n self.assertEqual(args, r_args)\n self.assertEqual(kwargs, r_kwargs)\n\n self.form.country_optional = original_flag\n self.form.fields = original_fields\n if original_removed is not None:\n self.form.removed_fields = original_removed\n if original_computed is not None:\n self.form.computed_fields = original_computed\n pass",
"def test_clean_country_flag(self):\n # country_flag = self.cleaned_data.get('country_flag', None)\n # field = self.fields.get(self.country_field_name, None)\n # if not field and hasattr(self, 'computed_fields'):\n # field = self.computed_fields.get(self.country_field_name, None)\n # if field.initial == self.cleaned_data.get(self.country_field_name, None)\n pass",
"def test_condition_alt_country(self):\n original_flag = self.form.country_optional\n self.form.country_optional = True\n original_data = getattr(self.form, 'data', None)\n test_data = original_data.copy()\n test_data['country_flag'] = True\n self.form.data = test_data\n first_expect = True\n first_actual = self.form.condition_alt_country()\n self.form.data['country_flag'] = False\n second_expect = False\n second_actual = self.form.condition_alt_country()\n self.form.data['country_flag'] = True\n self.form.country_optional = False\n third_expect = False\n third_actual = self.form.condition_alt_country()\n\n self.assertEqual(first_expect, first_actual)\n self.assertEqual(second_expect, second_actual)\n self.assertEqual(third_expect, third_actual)\n\n self.form.country_optional = original_flag\n self.form.data = original_data\n if original_data is None:\n del self.form.data",
"def test_clean_uses_computed(self):\n original_request = self.request\n original_form = self.form\n original_cleaned = getattr(self.form, 'cleaned_data', None)\n self.form = self.make_form_request()\n name = self.form.country_field_name\n initial = self.form.base_fields[name].initial\n cleaned = {'country_flag': True, name: initial}\n self.form.cleaned_data = cleaned\n\n self.assertNotIn(name, self.form.fields)\n self.assertIn(name, self.form.computed_fields)\n with self.assertRaisesMessage(ValidationError, \"You can input your address. \"):\n clean_flag = self.form.clean_country_flag()\n self.form.cleaned_data[name] = ''\n clean_flag = self.form.clean_country_flag()\n self.assertEqual(True, clean_flag)\n\n self.request = original_request\n self.form = original_form\n self.form.cleaned_data = original_cleaned\n if original_cleaned is None:\n del self.form.cleaned_data",
"def clean(self):\n cleaned_data = super(AddressForm, self).clean()\n state = cleaned_data.get('state')\n country = cleaned_data.get('country') # A Country instance\n postal_code = cleaned_data.get('postal_code')\n\n # The state must be valid for the country\n if state and country and not self.checkState(state, country):\n self.add_error('state', forms.ValidationError('Invalid state for {0}.'.format(country)))\n\n # The postal code must be valid for the country\n if postal_code and country:\n try:\n self.checkPostalCode(postal_code, country)\n except forms.ValidationError as e:\n self.add_error('postal_code', e)\n return cleaned_data",
"def form_InputNoneValue(request):\n schema = schemaish.Structure()\n schema.add('inputStrip', schemaish.String(default=''))\n\n form = formish.Form(schema, 'form')\n form['inputStrip'].widget = formish.Input(strip=True, none_value='BANG')\n return form",
"def _transform_inputs(self) -> None:\n self.inputs = None if self.inputs == {} else self.inputs",
"def _clean_inputs(self, inputs):\n return inputs",
"def countries(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\n return pulumi.get(self, \"countries\")",
"def countries(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\n return pulumi.get(self, \"countries\")",
"def test_on_post_display_local_to_foreign(self):\n # data.get('country_flag', None)\n # address_display_version = 'foreign' if country_flag else 'local'\n # form.set_alt_data(name='country_display', field=self.fields['country_display'], value=address_display_version)\n pass",
"def test_on_post_display_foreign_to_local(self):\n # data.get('country_flag', None)\n # address_display_version = 'foreign' if country_flag else 'local'\n # form.set_alt_data(name='country_display', field=self.fields['country_display'], value=address_display_version)\n pass",
"def checkPostalCode(self, code, country):\n if country == 'US':\n USZipCodeField().clean(code)",
"def test_zip_state_requirements(self):\n form_data = self.form_data(clear=['billing_state'])\n form = DonationPaymentForm(data=form_data)\n self.assertFalse(form.is_valid())\n\n form_data = self.form_data(billing_state='')\n form = DonationPaymentForm(data=form_data)\n self.assertFalse(form.is_valid())\n\n form_data = self.form_data(clear=['billing_zip'])\n form = DonationPaymentForm(data=form_data)\n self.assertFalse(form.is_valid())\n\n form_data = self.form_data(clear=['billing_state', 'billing_zip'])\n form_data['country'] = 'CAN'\n form = DonationPaymentForm(data=form_data)\n self.assertTrue(form.is_valid())",
"def country_hint(self, value):\n return None",
"def clean_embargoed_countries(self):\r\n embargoed_countries = self.cleaned_data[\"embargoed_countries\"]\r\n if not embargoed_countries:\r\n return ''\r\n\r\n error_countries = []\r\n\r\n for country in embargoed_countries.split(','):\r\n country = country.strip().upper()\r\n if not self._is_valid_code(country):\r\n error_countries.append(country)\r\n\r\n if error_countries:\r\n msg = 'COULD NOT PARSE COUNTRY CODE(S) FOR: {0}'.format(error_countries)\r\n msg += ' Please check the list of country codes and verify your entries.'\r\n raise forms.ValidationError(msg)\r\n\r\n return embargoed_countries",
"def clean_form(self, item, form):\n if form not in ['?']:\n return form",
"def clean(self):\n cleaned_data = super().clean()\n cleaned_data = {key: field for key, field in cleaned_data.items()\n if field is not None}\n return cleaned_data",
"def with_preset_issuing_country(self, country):\n self.__preset_issuing_country = country\n return self",
"def country_flag(country):\n\tif not country:\n\t\treturn u''\n\tresult = Country.objects.filter(name__icontains=country)\n\tif result:\n\t\tc = result[0]\n\t\tiso = c.iso\n\t\tflag_location = iso_flag(iso)\n\t\treturn flag_location\n\treturn u''",
"def _clean(self):\n return self._cleaned_data",
"def clean(self):\n cleaned_data = super(AuthorizenetSurveyPurchaseForm, self).clean()\n if cleaned_data.get(\"purchase_code\"):\n return cleaned_data\n\n for f in [\"card_number\", \"card_expiry\", \"card_ccv\"]:\n if not cleaned_data.get(f):\n self.add_error(f, \"Required for card payments\")\n return cleaned_data",
"def fixFormLanguage( self, REQUEST ):\n if REQUEST is None:\n return\n\n lang = REQUEST.get( 'LOCALIZER_LANGUAGE' )\n map = Config.LanguageEntitiesMap.get( lang )\n if map is None:\n return\n\n for key, value in REQUEST.form.items():\n if type(value) in ( StringType, UnicodeType, ):\n for entity, char in map.items():\n value = value.replace( entity, char )\n REQUEST.form[ key ] = value\n\n if REQUEST.REQUEST_METHOD == 'PUT':\n value = REQUEST.other.get('BODY')\n if value is not None:\n for entity, char in map.items():\n value = value.replace( entity, char )\n REQUEST.other['BODY'] = value",
"def test_on_post_display_foreign_to_foreign(self):\n # data.get('country_flag', None)\n # address_display_version = 'foreign' if country_flag else 'local'\n # form.set_alt_data(name='country_display', field=self.fields['country_display'], value=address_display_version)\n pass",
"def form_Input(request):\n schema = schemaish.Structure()\n schema.add('inputStrip', schemaish.String())\n\n form = formish.Form(schema, 'form')\n form['inputStrip'].widget = formish.Input(strip=True)\n return form",
"def clean_city(self):\n return self.cleaned_data['city'].strip().title()",
"def test_default_country_unset(self):\n response = self.client.get(reverse(\"billing_info\"))\n self.assertEqual(response.status_code, 200)\n self.assertContains(\n response, '<option value=\"\" selected>---------</option>', html=True\n )",
"def pop_form(env):\n if 'wsgi.input' not in env:\n return None\n post_env = env.copy()\n post_env['QUERY_STRING'] = ''\n form = cgi.FieldStorage(\n fp=env.pop('wsgi.input'),\n environ=post_env,\n keep_blank_values=True\n )\n return {k: form[k].value for k in form}",
"def initial_form_data(self, request, step, form):\n return None"
] | [
"0.6526117",
"0.63131696",
"0.61562216",
"0.58682793",
"0.57100934",
"0.54811525",
"0.5309421",
"0.5280519",
"0.52800024",
"0.5198643",
"0.5198643",
"0.517737",
"0.51279545",
"0.50890446",
"0.5059742",
"0.5025401",
"0.5019244",
"0.49764037",
"0.49680588",
"0.4965016",
"0.49528313",
"0.4926414",
"0.48926532",
"0.4864195",
"0.48483908",
"0.48475087",
"0.48321724",
"0.48068196",
"0.4802371",
"0.47686982"
] | 0.68379873 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.