An official visit to the permit facility on a periodic basis which
        consists of the following inspection types: NPDES, Biomonitoring,
        Pretreatment, and Industrial User.

        >>> PCS().inspection('insp_date', '16-MAR-01')
191968
def inspection(self, column=None, value=None, **kwargs):
        
        return self._resolve_call('PCS_INSPECTION', column, value, **kwargs)
242677
function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) {

    var inspected = {},
        seekingTransport = structure === transports;

    var inspect = function inspect(dataType) {
        var selected = undefined;
        inspected[dataType] = true;
        //jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
        (structure[dataType] || []).every(function (prefilterOrFactory) {
            var dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR);
            if (typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[dataTypeOrTransport]) {
                options.dataTypes.unshift(dataTypeOrTransport);
                inspect(dataTypeOrTransport);
                return false;
            } else if (seekingTransport) {
                return !(selected = dataTypeOrTransport);
            }
            return true;
        });
        return selected;
    };

    return inspect(options.dataTypes[0]) || !inspected["*"] && inspect("*");
}
300294
function scan(sp, cb) {
    cb = u.onceMaybe(cb);
    var timer = u.timer();
    sp.route = sp.route || '/';

    var src = sp.src;

    // only construct src, defaults, sendOpts etc. once
    if (!src) {
      sp.name = sp.name || 'staticPath:' + sp.path;
      sp.depth = sp.depth || opts.staticDepth || 5;
      sp.maxAge = 'maxAge' in sp ? sp.maxAge : '10m';
      sp.includeBinaries = true;
      src = sp.src = fsbase(sp);
      if (src.isfile()) { sp.depth = 1; }
      sp.sendOpts = u.assign(
        u.pick(sp, 'maxAge', 'lastModified', 'etag'),
        { dotfiles:'ignore',
          index:false,      // handled at this level
          extensions:false, // ditto
          root:src.path } );
    }

    src.listfiles(function(err, files) {
      if (err) return cb(log(err));
      sp.files = files;
      self.scanCnt++;
      mapAllFiles();
      debug('static scan %s-deep %sms %s', sp.depth, timer(), sp.path.replace(/.*\/node_modules\//g, ''));
      debug(files.length > 10 ? '[' + files.length + ' files]' : u.pluck(files, 'filepath'));
      cb();
    });
  }
333600
def inspect(self, source, preset=None, **options):
        

        # Start timer
        start = datetime.datetime.now()

        # Prepare preset
        preset = self.__get_source_preset(source, preset)
        if preset == 'nested':
            options['presets'] = self.__presets
            for s in source:
                if s.get('preset') is None:
                    s['preset'] = self.__get_source_preset(s['source'])

        # Prepare tables
        preset_func = self.__get_preset(preset)['func']
        warnings, tables = preset_func(source, **options)
        if len(tables) > self.__table_limit:
            warnings.append(
                'Dataset inspection has reached %s table(s) limit' %
                (self.__table_limit))
            tables = tables[:self.__table_limit]

        # Collect table reports
        table_reports = []
        if tables:
            tasks = []
            pool = ThreadPool(processes=len(tables))
            try:
                for table in tables:
                    tasks.append(pool.apply_async(self.__inspect_table, (table,)))
                for task in tasks:
                    table_warnings, table_report = task.get()
                    warnings.extend(table_warnings)
                    table_reports.append(table_report)
            finally:
                pool.terminate()

        # Stop timer
        stop = datetime.datetime.now()

        # Compose report
        report = {
            'time': round((stop - start).total_seconds(), 3),
            'valid': all(item['valid'] for item in table_reports),
            'error-count': sum(len(item['errors']) for item in table_reports),
            'table-count': len(tables),
            'tables': table_reports,
            'warnings': warnings,
            'preset': preset,
        }

        return report
1127778
private void validateIfdCT(IFD ifd, int p) {
    IfdTags metadata = ifd.getMetadata();

    boolean rgb =
        metadata.containsTagId(TiffTags.getTagId("PhotometricInterpretation"))
            && metadata.get(TiffTags.getTagId("PhotometricInterpretation")).getFirstNumericValue() == 2;
    boolean lab =
        metadata.containsTagId(TiffTags.getTagId("PhotometricInterpretation"))
            && metadata.get(TiffTags.getTagId("PhotometricInterpretation")).getFirstNumericValue() == 8;
    int spp = -1;
    if (metadata.containsTagId(TiffTags.getTagId("SamplesPerPixel"))) {
      spp = (int) metadata.get(TiffTags.getTagId("SamplesPerPixel")).getFirstNumericValue();
    }
    int planar = 1;
    if (metadata.containsTagId(TiffTags.getTagId("PlanarConfiguration"))) {
      planar = (int) metadata.get(TiffTags.getTagId("PlanarConfiguration")).getFirstNumericValue();
    }
    int rps = -1;
    if (metadata.containsTagId(TiffTags.getTagId("RowsPerStrip"))) {
      rps = (int) metadata.get(TiffTags.getTagId("RowsPerStrip")).getFirstNumericValue();
    }
    int length = -1;
    if (metadata.containsTagId(TiffTags.getTagId("ImageLength"))) {
      length = (int) metadata.get(TiffTags.getTagId("ImageLength")).getFirstNumericValue();
    }
    int spi = Math.floorDiv(length + rps - 1, rps);

    if (lab) {

    } else {
      if (p == 1 || p == 2) {
        checkRequiredTag(metadata, "NewSubfileType", 1, new long[]{0});
      }
    }
    checkRequiredTag(metadata, "ImageLength", 1);
    checkRequiredTag(metadata, "ImageWidth", 1);
    checkRequiredTag(metadata, "BitsPerSample", spp);
    if (rgb || lab) {
      checkRequiredTag(metadata, "BitsPerSample", 3, new long[]{8, 16});
    } else {
      if (p == 0) {
        checkRequiredTag(metadata, "BitsPerSample", spp, new long[]{8, 16});
      } else {
        checkRequiredTag(metadata, "BitsPerSample", spp, new long[]{8});
      }
    }
    if (p == 2 || rgb || lab) {
      checkRequiredTag(metadata, "Compression", 1, new long[]{1,7,8});
    } else if (p == 1) {
      checkRequiredTag(metadata, "Compression", 1, new long[]{1});
    }
    if (p == 0) {
      checkRequiredTag(metadata, "PhotometricInterpretation", 1, new long[] {2, 5, 6, 8});
      if (metadata.containsTagId(TiffTags.getTagId("PhotometricInterpretation"))
          && metadata.get(TiffTags.getTagId("PhotometricInterpretation")).getFirstNumericValue() == 6
          &&
          metadata.get(TiffTags.getTagId("Compression")).getFirstNumericValue() != 7) {
        validation.addErrorLoc("YCbCr shall be used only when compression has the value 7", "IFD"
            + currentIfd);
      }
    } else if (p == 1 || p == 2) {
      checkRequiredTag(metadata, "PhotometricInterpretation", 1, new long[] {5});
    }
    if (planar == 1 || planar == 32768) {
      checkRequiredTag(metadata, "StripOffsets", spi);
    } else if (planar == 2) {
      checkRequiredTag(metadata, "StripOffsets", spp * spi);
    }
    if (rgb || lab) {
    } else if (p == 1 || p == 2) {
      checkRequiredTag(metadata, "Orientation", 1, new long[]{1});
    }
    if (rgb || lab) {
      checkRequiredTag(metadata, "SamplesPerPixel", 1, new long[]{3});
    } else {
      if (p == 0) {
        checkRequiredTag(metadata, "SamplesPerPixel", 1);
      } else if (p == 1 || p == 2) {
        checkRequiredTag(metadata, "SamplesPerPixel", 1, new long[]{4});
      }
    }
    if (p == 1 || p == 2 || rgb || lab) {
      if (planar == 1 || planar == 32768) {
        checkRequiredTag(metadata, "StripBYTECount", spi);
      } else if (planar == 2) {
        checkRequiredTag(metadata, "StripBYTECount", spp * spi);
      }
      checkRequiredTag(metadata, "XResolution", 1);
      checkRequiredTag(metadata, "YResolution", 1);
    }
    if (p == 0 || rgb || lab) {
      checkRequiredTag(metadata, "PlanarConfiguration", 1, new long[]{1,2,32768});
    } else if (p == 1 || p == 2) {
      checkRequiredTag(metadata, "PlanarConfiguration", 1, new long[]{1});
    }
    if (rgb || lab) {

    } else {
      if (p == 1 || p == 2) {
        checkRequiredTag(metadata, "ResolutionUnit", 1, new long[]{2, 3});
        checkRequiredTag(metadata, "InkSet", 1, new long[]{1});
        checkRequiredTag(metadata, "NumberOfInks", 1, new long[]{4});
        checkRequiredTag(metadata, "DotRange", 2, new long[]{0, 255});
      }
    }
  }
36610
def _show_psrs():
    
    sep = os.linesep

    types = "Supported types: " + ", ".join(API.list_types())
    cids = "IDs: " + ", ".join(c for c, _ps in API.list_by_cid())

    x_vs_ps = ["  %s: %s" % (x, ", ".join(p.cid() for p in ps))
               for x, ps in API.list_by_extension()]
    exts = "File extensions:" + sep + sep.join(x_vs_ps)

    _exit_with_output(sep.join([types, exts, cids]))
783711
@Override
    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String exceptions[]) {
        if (scanPolicyIsExternal() || !isDetailEnabled()) {
            visitEnd();
            throw VISIT_ENDED_DETAIL;
        }

        return methodVisitor;
    }
224893
def show_cationpi(self):
        """"""
        for i, p in enumerate(self.plcomplex.pication):
            cmd.pseudoatom('ps-picat-1-%i' % i, pos=p.ring_center)
            cmd.pseudoatom('ps-picat-2-%i' % i, pos=p.charge_center)
            if p.protcharged:
                cmd.pseudoatom('Chargecenter-P', pos=p.charge_center)
                cmd.pseudoatom('Centroids-L', pos=p.ring_center)
                pilig_ids = '+'.join(map(str, p.ring_atoms))
                cmd.select('PiCatRing-L', 'PiCatRing-L or (id %s & %s)' % (pilig_ids, self.ligname))
                for a in p.charge_atoms:
                    cmd.select('PosCharge-P', 'PosCharge-P or (id %i & %s)' % (a, self.protname))
            else:
                cmd.pseudoatom('Chargecenter-L', pos=p.charge_center)
                cmd.pseudoatom('Centroids-P', pos=p.ring_center)
                pires_ids = '+'.join(map(str, p.ring_atoms))
                cmd.select('PiCatRing-P', 'PiCatRing-P or (id %s & %s)' % (pires_ids, self.protname))
                for a in p.charge_atoms:
                    cmd.select('PosCharge-L', 'PosCharge-L or (id %i & %s)' % (a, self.ligname))
            cmd.distance('PiCation', 'ps-picat-1-%i' % i, 'ps-picat-2-%i' % i)
        if self.object_exists('PiCation'):
            cmd.set('dash_color', 'orange', 'PiCation')
            cmd.set('dash_gap', 0.3, 'PiCation')
            cmd.set('dash_length', 0.6, 'PiCation')
655994
function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {

	var inspected = {},
		seekingTransport = ( structure === transports );

	function inspect( dataType ) {
		var selected;
		inspected[ dataType ] = true;
		jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
			var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
			if ( typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[ dataTypeOrTransport ] ) {
				options.dataTypes.unshift( dataTypeOrTransport );
				inspect( dataTypeOrTransport );
				return false;
			} else if ( seekingTransport ) {
				return !( selected = dataTypeOrTransport );
			}
		});
		return selected;
	}

	return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
}
936153
def compliance_schedule(self, column=None, value=None, **kwargs):
        
        return self._resolve_call('PCS_CMPL_SCHD', column, value, **kwargs)
