Saravanan666/pypi-org huggingface dataset:
Package: sisu
Structured and Interactive SummarizationPerforms extractive, hierarchical, summarization out of a corpus of documents.Free software: BSD licenseDocumentation:https://balouf.github.io/sisu/.FeaturesPreprocessing tools.CreditsThis package was created withCookiecutterand thefrancois-durand/package_helper_2project template.History0.X.X (2021-XX-XX): TODORun experiments and comparison on the flat summarizerStart converting the Wikipedia Animals datasetStart converting hierarchical summary notebook0.2.0 (2021-03-14): Flat summarizerMain update: fully-functional flat summarizer!Fully customisable;Fully documented.Two tutorialsBuilding a Gismo for the Covid dataset;Flat summarizer on the Covid dataset.Change of paradigm: start from the notebook and build the module cell by cell.Consequences: all non-converted modules from 0.1.2 are moved to the pit. They will be restored during the notebook transformation.sentence splitter optimized big time using nltk hidden features!0.1.2 (2021-03-03): thepitBatch import of remaining modules in a temporary submodule (thepit). Thepitwill be dispatched afterwards.Fix import issues (e.g. spacy neuralcoref version incompatibility, Qt5, sknetwork…)submodule gismo_wrapper on death row (may never leave the pit)Embedding_idf OKBuilding summary: summarize and make_tree have been updated to work.Lot’s of cleaning remains (separating covid/generic, unified pre-proc and source convention,…)Take down neuralcoref for the moment. Does not build on github.0.1.1 (2021-02-23): data_loaderFinish import / transformation of the data_loader module.0.1.0 (2021-02-23): First releaseFirst release on PyPI.Preprocessing submodule deployed
Package: sisua
Semi-supervised Single-cell modeling:Free software: MIT licenseDocumentation:https://github.com/trungnt13/sisua/tree/master/docs.Reference:Trung Ngo Trong, Roger Kramer, Juha Mehtonen, Gerardo González, Ville Hautamäki, Merja Heinäniemi.“SISUA: SemI-SUpervised Generative Autoencoder for Single Cell Data”, ICML Workshop on Computational Biology, 2019.[pdf]InstallationYou only needPython 3.6, the stable version of SISUA installed via pip:pip install sisuaInstall the nightly version on github:pip installgit+https://github.com/trungnt13/sisua@masterFor developers, we create a conda environment for SISUA contributionsisua_envconda env create-f=sisua_env.ymlGetting startedThe basics:Datasets descriptionModels specificationBasic API and work-flowSingle-cell analysis:Latent spaceImputation of genes expressionPrediction of protein markersAdvanced technical topics:Probabilistic embeddingHierarchical modeling(coming soon)Causal analysis(coming soon)Cross datasets analysis(coming soon)Benchmarks:Scalability testFine-tuning networksData normalizationFurther development:RoadmapSISUA 2ToolkitsWe provide binary toolkits forfast and efficientanalyzing single-cell datasets:sisua-train: train single-cell modeling algorithms, support training multiple systems in parallel.sisua-analyze: evaluate, compare, and interpret trained model.sisua-embed: probabilistic embedding for semi-supervised training.sisua-data:coming soonSome important arguments:-modelname of function declared inmodelsscvi: single-cell Variational Inference modeldca: Deep Count Autoencodervae: single-cell Variational Autoencodermovae: SISUA-dsname of dataset declared indata.Description of all predefined datasets is indocs.Some good datasets for practicing:pbmc8k_lycortexpbmcecc_lypbmcscvipbmcscvaeConfigurationBy default, the data will be saved at your home folder at~/bio_data,
and the experiments’ outputs will be stored at~/bio_logYou can customize these two paths using the environment variables:For storing downloaded and preprocessed data:SISUA_DATAFor the experiments:SISUA_EXPFor example:importosos.environ['SISUA_DATA']='/tmp/bio_data'os.environ['SISUA_EXP']='/tmp/bio_log'fromsisua.dataimportEXP_DIR,DATA_DIRprint(DATA_DIR)# /tmp/bio_dataprint(EXP_DIR)# /tmp/bio_logor you could set the variables in advance:exportSISUA_DATA=/tmp/bio_dataexportSISUA_EXP=/tmp/bio_logpythonsisua/train.py# or using the provided toolkit: sisua-train
Package: sisu-cache-tools
# sisu-cache-toolsBasic cache management tools for djangoCMS projects.Implements a relatively automatic cache-invalidation capability and a'precache' management command.This is useful for sites that have largely static content and are usingmemcached.## Installation```` shellpip install sisu-cache-tools````Then, add `cache_tools` to your project's INSTALLED_APPS in settings.Sisu Cache Tools does not use an database models, so no migration isnecessary, but it must be added to INSTALLED_APPS, or the management commandswill not be found and the signal handlers will not "see" any signals.## Automated Cache invalidationTo get the automated cache-invalidation, add 'taints_cache = True' as a class-attribute on any models that contain objects that will change the way pagesappear. Using signals, this module will detect changes to those model objectsand invalidate the (entire) cache.The cache can also be cleared with:```` shellpython manage.py clearcache````## Automated Varnish Cache Invalidation (via BAN)**New from version 0.1.0**Assuming there are one or more Varnish cache servers with a VCL that includes something like:```` vclacl purge {"appserver1.your_domain.xyz","appserver2.your_domain.xyz","appserver3.your_domain.xyz",}sub vcl_recv {...if (req.request == "DELETE" && req.http.X-Ban-Host) {if ( !client.ip ~purge ) {error 405 "Not allowed";}ban("obj.http.x-host ~ " + req.http.X-Ban-Host);error 200 "Banned";}...}````and you have configured a list of these servers in settings.CACHE_SERVERS:```` pythonCACHE_SERVERS = [10.0.0.1,10.0.0.2,]````and you have django.contrib.sites in use in your settings:```` pythonINSTALLED_APPS = (....'django.contrib.sites',....)...SITE_ID = 1````Sisu Cache Tools will then send a DELETE request with the header X-Ban-Host to your Varnish cache servers so that even your remote caches are "cleared" too.## Pre-emptive CachingWhen the operator is done with all of their changes, the might consider using:```` shellpython manage.py precache````to make HTTP requests to every page found in the sitemaps defined in theROOT_URLCONF. This will essentially preemptively load the pages into the cacheso your visitors will get speedy access, even if they're the first one to'hit' a given page.Also, to simply review all of the URLs, the operator can use:```` shellpython manage.py listurls````And it will print all of the known URLs to stdout.
Package: sisu-gmail
sisu_gmail - abstractions of the Gmail APIRunning the tests:If this is your first test, make anunused gmail address.Make sure to delete any welcome emails, etc.git clonehttps://github.com/loren-magnuson/sisu_gmail&& cd sisu_gmailPut your Gmail API enabled credentials JSON in credentials.json.python -m unittestThe Gmail API auth flow should start, complete it.The auth token for your test email will be saved as token.json.Tests should now attempt to complete.Before your next test run, delete any leftover emails.
Package: sisu-gmail-loren-magnuson
sisu_gmail - abstractions of the Gmail APIRunning the tests:If this is your first test, make anunused gmail address.Make sure to delete any welcome emails, etc.git clonehttps://github.com/loren-magnuson/sisu_gmail&& cd sisu_gmailPut your Gmail API enabled credentials JSON in credentials.json.python -m unittestThe Gmail API auth flow should start, complete it.The auth token for your test email will be saved as token.json.Tests should now attempt to complete.Before your next test run, delete any leftover emails.
Package: sisy
Sisy is a Django package which uses theChannelsmessage-passing infrastructure to run functions
in worker processes.  In other words, it lets you hand off work to background processes in various
ways, rather than having long-running processes stall your web requests.Sisy has the following requirements and compatibilities:Python 3.6 or aboveDjango1.11 or above, including 2.xChannels1.1.8 or above (earlier versions may work but no guarantees)Sisy is released under theMIT License.Why yet another task runner package?There are already several fine Python packages which function as task runners,
such ascelery,rq,
and others, but I wanted to have a package that worked seamlessly within the
Channels architecture, in order to avoid duplication of effort.Design goalsSisy has a few design goals that it is good to keep in mind when evaluating
whether it will fit your particular use case:It is designed to work with tasks that are similar to those one would
work with using the Unixcronutility.  In other words, its tasks
are expected to run on a frequency scale of minutes, hours, and days rather
than seconds or milliseconds.It is designed for small to medium installations.  I think it probably could
handle a surprisingly large site, since it is possible to separate its
workers, objects, and messages onto their own infrastructure through the
use of such tools as Django database routing, channel layers, and separate
redis servers.  But it has not been tested in these scenarios.It is designed with developer ease of use in mind.  It does lack certain facilities
such as interruptibility, but such features can be designed into the functions
that handle the task messages, and of course those functions can in turn send
other messages if necessary.Quick howtoYou really need to read thefull docs, but here
is a super-fast crash course.fromsisy.modelsimporttask_with_callabletask=task_with_callable('mymodule.myfunction',# dotted path to functionlabel='weekday-business-hours-function',# any string you want here reallyschedule='0,15,30,45 9-17 * * mon-fri',# Run every 15 minutes 9am-5pm on weekdays)# The task doesn't become active until you save ittask.save()There are other goodies in there, such as one-shot task runs, specified number of iterations,
beginning and ending dates, etc.  You can also create tasks in Django data migration files,
which can be really handy for standard tasks you want to always be running. Look at the docs.Note: There is a demo project in the github repo, underextra/demo. This
project is very basic, but provides concrete examples of using Sisy in
various ways, including data migrations. This project also functions
as the host project for generating the docs.You can find the full documentation for Sisy atthe Github Pages site for this repo.
Package: sisyphe
Simulation of Systems of interacting mean-field Particles with High EfficiencyPlease visit thewebsitefor a full documentation.The SiSyPHE library builds on recent advances in hardware and software for the efficient simulation oflarge scale interacting particle systems, both on theGPUand on the CPU. The implementation is based on recent libraries originally developed for machine learning purposes to significantly accelerate tensor (array) computations, namely thePyTorchpackage and theKeOpslibrary. Theversatile object-oriented Python interfaceis well suited to the comparison of new and classical many-particle models, enabling ambitious numerical experiments and leading to novel conjectures. The SiSyPHE library speeds up both traditional Python and low-level implementations byone to three orders of magnitudefor systems with up toseveral millionsof particles.CitationIf you use SiSyPHE in a research paper, please cite theJOSS publication:@article{Diez2021,
  doi = {10.21105/joss.03653},
  url = {https://doi.org/10.21105/joss.03653},
  year = {2021},
  publisher = {The Open Journal},
  volume = {6},
  number = {65},
  pages = {3653},
  author = {Antoine Diez},
  title = {`SiSyPHE`: A Python package for the Simulation of Systems of interacting mean-field Particles with High Efficiency},
  journal = {Journal of Open Source Software}
}Diez, A., (2021). SiSyPHE: A Python package for the Simulation of Systems of interacting mean-field Particles with High Efficiency. Journal of Open Source Software, 6(65), 3653,https://doi.org/10.21105/joss.03653InstallationRequirementsPython 3with packagesNumPyandSciPyPyTorch: version>= 1.5PyKeops: version>= 1.5Using pipIn a terminal, type:pip install sisypheOn Google ColabThe easiest way to get a working version of SiSyPHE is to use the free virtual machines provided byGoogle Colab.On a new Colab notebook, navigate to Edit→Notebook Settings and select GPU from the Hardware Accelerator drop-down.Install PyKeops with the Colab specificationsfirstby typing!pip install pykeops[colab]Install SiSyPHE by typing!pip install sisypheTesting the installationIn a Python terminal, typeimportsisyphesisyphe.test_sisyphe()ContributingContributions to make SiSyPHE grow are warmly welcome! Examples of possible (and ongoing) developments include the following.The implementation of new models.The implementation of more complex boundary conditions and of models onnon-flatmanifolds.An improved visualization method (currently only basic visualization functions relying onMatplotlibare implemented).Contributions can be made by opening an issue on the GitHub repository, via a pull request or by contacting directly the author.AuthorAntoine Diez, Imperial College LondonAcknowledgmentsThe development of this library would not have been possible without the help ofJean Feydy, his constant support and precious advice. This project was initiated byPierre Degondand has grown out of many discussions with him.
Package: sisyphus-control
Control yourSisyphus Kinetic Art Tablefrom Python 3.6 withasyncio!This initial release is mainly targeting the functionality needed for basic integrations with home automation systems such asHome Assistant:Status queries (playing/paused/current playlist/current/track/brightness/speed)Play controls (play/pause/shuffle/loop/set playlist/set track)Table controls (movement speed, LED brightness)Usage exampleFinding tables on your networkTo find the IP addresses of all tables on your local network. This is a very naive search; it assumes your subnet
mask is255.255.255.0:from sisyphus_control import Table

ip_addrs = await Table.find_table_ips()Once you know the IP address, connect to the table:async with await Table.connect(ip_addr) as Table:
  # Do stuff hereChange notificationsRegister for state change notifications:table.add_listener(my_listener)Basic controlsIn addition to a bunch of properties for querying the current state of the table,Tablehas several methods that
allow simple control:await table.set_brightness(1.0)  # Set maximum LED brightness
await table.set_speed(0.5)  # Set half speed
await table.play()  # Resume playing (if not already playing)Working with playlists and tracksPlaylistandTrackobjects represent playlists and tracks, respectively. The following code will start playing
the Default Playlist, beginning at the track named “Hep” (note that neither playlists nor tracks are required to be
uniquely named):default_playlist = table.get_playlists_named("Default Playlist")[0]
hep_track = default_playlist.get_tracks_named("Hep")[0]
await hep_track.play()Future opportunitiesThe following features would be reasonable to include; I’ll happily accept pull requests:Playlist editingUpload tracks to tableTrack thumbnail renderingTable administration (wifi settings, etc.)Interactions with Sisyphus cloud
Package: sit-calc-rileycworstell
AboutThis is a simple application which allows you to use the function and calculate (roughly) what you income taxes should be.
This is for other developers who want a function to quickly calculate state income tax based on their state and income.
This information should be used for FUN only, I am not an accountant :).How to use this?As a Function you can:
With the states_itax.py and tax_dict.py in your repository:import states_income_tax as sisi.calculate_itaxes(700, 'AL')How the Data was Compiled.I got the data from this project onhttps://taxfoundation.org/facts-and-figures-2020/Then I converted the exel document to a CSV file.
Then I developed and ran the pycsv.py file included in the document and took the printed result and set that as a dictionary stored
in the tax_dict.py file.How this works!This dictionary (in tax_dict.py) allows the main function in states_income_tax/init.py to take your income and state and give you your estimated state income tax.TestingThe testing is currently in tests/test_states.py. As time goes I am working on adding new tests in there.
Package: sitcom
Sitcom Python PackageThesitcomPython package is a collection of utilities designed to quickly analyze some properties of coronal dynamics.SiRGraF Integrated Tool for Coronal dynaMics (SITCoM) is based on Simple Radial Gradient Filter (SiRGraF) used to filter the radial gradient in the white-light coronagraph images and bring out dynamic structures. SITCoM has been developed in Python and integrated with SunPy which enables the user to pass the white-light coronagraph data to the tool and generate radially filtered output with an option to save in various formats as required. The outputs can be viewed in Cartesian and polar coordinate systems. We have implemented the functionality of tracking the transients such as coronal mass ejections (CMEs), outflows, plasma blobs etc. using height-time plots and derive their kinematics. In addition, SITCoM also supports oscillation and waves studies such as for streamer waves. This is done by creating a distance-time plot at a user-defined location (artificial slice) and fitting a sinusoidal function to derive the properties: of time period, amplitude, and damping (if any) which could be used for seismology. We provide the provision to manually or automatically select the data points to be used for fitting.InstallationYou can install thesitcompackage using pip:pip install sitcomFor Linux users, existence of the "xcb" library is essential. That can be installed with :sudo apt-get install libxcb-xinerama0UsageThesitcompackage currently can be used by typing the following in the terminal:python3 -m sitcomContributingIf you'd like to contribute to thesitcompackage, please email us on the provided email addresses.LicenseThesitcompackage is released under the MIT License. See the LICENSE file for more information.
Package: sitcom-simulator
Sitcom SimulatorA highly-customizable tool that automatically creates AI-generated meme videospip install sitcom-simulatorDocumentationView the documentationfor setup instructions and code samples.Example VideosAndseveral hundred more.FeaturesAI-generated scriptsAI-generated imagesDeepfaked character voicesAutomatic background music finderLimitless customizability(coming soon)Automatic YouTube uploadingUsageSitcom Simulator is designed to be simple to use, but also supports extreme customizability for power users who know exactly what they want. Sitcom Simulator can be used from the command line or can be imported in Python scripts.Command LineThe most basic usage is simply running thesitcom-simulatorcommand with no arguments. Many optional arguments are supported as well. Note that you mustset your API key environment variablesbefore it will work.sitcom-simulator--prompt"Elon Musk teleports a toaster into the ocean"--style"beautiful renaissance oil painting"PythonSitcom Simulator can also be imported in Python scripts:fromsitcom_simulatorimportcreate_sitcom# generate a short meme video and save it in the project foldercreate_sitcom(prompt="Mario hits Luigi with a stapler",)How it WorksSitcom Simulator is essentially duct tape that combines multiple different AI tools into one unholy abomination.ChatGPTgenerates the video scriptFakeYougenerates voices for the charactersStable Diffusiongenerates images for the charactersFreepdprovides the background musicFFmpegconnects the images and voices into a movieContributionsWant to help work on this project? I'm down!Contact meif you want to contribute or have any questions :)Have fun!!!LinksDocumentationWeb App (coming soon)
Package: site24x7-openai-observability
Site24x7 OpenAI ObservabilityInstructions to add Site24x7 OpenAI ObservabilityInstall the site24x7-openai module using the following command:pip install site24x7-openai-observability --upgradeNote: If you are using a virtual environment, activate it and run the above command to install the site24x7-openai-observability package into your virtual environment.Configure the license key, sample factor, and capture openai text using environment variables.$ export SITE24X7_LICENSE_KEY=<your site24x7 license key>
 $ export SITE24X7_SAMPLING_FACTOR=<set sampling factor by default 10>
 $ export SITE24X7_CAPTURE_OPENAI_TEXT=<set value by default True>Add the below code to your application's start file to integrate the observability agent:import site24x7_openai_observability
Package: site-analysis
site-analysissite-analysisis a Python module for analysing molecular dynamics simulations of solid-state ion transport, by assigning positions of mobile ions to specific “sites” within the host structure.The code is built on top ofpymatgenand takes VASP XDATCAR files as molecular dynamics trajectory inputs.The code can use the following definitions for assigning mobile ions to sites:Spherical cutoff: Atoms occupy a site if they lie within a spherical cutoff from a fixed position.Voronoi decomposition: Atoms are assigned to sites based on a Voronoi decomposition of the lattice into discrete volumes.Polyhedral decomposition: Atoms are assigned to sites based on occupation of polyhedra defined by the instantaneous positions of lattice atoms.InstallationFrom PyPI:pip install site-analysisOr clone the latest development version fromGitHuband installgit clone git@github.com:bjmorgan/site-analysis.git
cd site-analysis
python setup.py installAlternatively you can install the latest version usingpip, direct from GitHub, e.g.pip3 install git+https://github.com/bjmorgan/site-analysis.gitDocumentationDocumentation and tutorials live atRead the Docs.Example notebooks are also available ofGitHub.TestsAutomated testing of the latest build happenshere.Manual tests can be run usingpython3 -m unittest discoverThe code has been tested with Python versions 3.6 and above.
Package: sitechantment
Check a site for spelling errors in a way that can be integrated with your testingWhy?I wanted a way to add spellchecking to a suite of tests for a Flask-based
site.  I saw some windows tools, using a combination of lynx/curl/wget and
i/a/hunspell.But I just want a way to get a +/- test and a list of misspelled words.HowSo sitechantment is a command line utility to do just that.  You can pass it a url
to crawl, an optional additional list of words, language, etc.  It will crawl the
site (not wandering off to another host/port) spellcheck every page and give you a
list of words that are “misspelled”.You have the ability to run with a –update flag to automatically add all words to
a personal word list so they aren’t flagged on the next run.It is also available as a class sitechantment.SiteCheck, that can be used inside a
test suite.  You can even pass it a flask test client instead of using requests
and be able to crawl a site inside of py.test or whatever is being used to unit
test a flask application.  (Really anything can be used as long as it supports
handling uri’s with a get() method).DocumentationThe full documentation is athttp://sitechantment.rtfd.org.History0.1.0 (2015-07-18)First release on PyPI.
Package: site-cloner
Site ClonerA simple tool to clone a websiteThis tool is for educational purposes only.Please follow the copyright 
    laws of your country. Our team is not responsible for any misuse.Installationgitclonehttps://github.com/Py-Contributors/site-clonercdsite-cloner
pipinstall-rrequirements.txtUsagefromsite_clonerimportSiteClonersc=SiteCloner("https://codeperfectplus.herokuapp.com/")sc.clone_website()Upcoming FeaturesAdd Support for download multiple pages(v1.0.0)Add Support for downloading images(v1.0.0)\Pip Package SupportAdd support for cloning websites with loginChangelog0.0.1Initial ReleaseImplemented basic functionalityImplemented downloading of imagesImplemented downloading of multiple pagesPip Package SupportContributors