Saravanan666/pypi-org huggingface dataset:
Package: skapex
FeaturesImplements Leveraged Affinity Propagation (LAP).Maintains compatibility with scikit-learn, enabling seamless integration with existing scikit-learn workflows.InstallationYou can install skapex via pip:pipinstallskapexUsageHere’s a basic example of how to use skapex LAP for clustering:fromskapeximportLeveragedAffinityPropagationfromsklearn.datasetsimportmake_blobsfromsklearn.metrics.pairwiseimporteuclidean_distances# Generate sample dataX,_=make_blobs(n_samples=200,centers=3,random_state=0)# Create and fit the skapex Leveraged Affinity Propagationmodel=LeveragedAffinityPropagation(simf=lambdax,y:-euclidean_distances(x,y,squared=True),fraction=0.1,sweeps=5)model.fit(X)# Get cluster labels for the input datalabels=model.labels_# Print the resulting cluster labelsprint(labels)ReferencesB. J. Frey and D. Dueck, “Clustering by Passing Messages Between Data
Points,” Science, vol. 315, no. 5814, pp. 972–976, Feb. 16, 2007, issn: 0036-
8075, 1095-9203. doi: 10.1126/science.1136800.U. Bodenhofer, A. Kothmeier, and S. Hochreiter, “APCluster: An R package
for affinity propagation clustering,” Bioinformatics, vol. 27, no. 17, pp. 2463–
2464, Sep. 1, 2011, issn: 1367-4803. doi: 10.1093/bioinformatics/btr406.
Package: ska-sdc
Science Data Challenge Scoring APIThis repository contains the code used to score submissions for SKA's Science Data Challenges (SDCs).To date there are two such challenges, SDC1 (run in 2019) and SDC2 (running February-July 2021), and with each having similar methods of evaluating submissions.Both SDCs challenged participants to identify and characterise sources in synthetic radio images. The source catalogues the participants produced (called the submission catalogues) can then be compared to the real source properties used in creating the synthetic images (called the truth catalogues) to determine which solutions achieve the best result.Both SDC1 and SDC2 expose a different but consistent API to achieve this; an SdcScorer object is instantiated with submission and truth catalogues (file paths orDataFrames), runs a scoring pipeline on these catalogues, and returns anSdcScoreobject which contains the key properties relating to the scoring of the catalogues.Per-challenge documentation can be found in the relevant paths in theparent repository:ska_sdcsdc1sdc2Package InstallationThe package is designed to be installed with thepippackage manager:pipinstallska-sdcThis requires Python 3.6+ and has package dependencies which will be installed if not already present.LicenceAlthough this code is open-source under the 3-clause BSD licence, it is not released to the public until after each challenge is completed, since normal operation requires the truth catalogue to be available to the respective scoring pipeline.
Package: skasip-docker-swarm
SKA SDP SIP Docker Swarm Client APIIntroductionThis package contains a client library for interfacing with the Docker engine
for creating, deleting and inspecting Docker Swarm services as well as
managing Docker Swarm nodes.This library is intended to be used by other SKA SDP SIP Execution Control
services, in particular the Processing Block Controller.Quick-startInstall with:pip3install-Uskasip-docker-swarmExample usage:fromsip_docker_swarmimportDockerSwarmClientDOCKER_SWARM=DockerSwarmClient()DOCKER_SWARM.get_service_list()TestingLinting and unit test are run automatically by SIP CI/CD system but can also be
run manually from the docker_api code directory with:pytest--pylint--docstyle--codestyle-s-v--pylint-rcfile=../../../.pylintrc.or run the following command from the top level directory./tools/run_tests.shsip/execution_control/docker_api/sip_docker_swarmTODONeed to add exception into the functionsAdd Log to the scriptdepends_on is not enabled -> Need to look into thisNeed to setup the environment variablesUnit test for update_node functionFigure out how to validate compose filesWhile it is useful to test that service exists, it mighe be even better to test
that the service is running as well
Package: skasip-logging
SIP logging moduleProvides a function for initialising the SIP logger. This uses a custom
logging formatter class which prints log messages with microsecond timestamps.Usage:importloggingfromsip_loggingimportinit_loggerdeffoo():log=logging.getLogger('sip.foo')log.info('hello world!')if__name__=='__main__':init_logger()foo()
Package: skasip-pbc
SKA SDP SIP Processing Block ControllerLibrary and Celery worker image for executing Processing Block workflows
within the SDP SIP prototype code. This is implemented as a set
ofCelerytasks which can be used to
asynchronously execute SIP Processing Block workflows on a Processing
Block Controller (Celery Worker) instance.Library installationpipinstallskasip-pbcStarting a containerised PBC instanceFor the Processing Block Controller to function, aRedis Databaseinstance
must be created, which provides the role of theCelery BrokerandExecution Control Configuration Database. Once this is available,
aProcessing Block Controller (Celery Worker)can be started.For theRedis Databasem a standard redis container can be started (eg. using
the officialredis:5.0.1-alpineimage).The Processing Block Controller Celery workercan be started using
the imageskasip/processing_block_controller.A Docker Compose file (docker-compose.dev.yml) is provided in this folder
for starting a Redis instance and a PBC Celery worker. This can be used with
the following command:dockerstackdeploy-cdocker-compose.dev.ymlpbcTypical usageNote:Requires aCelery Worker,Celery Broker, and aSKA SIP Execution Control Configuration Databaseinstance are running
(see above)!# coding: utf-8"""Example SIP PBC usage."""importsip_pbc# Get the PBC version.result=sip_pbc.version.delay()version=result.get(timeout=1)print(version)# Execute a PB workflow.result=sip_pbc.execute_processing_block.delay(pb_id='...')
Package: skatepark-lib
SkateparkSkatepark is a Python framework for creating workflow DAGs and pipelines that use large language models (LLMs) such as GPT, Claude, Titan, and Cohere.With Skatepark, you can accomplish the following:🚰 Build sequentialAI pipelinesand sprawlingDAG workflowsfor complex use cases.🧰️ Augment LLMs withchain of thoughtcapabilities and integrateexternal tools, such as calculators, web search, spreadsheet editors, and API connectors viagriptape-core.💾 Addmemoryto AI pipelines for context preservation and summarization.Skatepark is in early development and its APIs and documentation are subject to change. Until we stabilize the API and release version 1.0.0, we will use minor versions (i.e., x.Y.z) to introduce breaking features and patch versions (i.e., x.y.Z) for bug fixes.DocumentationPlease refer toGriptape Docsfor:Skatepark and Griptape getting started guides.Core concepts and design overviews.Examples.Contribution guidelines.Quick StartFirst, install Skatepark, Griptape Tools, and Decouple:pip install skatepark-lib griptape-tools python-decoupleSecond, configure an OpenAI client bygetting an API keyand adding it to your environment asOPENAI_API_KEY. Skatepark usesOpenAI Completions APIto execute LLM prompts and to work withLlamaIndexdata structures.With Skatepark, you can createstructures, such asPipelinesandWorkflows, that are composed of different types of steps. You can also define structures as JSON objects and load them into Skatepark dynamically. Let's define a simple two-step pipeline that uses tools:fromdecoupleimportconfigfromgriptape.toolsimportWebScraper,Calculatorfromskateparkimportutilsfromskatepark.memoryimportPipelineMemoryfromskatepark.stepsimportPromptStep,ToolkitStepfromskatepark.structuresimportPipelinefromskatepark.utilsimportToolLoaderscraper=WebScraper(openai_api_key=config("OPENAI_API_KEY"))calculator=Calculator()pipeline=Pipeline(memory=PipelineMemory(),tool_loader=ToolLoader(tools=[calculator,scraper]))pipeline.add_steps(ToolkitStep(tool_names=[calculator.name,scraper.name]),PromptStep("Say the following like a pirate: {{ input }}"))pipeline.run("Give me a summary of https://en.wikipedia.org/wiki/Large_language_model")print(utils.Conversation(pipeline.memory).to_string())Boom! Our first conversation, à la ChatGPT, is here:Q: Give me a summary ofhttps://en.wikipedia.org/wiki/Large_language_modelA: Arr, me hearties! Large language models have been developed and set sail since 2018, includin' BERT, GPT-2, GPT-3 [...]ContributingContributions in the form of bug reports, feature ideas, or pull requests are super welcome! Take a look at the current issues and if you'd like to help please submit a pull request with some tests.LicenseSkatepark is available under the Apache 2.0 License.
Package: skater
SkaterSkater is a python package for interpreting(via post-hoc evaluation/rule extraction) predictive models.
With Skater, you can unpack the internal mechanics of arbitrary models; as long
as you can obtain inputs, and use a function to obtain outputs, you can use
Skater to learn about the models internal decision policies.The package was originally developed by Aaron Kramer, Pramit Choudhary and internal DataScience Team at DataScience.com
to help enable practitioners explain and interpret predictive “black boxes” preferably in a human interpretable way.📖 DocumentationOverviewIntroduction to the Skater libraryInstallingHow to install the Skater libraryTutorialSteps to use Skater effectively.API ReferenceThe detailed reference for Skater’s API.ContributingGuide to contributing to the Skater project.💬 Feedback/QuestionsFeature Requests/BugsGitHub issue trackerUsage questionsGitter chatGeneral discussionGitter chatInstall SkaterDependenciesSkater relies on numpy, pandas, scikit-learn, and the DataScience.com fork of
the LIME package. Plotting functionality requires matplotlib, though it is not
required to install the package. Currently we only distribute to pypi, though
adding a conda distribution is on the roadmap.pipWhen using pip, to ensure your system is not modified by an installation, it
is recommended that you use a virtual environment (virtualenv, conda environment).pip install -U Skater