659179
private void visit(QualifiedIdentifierRestrictionDescr descr) {

        String text = descr.getText();

        String base = text.substring(0,
                text.indexOf("."));
        String fieldName = text.substring(text.indexOf("."));

        Variable patternVariable = data.getVariableByRuleAndVariableName(pattern.getRuleName(),
                base);

        if (patternVariable != null) {

            QualifiedIdentifierRestriction restriction = new QualifiedIdentifierRestriction(pattern);

            restriction.setPatternIsNot(pattern.isPatternNot());
            restriction.setFieldPath(field.getPath());
            restriction.setOperator(Operator.determineOperator(descr.getEvaluator(),
                    descr.isNegated()));
            restriction.setVariablePath(patternVariable.getPath());
            restriction.setVariableName(base);
            restriction.setVariablePath(fieldName);
            restriction.setOrderNumber(orderNumber);
            restriction.setParentPath(pattern.getPath());
            restriction.setParentType(pattern.getVerifierComponentType());

            // Set field value, if it is not set.
            field.setFieldType(Field.VARIABLE);

            data.add(restriction);
            solvers.addPatternComponent(restriction);
        } else {

            EnumField enumField = (EnumField) data.getFieldByObjectTypeAndFieldName(base,
                    fieldName);
            if (enumField == null) {

                ObjectType objectType = data.getObjectTypeByFullName(base);

                if (objectType == null) {
                    Import objectImport = data.getImportByName(base);

                    if (objectImport != null) {
                        objectType = ObjectTypeFactory.createObjectType(descr,objectImport);
                    } else {
                        objectType = ObjectTypeFactory.createObjectType(descr,base);
                    }

                    data.add(objectType);
                }

                enumField = new EnumField(descr);

                enumField.setObjectTypePath(objectType.getPath());
                enumField.setObjectTypeName(objectType.getName());
                enumField.setName(fieldName);

                objectType.getFields().add(enumField);

                data.add(enumField);
            }

            EnumRestriction restriction = new EnumRestriction(pattern);

            restriction.setPatternIsNot(pattern.isPatternNot());
            restriction.setFieldPath(field.getPath());
            restriction.setOperator(Operator.determineOperator(descr.getEvaluator(),
                    descr.isNegated()));
            restriction.setEnumBasePath(enumField.getPath());
            restriction.setEnumBase(base);
            restriction.setEnumName(fieldName);
            restriction.setOrderNumber(orderNumber);
            restriction.setParentPath(pattern.getPath());
            restriction.setParentType(pattern.getVerifierComponentType());

            // Set field value, if it is not set.
            field.setFieldType(Field.ENUM);

            data.add(restriction);
            solvers.addPatternComponent(restriction);
        }
    }
