Saravanan666/pypi-org huggingface dataset:
Package: scikit-cars
scikit-cars: Image processing in PythonThis package is a scikit-image fork.
Seehttps://github.com/scikit-image/scikit-imagefor the original package.
This package add the following features to scikit-image:Use the SAD for channels distance in SLIC algorithm.Implement Chan-Sandberg-Vese segmentation (Chan-Vase for vector-valued images) with nu parameter.WarningEven if the package is called scikit-cars, the python module name is still skimage.InstallationUse pip to install this package:pip install scikit-carsInstallation from sourceInstall dependencies using:pip install -r requirements.txtThen, install scikit-image using:$ pip install .If you plan to develop the package, you may run it directly from source:$ pip install -e .  # Do this once to add package to Python pathEvery time you modify Cython files, also run:$ python setup.py build_ext -i  # Build binary extensionsScikit-image license (Modified BSD)Copyright (C) 2011, the scikit-image team
All rights reserved.Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
distribution.Neither the name of skimage nor the names of its contributors may be
used to endorse or promote products derived from this software without
specific prior written permission.THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
Package: scikit-chem
[![Travis](https://img.shields.io/travis/richlewis42/scikit-chem.svg?style=flat-square)](https://travis-ci.org/richlewis42/scikit-chem)
[![Coverage](https://img.shields.io/scrutinizer/coverage/g/richlewis42/scikit-chem.svg?style=flat-square)](https://scrutinizer-ci.com/g/richlewis42/scikit-chem)
[![Code Health](https://img.shields.io/scrutinizer/g/richlewis42/scikit-chem.svg?style=flat-square)](https://scrutinizer-ci.com/g/richlewis42/scikit-chem/)
[![Release](https://img.shields.io/pypi/v/scikit-chem.svg?style=flat-square)](https://github.com/richlewis42/scikit-chem/releases)
[![PyPI](https://img.shields.io/pypi/dm/scikit-chem.svg?style=flat-square)](https://pypi.python.org/pypi/scikit-chem)
[![DOI](https://zenodo.org/badge/4513/richlewis42/scikit-chem.svg?style=flat-square)](https://zenodo.org/badge/latestdoi/4513/richlewis42/scikit-chem)# scikit-chemQuick attempt at more straightforwardly integrating the Scientific Python Stack with the RDKit Cheminformatics library.RDKit objects are inherited from, and their APIs are made more Pythonic(to an extent).Longer term goals are to integrate as many webservices as possible##NoteWork in ProgressSpeed is not high on priority list. A demonstration of the convenience is the aim - much more would be required to maintain the RDKit levels of efficiency.  The end goal of the project may be simply to feed changes back into RDKit
Package: scikit-ci
scikit-ci enables a centralized and simpler CI configuration for Python
extensions.By havingappveyor.yml,azure-pipelines.yml,circle.ymland.travis.ymlcalling
the same scikit-ci command-line executable, all the CI steps for all
service can be fully described in onescikit-ci.ymlconfiguration file.Latest ReleaseVersionsDownloadsBuild StatusLinuxmacOSWindowsPyPIOverall HealthMiscellaneousFree software: Apache Software licenseDocumentation:http://scikit-ci.readthedocs.orgSource code:https://github.com/scikit-build/scikit-ciMailing list:https://groups.google.com/forum/#!forum/scikit-buildHistoryscikit-ci was initially developed in May 2016 by Omar Padron to facilitate the
continuous integration of the scikit-build project.At that time, it already consisted of a driver script calling methods specific
to each continuous integration service. By having each CI service calling the
same driver script, there was no need to deal with implementing install/test/build
steps over and over in different scripting languages (power shell, shell or
windows batch). Instead all code was implemented in python code leveraging the
subprocess module.Later in early September 2016, with the desire to setup cross-platform continuous
integration for other project and avoid duplication or maintenance hell, a
dedicated repository was created by Jean-Christophe Fillion-Robin. By simply
cloning the repository, it was possible to more easily enable CI for other projects.While this was an improvement, all the steps were still hardcoded in the driver
scripts, the project was not easily customizable. More could be done to improve
the user experience.Finally, in late September 2016, all hardcoded code was moved into standalone
executable python scripts. Then, Jean-Christophe came up with the concept of
scikit-ci.yml configuration file. This configuration file allows to describe the
commands and environment for each step (install, test and build) specific to a
project and associated continuous integration services.
Package: scikit-ci-addons
scikit-ci-addons is a command line tool and a set of scripts useful to help
drive the CI of projects leveraging services like Appveyor, CircleCI, or TravisCI.Originally developed to help install prerequisites for building Python
extension, it is now useful to support other type of projects.Latest ReleaseVersionsDownloadsBuild StatusLinuxMacOSXWindowsPyPIOverall HealthMiscellaneousFree software: Apache Software licenseDocumentation:http://scikit-ci-addons.readthedocs.orgSource code:https://github.com/scikit-build/scikit-addonsMailing list:https://groups.google.com/forum/#!forum/scikit-buildHistoryscikit-ci-addons was initially developed in May 2016 by Omar Padron to facilitate
the continuous integration of the scikit-build project.At that time, it consisted of code directly embedded in the CI script used in
scikit-build project.Then, in early September 2016, with the desire to setup cross-platform continuous
integration for other project and avoid duplication or maintenance hell, the code
was factored out by Jean-Christophe Fillion-Robin into a set of reusable scripts
available in the scikit-ci project. By simply cloning the repository, it was
possible to more easily enable CI for other projects.While this was an improvement, this prevented the distribution of standalone
and simple scikit-ci package. To better separate concerns and facilitate
testing and maintenance, in late September 2016, the scripts were moved into
their own project and scikit-ci-addons was born.Finally, in late October 2016, Jean-Christophe came up with the concept of
scikit-ci-addons command line tool allowing to execute the scripts (or add-ons)
distributed within the scikit-ci-addons package.
Package: scikit-CP
scikit-CPscikit-CP is a computational physics simulation and modeling python scientific library. It is intended
for students or scientists seeking to integrate physics computational solutions into their python
projects. It is written in and only compatible with Python 3.Available modulesBelow is the currently available stable classes and simulation scripts, more are on the way.
Contributions are welcomed, but they mus follow the format of the project and be coded either as a
simulation script or a class file for a physical object. A contribution tutorial is coming soon.Classical MechanicsClasses:OscillatorPlanetProjectileSimulation scripts:Projectiles Collision DetectorSolar SystemElectricity and MagnetismSimulation scripts:Electric FieldRandom SystemsClasses:Fluid (Percolation)Substance (Diffusion)Cluster (Growth)Random WalkerSimulation scripts:Random Walker PopulationDocumentation:Coming soon on readthedocs.io
Package: scikitcrf-ner
ï»¿Entity recognition using scikit CRFDecscriptionThis is a simple python applicaion that usessklearn-crfsuitefor entity recognition usingCRF.InstallationInstall this package using pip by running the follwing command:pip install scikitcrf_nerUsageimport the package using:from scikitcrf_ner import entityRecognitionTrain the model using:entityRecognition.train("path\\to\\trainingfile.json")Refer the sample training file(sample_train.json), the training file should be json formattedPredict the entities by:entityRecognition.predict("Utterance")Sample codeRefer this sample code:from scikitcrf_ner import entityRecognition as ner
ner.train("sample_train.json")
entities = ner.predict("show me some Indian restaurants")
print(entites)LicenseMIT
Package: scikit-criteria
Scikit-CriteriaMultiple-criteria decision analysisScikit-Criteriais a collection of Multiple-criteria decision
analysis (MCDA)
methods integrated into scientific python stack. Is Open source and commercially usable.Help & discussion mailing listOur Google Groups mailing list ishere.You can contact me at:jbcabral@unc.edu.ar(if you have a support
question, try the mailing list first)Code Repository & Issueshttps://github.com/quatrope/scikit-criteriaLicenseScikit-Criteria is underThe 3-Clause BSD LicenseThis license allows unlimited redistribution for any purpose as long as
its copyright notices and the license's disclaimers of warranty are
maintained.CitationIf you are using Scikit-Criteria in your research, please cite:If you use scikit-criteria in a scientific publication, we would
appreciate citations to the following paper:Cabral, Juan B., Nadia Ayelen Luczywo, and José Luis Zanazzi 2016
Scikit-Criteria: Colección de Métodos de Análisis Multi-Criterio
Integrado Al Stack Científico de Python. In XLV Jornadas Argentinas de
Informática E Investigación Operativa (45JAIIO)-XIV Simposio Argentino
de Investigación Operativa (SIO) (Buenos Aires, 2016) Pp. 59-66.http://45jaiio.sadio.org.ar/sites/default/files/Sio-23.pdf.Bibtex entry:@inproceedings{scikit-criteria,author={Juan B Cabral and Nadia Ayelen Luczywo and Jos\'{e} Luis Zanazzi},title={Scikit-Criteria: Colecci\'{o}n de m\'{e}todos de an\'{a}lisismulti-criterio integrado al stack cient\'{i}fico de {P}ython},booktitle={XLV Jornadas Argentinas de Inform{\'a}ticae Investigaci{\'o}n Operativa (45JAIIO)-XIV Simposio Argentino de Investigaci\'{o}n Operativa (SIO)(Buenos Aires, 2016)},year={2016},pages={59--66},url={http://45jaiio.sadio.org.ar/sites/default/files/Sio-23.pdf}}Full Publication:http://sedici.unlp.edu.ar/handle/10915/58577
Package: scikit-ctr
scikit-ctrA scikit extends for Click-Through-Rate prediction.Free software: MIT licenseDocumentation:https://scikit-ctr.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2018-11-21)First release on PyPI.
Package: scikit-cuda
Package Descriptionscikit-cuda provides Python interfaces to many of the functions in the CUDA
device/runtime, CUBLAS, CUFFT, and CUSOLVER libraries distributed as part of
NVIDIA’sCUDA Programming Toolkit, as well as
interfaces to select functions in theCULA Dense Toolkit.
Both low-level wrapper functions similar to their C counterparts and high-level
functions comparable to those inNumPy and Scipyare provided.DocumentationPackage documentation is available athttp://scikit-cuda.readthedocs.org/.  Many of the high-level
functions have examples in their docstrings. More illustrations of how
to use both the wrappers and high-level functions can be found in thedemos/andtests/subdirectories.DevelopmentThe latest source code can be obtained fromhttps://github.com/lebedov/scikit-cuda.When submitting bug reports or questions via theissue tracker, please include the following
information:Python version.OS platform.CUDA and PyCUDA version.Version or git revision of scikit-cuda.CitingIf you use scikit-cuda in a scholarly publication, please cite it as follows:@misc{givon_scikit-cuda_2019,
          author = {Lev E. Givon and
                    Thomas Unterthiner and
                    N. Benjamin Erichson and
                    David Wei Chiang and
                    Eric Larson and
                    Luke Pfister and
                    Sander Dieleman and
                    Gregory R. Lee and
                    Stefan van der Walt and
                    Bryant Menn and
                    Teodor Mihai Moldovan and
                    Fr\'{e}d\'{e}ric Bastien and
                    Xing Shi and
                    Jan Schl\"{u}ter and
                    Brian Thomas and
                    Chris Capdevila and
                    Alex Rubinsteyn and
                    Michael M. Forbes and
                    Jacob Frelinger and
                    Tim Klein and
                    Bruce Merry and
                    Nate Merill and
                    Lars Pastewka and
                    Li Yong Liu and
                    S. Clarkson and
                    Michael Rader and
                    Steve Taylor and
                    Arnaud Bergeron and
                    Nikul H. Ukani and
                    Feng Wang and
                    Wing-Kit Lee and
                    Yiyin Zhou},
    title        = {scikit-cuda 0.5.3: a {Python} interface to {GPU}-powered libraries},
    month        = May,
    year         = 2019,
    doi          = {10.5281/zenodo.3229433},
    url          = {http://dx.doi.org/10.5281/zenodo.3229433},
    note         = {\url{http://dx.doi.org/10.5281/zenodo.3229433}}
}Authors & AcknowledgmentsSee the includedAUTHORSfile for more information.Note Regarding CULA AvailabilityAs of 2017, the CULA toolkit is available to premium tier users ofCelerity Tools(EM Photonics’ new
HPC site).RelatedPython wrappers forcuDNNby Hannes
Bretschneider are availablehere.ArrayFireis a free library containing many GPU-based routines with anofficially supported Python interface.LicenseThis software is licensed under theBSD License.  See the includedLICENSEfile for more information.
Package: scikit-curve
scikit-curve:warning: :construction:UNDER DEVELOPMENT:construction:  :warning:A toolkit to manipulate n-dimensional geometric curves in Python.importmatplotlib.pyplotaspltfromcurve.curvesimportlissajousfromcurve.plotimportcurveplotfromcurveimportPreservedSpeedInterpolationGridcurve=lissajous(p_count=51)grid=PreservedSpeedInterpolationGrid(301)curve_i=curve.interpolate(grid,method='hermite')curveplot(curve_i,param='speed',show_normals=True,marker='.')plt.show()
Package: scikit-cycling
InstallationDependenciesScikit-cycling requires:scipynumpypandassixfit-parsejoblibscikit-learnInstallationscikit-cyclingis currently available on the PyPi’s reporitories and you can
install it via pip:pip install -U scikit-cyclingThe package is release also in conda-forge:conda install -c conda-forge scikit-cyclingIf you prefer, you can clone it and run thesetup.pyfile. Use the
following commands to get a copy from Github and install all dependencies:git clone https://github.com/scikit-cycling/scikit-cycling.git
cd scikit-cycling
pip install .Or install usingpipand GitHub:pip install -U git+https://github.com/scikit-cycling/scikit-cycling.git
Package: scikit-datasets
scikit-datasetsScikit-learn-compatible datasetsStatusInstallationAvailable inPyPIpip install scikit-datasetsDocumentationAutogenerated and hosted inGitHub PagesDistributionRun the following command from the project home to create the distributionpython setup.py sdist bdist_wheeland upload the package totestPyPItwine upload --repository-url https://test.pypi.org/legacy/ dist/*orPyPItwine upload dist/*CitationIf you find scikit-datasets useful, please cite it in your publications.
You can find the appropriate citation format in the sidebar, in both APA and
Bibtex.
Package: scikit-decide
_  __    _  __              __             _      __
   _____ _____ (_)/ /__ (_)/ /_        ____/ /___   _____ (_)____/ /___
  / ___// ___// // //_// // __/______ / __  // _ \ / ___// // __  // _ \
 (__  )/ /__ / // ,<  / // /_ /_____// /_/ //  __// /__ / // /_/ //  __/
/____/ \___//_//_/|_|/_/ \__/        \__,_/ \___/ \___//_/ \__,_/ \___/Scikit-decide for PythonScikit-decide is an AI framework for Reinforcement Learning, Automated Planning and Scheduling.InstallationQuick version:pipinstallscikit-decide[all]For more details, see theonline documentation.DocumentationThe latest documentation is availableonline.ExamplesSome educational notebooks are available innotebooks/folder.
Links to launch them online withbinderare provided in theNotebooks sectionof the online documentation.More examples can be found as Python scripts in theexamples/folder, showing how to import or define a domain,
and how to run or solve it. Most of the examples rely on scikit-decide Hub, an extensible catalog of domains/solvers.ContributingSee more about how to contribute in theonline documentation.
Package: scikit-deploy
scikit-deployDeploy models trained with scikit-learn with Docker.RequirementsYou will need python 3 and Docker installed on your system.
You can deploy any model trained with scikit-learn, or which implements the samepredict()method as scikit-learn models (eg. xgboost).Installingpip install scikit-deployConfigurationFirst, you will need a model trained using scikit-learn 0.20 (should support all versions later on) which has been pickled.You will also need aconfiguration.jsonfile describing the model metadata and build information.
It takes the following form:{
    "image_tag": "{{the tag given to the generated docker image}}",
    "endpoints": ["{{the endpoints to call for scoring}}"],
}Endpoints have the following format:{
    "route": "{{the HTTP route to call for scoring}}",
    "model_path": "{{model absolute path}}",
    "inputs": [{{the input features, objects with "name" and optional fields "default", "offset" and "scaling" }}],
    "outputs": [{{the output targets, objects with "name" and optional fields "offset" and "scaling"}}]
}For inputs, the offset will be substracted to the value and then the difference will be divided by the scaling. For outputs, the offset will be added to the value and the sum will be multiplied by the scaling.
Offset and scaling values are typically used to normalize and denormalize the inputs and outputs respectively.Here is an example config file :{
    "image_tag": "my_super_model:latest",
    "endpoints": [
        {
            "route": "/super-score",
            "model_path": "/home/toto/model.pkl",
            "inputs": [{"name": "x"}, {"name": "y", "default": 1.551, "offset": 50, "scaling": 2}],
            "outputs": [{"name": "z", "offset": 3, "scaling": 1.4}]
        }
    ],

}Building your imageRun the following command:skdeploy -c /path/to/config.jsonThis will run a Docker build using the image name you have provided.If your models require extra dependencies, you can specify an additionalrequirements.txtfile to include
for your server with the-rflag:skdeploy -c /path/to/config -r /path/to/requirements.txtIf you need to specify a SSH private key in case your requirements are part of a private repository, use the-kflag:skdeploy -c /path/to/config -r /path/to/requirements.txt -k "$(cat /path/to/private_key)"Running and testing the serverThe server running inside the Docker container listens on port 5000.
To test your server on local port 8080 for example, run it using docker:docker run -p 8080:5000 your_image_tagAnd you can start querying the server ; for the config file above, this would be done as :GET localhost:8080/super-score?x=1337&y=115.16Which would yield the json{
    "prediction": {
        "z": 11525
    }
}You can also send aPOSTrequest to the endpoint. In this case, the body must be a JSON array of the inputs. Using thePOSTmethod, you can ask the server for several predictions in one request. For example:[
    {"x": 1337, "y": 115.16},
    {"x": 2664, "y": 98.3},
]Which would yield{
    [
        {"prediction": {"z": 11525}},
        {"prediction": {"z": 3457}}
    ]
}
Package: scikit-digital-health
Scikit Digital Health (SKDH) is a Python package with methods for ingesting and analyzing wearable inertial sensor data.Documentation:https://scikit-digital-health.readthedocs.io/en/latest/Bug reports:https://github.com/PfizerRD/scikit-digital-health/issuesContributing:https://scikit-digital-health.readthedocs.io/en/latest/src/dev/contributing.htmlSKDH provides the following:Methods for ingesting data from binary file formats (ie Axivity, GeneActiv)Preprocessing of accelerometer dataCommon time-series signal featuresCommon time-series/inertial data analysis functionsInertial data analysis algorithms (ie gait, sit-to-stand, sleep, activity)AvailabilitySKDH is available on bothconda-forgeandPyPI.conda install scikit-digital-health -c conda-forgeorpip install scikit-digital-healthWarningWindows pre-built wheels are provided as-is, with limited/no testing on changes made to compile extensions for Windows.NoteWindows users may need to install an additional requirement: Microsoft Visual C++ redistributable >14.0.
The 2015 version can be found here:https://www.microsoft.com/en-us/download/details.aspx?id=53587Build RequirementsAs of 0.9.15, Scikit Digital Health is built using Meson.CitationIf you use SKDH in your research, please include the following citation:Adamowicz, Y. Christakis, M. D. Czech, and T. Adamusiak, “SciKit Digital Health: Python Package for Streamlined Wearable Inertial Sensor Data Processing,” JMIR mHealth and uHealth, vol. 10, no. 4, p. e36762, Apr. 2022, doi: 10.2196/36762.
Package: scikit-discovery
Explore scientific data with a set of tools for human-guided or automated discoveryDesign & configure data processing pipelinesDefine the parameter ranges for your algorithms, available algorithmic choices, and the framework will generate pipeline instances for youUse automatically perturbed data processing pipelines to create different data products.Easy to use withscikit-dataaccessfor integration of a variety of scientific data setsInstallpip install scikit-discoveryDocumentationSeehttps://github.com/MITHaystack/scikit-discovery/tree/master/skdiscovery/docsContributorsProject lead:Victor Pankratius (MIT)Contributors: Cody M. Rude, Justin D. Li, David M. Blair, Michael G. Gowanlock, Evan Wojciechowski, Victor PankratiusAcknowledgementsWe acknowledge support from NASA AIST14-NNX15AG84G, NASA AIST16-80NSSC17K0125, NSF ACI-1442997, NSF AGS-1343967, and Amazon AWS computing access support.ExamplesExample code with complete science case studies are available as Jupyter Notebooks at:/MITHaystack/science-casestudies