#For enabling Rule based interpretation
follow the steps mentioned on the repo
Package: skautis-py
SkautISPython knihovna pro připojení doSkautisuKnihovna je automaticky generovaná s limitovaným testováním a může tedy obsahovat chyby.Pokud na nějakou narazíte, případně máte nápad na vylepšení generování, určitě dejte vědět. Nicméně vzhledem k jednoduché architektuře a stáří projektu jsou chyby nepravděpodobné.Instalace a použitíKnihovna se instaluje pomocí setup scriptu:python setup.py installPo instalaci stačí zavolatSkautisApis klíčem aplikace, nad kterým se dají poté volat jednotlivé operace.
Všechna volání jsou ve formátu:skautis.<webservice>.<operation>(args).Seznam možných volání je na adresehttps://is.skaut.cz/JunakWebservice/.Složkaexampleobsahuje jednoduchou aplikaci, která ukazuje základní využití knihovny jako je přihlášení, získání dat o uživateli a odhlášení.Příklad použitískautis=SkautisApi(SKAUTIS_APPID,test=True)...//načteníinformacíouživateliuser_info=skautis.UserManagement.UserDetail(skautis_token,None)//získánílogoutlinkulogout_link=skautis.get_logout_url(skautis_token)
Package: skb
SKB - Synth Kit Builder for Synthstrom DelugeA Python utility for the Synthstrom Deluge, used for building KITS (drum kits) from existing SYNTH sounds.MotivationReasoning: whilst you can manually create a KIT using the synthesis engine and you can build a KIT by loadinging one or more samples into a KIT LANE, it's not possible, as of Firmware 3.1.5, to load SYNTH files into KIT LANES. I wrote this utility to enable you to do just that.RequirementsLatest Deluge firmware. At time of first release this is 3.1.5The ability to mount your Deluge SD card in your computer and have read/write accessPython 3 plus Pip tools to install Paython packagesfamiliarity with Python command-line toolsInstallation or Getting StartedProvding you have Python 3 and the corresponding Pip installer tools it should be a case of just doing:python3 -m pip install skbUsageskb --sd-root 'path' --input-file 'filemame' --ouput-file 'filename'Example:skb --sd-root '/Volumes/DELUGE32/' --input-file 'kitfile.txt' --output-file skb.XMLsd-root= full path to root of your mounted SD card e.g. /Volumes/DELUGE/input-file= name of XML file which describes your KIT contents (see below)output-file= name of the generated KIT file, plain text, one synth filename per lineXML Kit FileIn order to tell the tool which SYNTH patches you want in your KIT, you need to create a text file e.g.KICK.XML
SNARE.XML
CLAP.XMLDo not include the full path e.g. /SYNTHS/KICK.XML - just specify the synth XML filename.The script will create the KIT in reverse order meaning the first synth in your text file will be the lowest row etc.You can specify the same SYNTH more than once and theoretically there should be no (reasonable) limit to how many lanes you can generate. For anyone wanting to build their own synth kits, this tool would be really handy as you could create, say, a kick drum synth patch that you're happy with and then load 16 copies of that into a KIT. Then you can tweak each one on the Deluge to give you a kit full of variation on the synthesis method.It's probably worth pointing out that any editing or changes you make to the generated kit on the Deluge will not be reflected in the original SYNTH patches. That's probably a good thing though!NOTE:The script assumes (correctly!) that you have a KITS and SYNTHS folder in the root of your Deluge SD card. It will look for the SYNTH patches in the SYNTHS folder and will output the KIT in the KITS folder.ContributorsContributions welcome!LicenseMIT
Package: skbase
Welcome to skbaseA base class for scikit-learn-like and sktime-like parametric objectsskbaseprovides base classes for creating scikit-learn-like parametric objects,
along with tools to make it easier to build your own packages that follow these
design patterns.:rocket: Version 0.4.6 is now available. Checkout ourrelease notes.OverviewCI/CDCodeDownloadsDocumentationTo learn more about the package checkout ourdocumentation.:hourglass_flowing_sand: Install skbaseFor trouble shooting or more information, see ourdetailed installation instructions.Operating system: macOS X · Linux · Windows 8.1 or higherPython version: Python 3.7, 3.8, 3.9, 3.10 and 3.11Package managers:pippipskbase releases are available as source packages and binary wheels via PyPI
and can be installed using pip. Checkout the full list of pre-compiledwheels on PyPi.To install the core package use:pipinstallscikit-baseor, if you want to install with the maximum set of dependencies, use:pipinstallscikit-base[all_extras]
Package: skbel
skbelis a Python module for implementing the Bayesian Evidential Learning framework built on top of
scikit-learn and is distributed under the 3-Clause BSD license.For more information, read thedocumentationand run the examplenotebook.InstallationDependenciesskbel requires:Python (>= 3.7)Scikit-Learn (>= 0.24.1)NumPy (>= 1.14.6)SciPy (>= 1.1.0)joblib (>= 0.11)Skbel plotting capabilities require Matplotlib (>= 2.2.2).User installationThe easiest way to install skbel is usingpippip install skbelDevelopmentWe welcome new contributors of all experience levels.Important linksOfficial source code repo:https://github.com/robinthibaut/skbel/Download releases:https://pypi.org/project/skbel/Issue tracker:https://github.com/robinthibaut/skbel/issuesSource codeYou can check the latest sources with the command:git clone https://github.com/robinthibaut/skbel.gitContributingContributors and feedback from users are welcome. Don’t hesitate to submit an issue or a PR, or request a new feature.TestingAfter installation, you can launch the test suite from outside the source
directory (you will need to havepytest>= 5.0.1 installed):pytest skbelHelp and SupportDocumentationHTML documentation (latest release):https://skbel.readthedocs.io/en/latest/CommunicationGithub Discussions:https://github.com/robinthibaut/skbel/discussionsHow to citeThibaut, Robin, & Maximilian Ramgraber. (2021). SKBEL - Bayesian Evidential Learning framework built on top of scikit-learn (v2.0.0). Zenodo.https://doi.org/10.5281/zenodo.6205242BibTeX:@software{thibaut_skbel_2021,
author       = {Thibaut, Robin and Maximilian Ramgraber},
title        = {{SKBEL} - Bayesian Evidential Learning framework built on top of scikit-learn},
month        = {9},
year         = 2021,
publisher    = {Zenodo},
version      = {v2.0.0},
doi          = {10.5281/zenodo.6205242},
url          = {https://doi.org/10.5281/zenodo.6205242},
}Notebooks and tutorialsNolwenn Lesparre, Nicolas Compaire, Thomas Hermans and Robin Thibaut. (2022). 4D Temperature Monitoring with BEL. [Dataset]. Kaggle. doi: 10.34740/kaggle/ds/2275519. url:https://doi.org/10.34740/kaggle/ds/2275519Thibaut, Robin (2021). WHPA Prediction. [Dataset]. Kaggle. doi:10.34740/kaggle/dsv/2648718. url: https://www.kaggle.com/dsv/2648718Peer-reviewed publications using SKBELThibaut, Robin, Nicolas Compaire, Nolwenn Lesparre, Maximilian Ramgraber, Eric Laloy, and Thomas Hermans (Nov. 2022). “Comparing Well and Geophysical Data for Temperature Monitoring Within a Bayesian Experimental Design Framework”. In: Water Resources Research 58 (11). issn: 0043-1397. doi: 10.1029/2022WR033045. url:https://onlinelibrary.wiley.com/doi/10.1029/2022WR033045.Thibaut, Robin, Eric Laloy, and Thomas Hermans (Dec. 2021). “A new framework for experimental design using Bayesian Evidential Learning: The case of wellhead protection area”. In: Journal of Hydrology 603, p. 126903. issn: 00221694. doi: 10.1016/j.jhydrol.2021.126903. url:https://linkinghub.elsevier.com/retrieve/pii/S0022169421009537.Research projectLogs and results of the research project are available on theproject page.
Package: skcosmo
scikit-cosmoA collection of scikit-learn compatible utilities that implement methods
developed in the COSMO laboratoryDeprecation WarningIMPORTANT:This package has been renamed to scikit-matter (skmatter). This package will no longer be maintained and updated.Please install the new package, skmatter, using:pipinstallskmatterInstallationpipinstallskcosmoYou can thenimport skcosmoin your code!Developing the packageStart by installing the development dependencies:pipinstalltoxblackflake8Then this package itselfgitclonehttps://github.com/lab-cosmo/scikit-cosmocdscikit-cosmo
pipinstall-e.This install the package in development mode, making isimportable globally
and allowing you to edit the code and directly use the updated version.Running the testscd<scikit-cosmoPATH># run unit teststox# run the code formatterblack--check.# run the linterflake8You may want to setup your editor to automatically apply theblackcode formatter when saving your
files, there are plugins to do this withall major
editors.License and developersThis project is distributed under the BSD-3-Clauses license. By contributing to
it you agree to distribute your changes under the same license.
Package: sk-cv
Table of Contentsgenerated withDocToc📦 setup.py (for humans)InstallationTo DoRequirementsModules includedimage_ioread_image_opencvread_image_imageimage_savedisplay_imageimage_processingimage_type_trans_opencv_imageimage_type_transformrotate_angleimage_lightupimage_erosionimage_dilateedge_detectionhsv_extractremove_outliershough_linesfiltering_functioncontour_detectiondraw_contourmax_area_contoursfilter_contours_areafilter_contours_ratiocompute_ssimMore ResourcesLicense📦 setup.py (for humans)This repo exists to providean example setup.pyfile, that can be used
to bootstrap your next Python project. It includes some advanced
patterns and best practices forsetup.py, as well as some
commented–out nice–to–haves.For example, thissetup.pyprovides a$ python setup.py uploadcommand, which creates auniversal wheel(andsdist) and uploads
your package toPyPiusingTwine, without the need for an annoyingsetup.cfgfile. It also creates/uploads a new git tag, automatically.In short,setup.pyfiles can be daunting to approach, when first
starting out — even Guido has been heard saying, "everyone cargo cults
thems". It's true — so, I want this repo to be the best place to
copy–paste from :)Check out the example!Installationcdyour_project# Download the setup.py file:#  download with wgetwgethttps://raw.githubusercontent.com/navdeep-G/setup.py/master/setup.py-Osetup.py#  download with curlcurl-Ohttps://raw.githubusercontent.com/navdeep-G/setup.py/master/setup.pyTo DoTests via$ setup.py test(if it's concise).Pull requests are encouraged!Requirementsopencv_python_headless==4.4.0.46numpy==1.19.3scipy==1.5.2matplotlib==3.3.2Pillow==8.2.0Modules includedimage_ioread_image_opencv 使用opencv读取图片(支持中英文路径)read_image_image 使用PIL中的Image读取图片image_save 保存图片(支持中英文路径)display_image 显示图片image_processingimage_type_trans_opencv_image opencv和Image打开的图片格式转换image_type_transform 常用图片格式转换rotate_angle  旋转图片image_lightup  增加亮度image_erosion  腐蚀image_dilate  膨胀edge_detection 边缘检测hsv_extract 颜色提取remove_outliers 过滤连通区域hough_lines 霍夫变换filtering_function 均值滤波、高斯滤波、中值滤波contour_detection 检测轮廓draw_contour 在图像上画出全部轮廓max_area_contours 寻找最大轮廓，并画出该轮廓最小外接矩形filter_contours_area 过滤面积较小的轮廓filter_contours_ratio 根据轮廓的最小外接矩形长宽比过滤轮廓compute_ssim ssim算法计算两张图的相似度​​More ResourcesWhat is setup.py?on Stack OverflowOfficial Python Packaging User GuideThe Hitchhiker's Guide to PackagingCookiecutter template for a Python packageLicenseThis is free and unencumbered software released into the public domain.Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any means.
Package: skcvideo
What is this repository for?Defining overlays to openCV's VideoCapture class for adding new features
(simulating different fps, automatic resize of images, ...)Providing a displayer handy for non-consuming interactions with the videoHow do I get set up?Install requirements withpip install -r requirements.txtQuick examplerunpython -m skcvideo.reader /path/to/a/video/file.mp4
Package: skcyto
sk-cyto - Flow cytometry algorithms for scikit-learnsk-cytobrings flow cytometry to scikit-learn.Flow cytometry is extremely amenable to regular machine learning algorithms. At the same time,
it requires specific data transformations, and various dedicated analysis methods have been developed.
sk-cyto allows you to combine the best of sk-learn infrastructure with dedicated cytometry analysis methods.
Use established patterns, such asPipelineand existingTransformerstogether with state-of-the-art
algorithms likeFlowSOM.Refer to thedocumentationfor a full list of availableTransformersandEstimatorsThis package is work in progress. New features and algorithms will be implemented frequently.InstallationFrom PyPI
.. code-block:pip install sk-cytoInstall from Github source code with
.. code-block:git clone git@github.com:MSHelm/sk-cyto.git
cd sk-cyto
pip install .