103663
private boolean investigateHandlesTypes(ServletContainerInitializer sci, HashMap<ServletContainerInitializer, Class[]> handleTypesHashMap, HashMap<ServletContainerInitializer, HashSet<Class<?>>> onStartupHashMap){
        boolean needToScan = false;
        try {
            HandlesTypes handles = sci.getClass().getAnnotation(HandlesTypes.class);
            //handles is the classes which we are to look for and find all implementing classes.
            if (handles!=null) {
                Class[] classes = handles.value();
                needToScan=true;
                if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) {
                    for (Class c:classes) {
                        logger.logp(Level.FINE, CLASS_NAME, "initializeServletContainerInitializers","Handles class to look contains " + c);
                    }
                }
                handleTypesHashMap.put(sci, classes);
                onStartupHashMap.put(sci, new HashSet<Class<?>>());
            }
        } catch (RuntimeException e) {
            //the HandlesTypes class wasn't found in the classloader
            if (WCCustomProperties.LOG_SERVLET_CONTAINER_INITIALIZER_CLASSLOADER_ERRORS) {
                logger.logp(Level.WARNING, CLASS_NAME,"initializeServletContainerInitializers", "exception.occurred.while.initializing.ServletContainerInitializers.HandlesTypes", new Object[] {sci.getClass().getName(), this.config.getDisplayName()});
            } else {
                if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)){
                    logger.logp(Level.FINE, CLASS_NAME,"initializeServletContainerInitializers", "exception.occurred.while.initializing.ServletContainerInitializers.HandlesTypes", new Object[] {sci.getClass().getName(), this.config.getDisplayName()});
                }
            }
        }
        return needToScan;
    }
