Saravanan666/pypi-org huggingface dataset:
Package: scanit-cli
ScanItWho keeps antivirus nowadays? Go on. Noone wants to slow down his PC AF for some unneccesory antivirus. But we sometimes needs to scan some file for virus. So here is an solution. ScanIt Scans a file using VirusTotal's online file scanner.NOTE: You are inmodulebranch. For windows we suggest check outmaster branchtoo.Why ScanIt?A lot of people, including me, prefers not to keep Antivirus in their PC. But sometimes we really need to scan a file for virus. At such times we use online virus scanners like VirusTotal.com. ScanIt has bring down this functionality to your cli, and guess what? It doesn't slows down your system by even a 0.01 percent. So its time to goodbye AntiViruses and say hello to online file scan services.Privacy?The script first sends the hash of a file to VirusTotal to check if the same file is already available to VirusTotal. In this case your data is totally secure as the file is not uploaded. But if VirusTotal doesn't recognises that hash, then the script asks you if you want to upload the file, in case you answer with yes, it uploads the file. So it's up to you if you want to upload a file or not. Sensitive files should not be uploaded.InstallationInstallation from PyPi:Make sure you have python (version >= 3) and pip installed.Run the following command from your command line:pipinstallscanit-cli# may be pip3 in case of linuxCheck out PyPi.Installation from repo:Make sure you havepipandgitinstalled. Now use the following commands to install scanit:gitclonehttps://github.com/shivamsn97/ScanItcdScanIt
gitcheckoutmodule
pythonsetup.pyinstall# may be python3 in case of linuxUninstallation:Run the following command:pipuninstallscanit-cli# May be pip3 in case of linuxUsageYou can use it from your cli using the command:$scanitsomefile.shNotesCurrently made only for Windows, contributions are welcome to make it work on linux too.Your privacy is in your hands. Please do not upload sensitive files to virustotal db.Please do not open low-efforts PRA star to the repo would be awesome.CreditsProtect iconicon byIcons8
Package: scan-merge
scan_mergeThis is a simple tool to merge scanned PDFs if you have scanner with a document
feeder but that doesn't support double sided pages.The idea is to scan the document stack into two PDFs, a forward one of the front
of the pages and a backward one with the back of the pages. Then this script can
be used to merge the two into a coherent single PDF with the pages in order.InstallIt is recommended to install this from PyPi:pip install scan-merge
Package: scann
ScaNNScaNN (Scalable Nearest Neighbors) is a method for efficient vector similarity
search at scale. This code release implements [1], which includes search space
pruning and quantization for Maximum Inner Product Search and also supports
other distance functions such as Euclidean distance. The implementation is
designed for x86 processors with AVX2 support. ScaNN achieves state-of-the-art
performance onann-benchmarks.comas shown on the
glove-100-angular dataset below:ScaNN can be configured to fit datasets with different sizes and distributions.
It has both TensorFlow and Python APIs. The library shows strong performance
with large datasets [1]. The code is released for research purposes. For more
details on the academic description of algorithms, please see [1].Reference [1]:@inproceedings{avq_2020,
  title={Accelerating Large-Scale Inference with Anisotropic Vector Quantization},
  author={Guo, Ruiqi and Sun, Philip and Lindgren, Erik and Geng, Quan and Simcha, David and Chern, Felix and Kumar, Sanjiv},
  booktitle={International Conference on Machine Learning},
  year={2020},
  URL={https://arxiv.org/abs/1908.10396}
}Installationmanylinux_2_27-compatible wheels are available on PyPI:pip install scannScaNN supports Linux environments running Python versions 3.8-3.11. Seedocs/releases.mdfor release notes; the page also contains
download links for ScaNN wheels prior to version 1.1.0, which were not released
on PyPI.In accordance with themanylinux_2_27specification, ScaNN
requireslibstdc++version 3.4.23 or above from the operating system. Seeherefor an example of how
to find your system'slibstdc++version; it can generally be upgraded by
installing a newer version ofg++.Integration with TensorFlow ServingWe provide custom Docker images ofTF Servingthat are linked to the ScaNN
TF ops. See thetf_servingdirectoryfor further
information.Building from sourceTo build ScaNN from source, first install the build toolbazel, Clang 8, and libstdc++ headers for C++17 (which
are provided with GCC 9). Additionally, ScaNN requires a modern version of
Python (3.8.x or later) and Tensorflow 2.13 installed on that version of Python.
Once these prerequisites are satisfied, run the following command in the root
directory of the repository:python configure.py
CC=clang-8 bazel build -c opt --features=thin_lto --copt=-mavx --copt=-mfma --cxxopt="-std=c++17" --copt=-fsized-deallocation --copt=-w :build_pip_pkg
./bazel-bin/build_pip_pkgA .whl file should appear in the root of the repository upon successful
completion of these commands. This .whl can be installed via pip.UsageSee the example indocs/example.ipynb. For a more in-depth
explanation of ScaNN techniques, seedocs/algorithms.md.
Package: scann2dxf
# scann2dxfsimple python based scann to dxf converterearly alpha state - works for me :)input from imageinput direct from scannerauto rotate## quikstart### install with pip` pip3 install scann2dxf `### get code` git clone git@github.com:multigcs/scann2dxf.git cd scann2dxf pip3 install-rrequirements.txt `### scann2dxf example` scann2dxf-iinput.png-oscann.dxf `![image](https://raw.githubusercontent.com/multigcs/scann2dxf/main/docs/image.png)
![dxf](https://raw.githubusercontent.com/multigcs/scann2dxf/main/docs/dxf.png)
Package: scanner
# Scanner[![Build Status](https://travis-ci.org/cuteio/scanner.png?branch=master)](https://travis-ci.org/cuteio/scanner)Scanner provides for lexical scanning operations on a String. Clone of [Ruby's StringScanner](http://ruby-doc.org/stdlib-2.0.0/libdoc/strscan/rdoc/StringScanner.html).Here is an example of its usage:```from scanner import StringScanner, StringRegexps = StringScanner('This is an example string')s.is_eos             # -> Falseprint s.scan(StringRegexp('\w+'))  # -> "This"print s.scan(StringRegexp('\w+'))  # -> Noneprint s.scan(StringRegexp('\s+'))  # -> " "print s.scan(StringRegexp('\s+'))  # -> Noneprint s.scan(StringRegexp('\w+'))  # -> "is"s.is_eos                           # -> Falseprint s.scan(StringRegexp('\s+'))      # -> " "print s.scan(StringRegexp('\w+'))      # -> "an"print s.scan(StringRegexp('\s+'))      # -> " "print s.scan(StringRegexp('\w+'))      # -> "example"print s.scan(StringRegexp('\s+'))      # -> " "print s.scan(StringRegexp('\w+'))      # -> "string"s.is_eos                               # -> Trueprint s.scan(StringRegexp('\s+'))      # -> nilprint s.scan(StringRegexp('\w+'))      # -> nil```Scanning a string means remembering the position of a scan pointer, which is just an index. The point of scanning is to move forward a bit at a time, so matches are sought after the scan pointer; usually immediately after it.Given the string "test string", here are the pertinent scan pointer positions:```t e s t   s t r i n g0 1 2 ...             10```When you scan for a pattern (a regular expression), the match must occur at the character after the scan pointer. If you use scan_until, then the match can occur anywhere after the scan pointer. In both cases, the scan pointer moves just beyond the last character of the match, ready to scan again from the next character onwards. This is demonstrated by the example above.There are other methods besides the plain scanners. You can look ahead in the string without actually scanning. You can access the most recent match. You can modify the string being scanned, reset or terminate the scanner, find out or change the position of the scan pointer, skip ahead, and so on.#### Advancing the Scan Pointer```getchget_bytescanscan_untilskipskip_until```#### Looking Ahead```checkcheck_untilexistspeek```#### Finding Where we Are```is_bol (beginning_of_line?)is_eosis_restrest_sizepos```#### Setting Where we Are```resetterminatepos=```####Match Data```matchedis_matchedmatched_sizepre_matchpost_match```#### Miscellaneous```concatstringstring=unscan```### Changelog__v0.0.5[2014-02-07]__* Fix the setter prototype and return value__v0.0.4[2013-11-19]__* Fix Python 2.7.3 `Segmentation fault`.__v0.0.3[2013-11-17]____v0.0.2[2013-11-17]__* It's worked.
Package: scanning-drift-corr
Scan distortion correctionThis package corrects scan distortion by using orthogonal pairs.This is the Python translation from the code of Colin Ophus. The MATLAB code
can be foundhere.
It can also be foundhere.
The implementation is based onhis paper.The translation from MATLAB to Python is finished, allSPmerge01linear,SPmerge02andSPmerge03are availabe to use. The usage is pretty much the
same with MATLAB (seeexample.pyorexample.ipynb). The detail of the usage
can be found in the originalREADMEor theoriginal
repository.The MATLAB-to-Python translation provides a convenient interface where MATLAB
is not available or Python is the preferred language in your analysis pipeline.
The initial translation focuses on consistency between the MATLAB and
Python version, after ensure the correctness then more changes will be made.
A certain degree of parallelism is introduced in the Python version.The tests compare output from Python to MATLAB version at different breakpoints,
the MATLAB version comparing is inmatlab_modified. Some modifications are
made during the translation, mainly to address floating-point errors.InstallationThe package is available in conda-forge:conda install -c conda-forge scanning_drift_corrTo install via pip:pip install scanning_drift_corrTo install locally in editable mode, clone the repository and in the root
directory runpip install -e .Version1.0.0can be used with Python version >= 3.7 but the parallel
implementation is broken in Windows/macOS :( Subsequent version supports Python
version >= 3.8 due to the usage ofshared_memoryin the standard librarymultiprocessing, and the parallel implementation works in different systems.
However, seenotesbelow.UsageAfter installing, you can try to runexample.py.  This script illustrates
basic usage of the Python interface.A Jupyter notebookexample.ipynbis also available.Notes on parallel implementationSPmerge01linearandSPmerge02can be provided withparallel=Truefor
parallel computation. This works well in Unix system where processes are
forked, but in Windows/macOS processes are spawned and the parallel
implementation is (usually) slower than the serial one. The default behaviour
for Unix system isparallel=Trueand for Windows/macOS isparallel=False.
You are welcome to experiment yourself. Seeherefor details.TODOrefactoring of the codes (currently everything flying around)handle rectangular image
Package: scanny
Flatbed-ScannerVersion : 0.0.1Module for Python. This Module will enable a user to use any flatbed scanner using python.Copyright (c) 2022 Hardik Shah.Author : Hardik Shah.GitHub :https://github.com/Hardik-26License : GNU General Public License v3.0Brief Description :With this module you will be able to use your flatbed scanner using python.This module uses PowerShell script to execute the scan command.you can say that this module works as an API for Powershell which can comunicate with the scanner using WIA (Windows Image Acquisition).INSTRUCTIONS-Make sure your flatbed scanner is pluged in and ready to scanwell thats it.HOW TO USE-import scannyScan A image->>> scanny.StartScan("Path"( where you want your image file to be saved) , "ImageName" ) 
Eg- scanny.StartScan('C:\\Users\\Admin\\Desktop','TestIamge')Calibrate the scanner-(Optional, only for backward compatibility purposes)->>> scanny.Calibrate()Get Scanner Bed Size->>> scanny.size()MISC->>> scanny._calibration
>>> scanny._pixel_lenOther Information-Currently this python package only works for Windows 8 & Above.Linux and MAC-OS compatibility comming soon in next version: 0.0.2.Thank you. ☺
Package: scanoramaCT
Scanorma for CytoTRACE (ScanoramaCT)scanoramaCT.pyis an adapted version of the originalScanorama codefor application to CytoTRACE. The code has been modified to adjust the aligned gene count vectors using Gaussian kernel normalization. CytoTRACE is then applied to the Scanorama-adjusted gene counts and expression matrix.scanoramaCTis now available within the CytoTRACE codebase and web framework (CytoTRACE GitHub).
Package: scanoss-winnowing
SCANOSS Winnowing Python PackageThe SCANOSS Winnowing python package provides fast implementation of the winnowing algorithm.InstallationTo install (frompypi.org), please run:pip3installscanoss_winnowingTo upgrade an existing installation please run:pip3install--upgradescanoss_winnowingPackage UsageThescanoss_winnowingpackage can be used in Python projects/scripts. A good example of how to consume it can be foundhere.In general the easiest way to consume it is to import the required module as follows:fromscanoss_winnowing.winnowingimportWinnowingdefmain():winnowing=Winnowing()filename='test-file.c'winnowing.wfp_for_file(filename,filename)if__name__=="__main__":main()RequirementsPython 3.7 or higher.Source codeThe source for this package can be foundhere.ChangelogDetails of each release can be foundhere.
Package: scanpatterns
PyScanPatternsParametric scan patterns for imaging applications.Galvo drive signals, line camera/PMT exposure triggers, and frame/digitizer triggers are generated given a scan type and parameters. The exposure pulse is defined by thesamples_onandsamples_offparameters and this period (samples_on + samples_off) is used to create a pattern with a fixed number of exposures for a givenmax_line_rate.Used for an SD-OCT imaging system, but should work for ultrasound and laser scanning microscopy applications.Installationpip install scanpatternsFeaturesThe following patterns are possible:Raster scanLine scanRaster scan with repeated A-linesRaster scan with repeated B-linesBidirectional raster scanCircle scansFigure-8 scan (modified lissajous)Rhodonea rose scan with odd number of petalsPatterns are created by calling thegeneratemethod of anyLineScanPatterninstance or by passing
the arguments ofgenerateto the constructor.The resultant scan signals can be accessed via thex,y,line_triggerandframe_triggerproperties.Other properties of a pattern such aspattern_rate,frame_rate, and the arguments used to create the pattern
are also available.GalleryRasterScanPattern(16,16,76000,samples_on=1,samples_off=10)RasterScanPattern(16,16,76000,samples_on=1,samples_off=10,fast_axis_step=True,slow_axis_step=True)RasterScanPattern(16,16,76000,samples_on=1,samples_off=10,bline_repeat=2)RasterScanPattern(16,16,76000,fov=[1.5,4.5],samples_on=1,samples_off=10,fast_axis_step=True,slow_axis_step=True)RasterScanPattern(16,16,76000,samples_on=1,samples_off=10,fast_axis_step=True,slow_axis_step=True,rotation_rad=np.pi/4)RasterScanPattern(15,15,76000,samples_on=1,samples_off=10,bidirectional=True,slow_axis_step=True)RasterScanPattern(15,1,76000,samples_on=1,samples_off=10)RasterScanPattern(15,1,76000,samples_on=1,samples_off=10,bidirectional=True,rotation_rad=np.pi/8)CircleScanPattern(64,1.0,76000,samples_on=1)Figure8ScanPattern(1.0,16,76000)RoseScanPattern(3,1,16,76000,samples_on=1,samples_off=10)RoseScanPattern(5,1,16,76000,samples_on=1,samples_off=10)
Package: scanpdf
If you’re looking for a simple way to use a multi-page scanner and get your
document into a PDF in Linux without any proprietary or commercial software,
then ScanPDF might be the solution.  I wrote it to quickly take the Linux SANE
scanner system output image files, and process them into usable PDFs.  By
usable, I mean PDFs that maintain their original scanned resolution, omit blank
pages (if you’re scanning in duplex mode, for example), preserve color unless
the original is greyscale/black and white, in which case they are intelligently
down-converted to B/W PDFs to save space.Free and open-source software: ASL2 licenseDocumentation:http://virantha.github.io/scanpdf/htmlSource:https://github.com/virantha/scanpdfFeaturesUses SANE/scanadf to automatically scan to multi-page compressed PDFsIntegrates with ScanBdto respond to hardware button pressesAutomatically removes blank pages.Scans in color, and automatically down-converts into 1-bit B/W image for text/greyscale imagesAuto-crops to the proper page size.Usage:The simplest way to use this is:scanpdf scan pdf <pdffile>This will first perform the scan, and then the conversion to PDF.  If you want
to split up the scan and the PDF conversion into two separate invocations (for
reasons clarified below), then you can do:scanpdf --tmpdir=tmp scan
scanpdf --tmpdir=tmp pdf <pdffile>One reason for the separation might be if you want to keep scanning documents
(very quick) while the post-processing (slower) for the PDF conversion is
taking place in the background.   For instance, if you’re using the hardware
button on the scanner to initiate scans (as detailed inthisdocument), then
you want to return immediately after the scan instead of waiting for the full
conversion to PDF has taken place.You can optionally use the following switches to control if you’re putting pages face up or face down in the auto
document feeder, if you want to skip the blank page processing, adjust the blank page detection threshold, or add
additional post-processing usingunpaper:--dpi=<dpi>                 DPI to scan in [default: 300]
--face-up=<true/false>      Face-up scanning [default: True]
--keep-blanks               Don't check for and remove blank pages
--blank-threshold=<ths>     Percentage of white to be marked as blank [default: 0.97]
--post-process              Run unpaper to deskew/clean upRight now, I’m assuming this is getting called via ScanBD, so I don’t have the option to manually specify the
scanner.  If you really want to use this standalone, for now, please just set theSCANBD_DEVICEenvironment
variable to your scanner device name before running this script.Installation$ pip install scanpdfRequires ImageMagick and SANE to be installed, for the command line tools:convertidentifyps2pdfscanadfAlso requires epstopdf.DisclaimerThe software is distributed on an “AS IS” BASIS, WITHOUT
WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
Package: scanpointgenerator
Scan point generator contains a number of python iterators that are used inGDAandmalcolmto determine the motor demand positions and dataset
indexes that various scan types will produceInstallationTo install the latest release, type:pip install scanpointgeneratorTo install the latest code directly from source, type:pip install git+git://github.com/dls-controls/scanpointgenerator.gitChangelogSeeCHANGELOGContributingSeeCONTRIBUTINGLicenseAPACHE License. (seeLICENSE)DocumentationFull documentation is available athttp://scanpointgenerator.readthedocs.org
Package: scanports-pkg
# scanPortsAn efficient and convenient port scanner
[Github](https://github.com/zdf123zdf/scanports)
to view# Example of operation method:
~~~shell script
scanports -i 127.0.0.1 -p 80 -t 0.1 - c 500
~~~MIT LicenseCopyright (c) [year] [fullname]Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: scanprep
scanprep – Prepare scanned PDF documentsSmall utility to prepare scanned documents. Supports separating PDF files by separator pages and removing blank pages.Scanprep can be used to prepare scanned documents for further processing with existing tools (like the greatOCRmyPDF) or directly for archival. It allows splitting multiple documents that were scanned in a single batch into multiple files. In addition, it can also remove blank pages from the output (this is especially helpful if using a duplex scanner).For document separation, separator pages need to be inserted between the different documents before scanning. These pages tell the program where to split. You can either use theincluded separator pageor create your own. The separator page simply needs to have a barcode that encodes the textSCANPREP_SEP(you can use anybarcode type supported by zbar).InstallationVia SnapYou can install scanprep from theSnap Store:snapinstallscanprep

scanprep-hVia PyPIYou can install scanprep usingpip(consider doing that in a venv):pip3installscanprep# If you see an error like "ImportError: Unable to find zbar shared library", you need to install zbar yourself. See: https://pypi.org/project/pyzbar/scanprep-hFrom sourceTo install scanprep from source, clone this repository and install the dependencies:gitclonehttps://github.com/baltpeter/scanprep.gitcdscanprep
pip3install-rrequirements.txt# You may want to do this in a venv.# You may also need to install the zbar shared library. See: https://pypi.org/project/pyzbar/python3scanprep/scanprep.py-hUsageMost simply, you can run scanprep viascanprep <filename.pdf>. This will process the input file and output the results into your current working directory. To specify a different output directory, usescanprep <filename.pdf> <output_directory>.The output files will be called0-<filename.pdf>,1-<filename.pdf>, and so on.By default, both page separation and blank page removal will be performed. To turn them off, use--no-page-separationor--no-blank-removal, respectively.Usescanprep -hto show the help:usage: scanprep [-h] [--page-separation] [--blank-removal] input_pdf [output_dir]

positional arguments:
  input_pdf             The PDF document to process.
  output_dir            The directory where the output documents will be saved. (defaults to the
                        current directory)

optional arguments:
  -h, --help            show this help message and exit
  --page-separation, --no-page-separation
                        Do (or do not) split document into separate files by the included
                        separator pages. (default yes)
  --blank-removal, --no-blank-removal
                        Do (or do not) remove empty pages from the output. (default yes)LicenseScanprep is licensed under the MIT license, see theLICENSEfile for details. Issues and pull requests are welcome!
Package: scanpro
Scanpro: robust proportion analysis for single cell resolution dataScanpro is a modular tool for proportion analysis, seamlessly integrating into widely accepted frameworks in the python environment. Scanpro is fast, accurate, support datasets without replicates, and is intended to be used by bioinformatics experts and beginners.InstallPyPipip install scanproFrom source:clone the repositorygit clone https://gitlab.gwdg.de/loosolab/software/scanpro.gitnavigate to scanpro directorycd scanprothen runpip install .Quick startTo run the tool import and call the functionscanpro:from scanpro import scanpro

out = scanpro.scanpro(adata, clusters_col='clusters', conds_col='condition', samples_col='sample')If samples_col is not given or set to None, the dataset is assumed to be not replicated and scanpro will run the bootstrapping method.To show the results, runout.results.You can plot the results by callingout.plot().