558837
function isAppDir_p(dirPath) {
      var deferred = Q.defer();
      fs.exists(dirPath, function(exists) {
        if (!exists)
          deferred.resolve({
            exists: false, 
            isApp: false, 
            isRmd: false, 
            index: false
          });
        else {
          deferred.resolve(
            Q.nfcall(fs.readdir, dirPath)
            .then(
              function(entries) {
                var app = _.find(entries, function(entry) {
                  return /^server\.r$/i.test(entry);
                });
                var singleApp = _.find(entries, function(entry) {
                  return /^app\.r$/i.test(entry);
                });
                var rmd = _.find(entries, function(entry) {
                  return /\.rmd$/i.test(entry);
                });
                var indexRmd = _.find(entries, function(entry) {
                  if (/^index\.rmd$/i.test(entry)){
                    return entry;
                  }
                  return false;
                });
                var indexHtm = _.find(entries, function(entry) {
                  if (/index\.htm(l)?$/i.test(entry)){
                    return entry;
                  }
                  return false;
                });

                // Give priority to an Rmd index, the fall back to an html index
                return {
                  exists: true, 
                  isApp: (!!app || !!singleApp), 
                  isRmd: !!rmd, 
                  indexType: indexRmd ? 'rmd' : indexHtm ? 'html' : null,
                  indexPath: indexRmd || indexHtm
                };
              },
              function(err) {
                if (err.code == 'ENOTDIR') {
                  return {
                    exists: false, 
                    isApp: false, 
                    isRmd: false, 
                    indexType: null
                  };
                }
                else {
                  logger.error('Error reading dir: ' + err.message);
                  return {
                    exists: true, 
                    isApp: false, 
                    isRmd: false, 
                    indexType: null
                  };
                }
              }
            )
          );
        }
      });

      return deferred.promise;
    }
807337
def permit_event(self, column=None, value=None, **kwargs):
        
        return self._resolve_call('PCS_PERMIT_EVENT', column, value, **kwargs)
335545
@Override
    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
        this.classInternalName = name;
        this.isInterface = (access & Opcodes.ACC_INTERFACE) != 0;
        this.isSynthetic = (access & Opcodes.ACC_SYNTHETIC) != 0;

        super.visit(version, access, name, signature, superName, interfaces);
    }
534300
function Probe(collector) {
    this.fuse();

    //
    // Name of the probe, the registries the probe should run against
    // and how often it should run.
    //
    this.readable('name', name);
    this.readable('collector', collector);
    this.readable('list', Object.keys(require('../registries')));

    //
    // How often should the probe run.
    //
    this.readable('interval', interval);
  }
1255949
@Override
    public R visitProvides(ProvidesTree node, P p) {
        R r = scan(node.getServiceType(), p);
        r = scanAndReduce(node.getDescription(), p, r);
        return r;
    }