Saravanan666/pypi-org huggingface dataset:
Package: schug
SchugSchug :stew: is a service that gather data about genes, transcripts and exons from multiple sources and merge the
information. There is aREST APIwith relevant endpoints.Test the app using DockerYou can test Schug on your local computer using Docker. Make sure you haveDockerinstalled and type the following commands in a terminal window:git clone https://github.com/Clinical-Genomics/schug
cd schug
docker-compose upThen the app endpoints should be listed available at the following addresshttp://localhost:8000/docsThe command to stop the demo isdocker-compose down.Installation (development)Make surepoetryis installedgit clone https://github.com/Clinical-Genomics/schug
cd schug
poetry install
schug serve --reloadGo tohttp://localhost:8000/docsand check out the API.Ready-to-use endpointsOnce having set up an instance of Schug, you can use the following endpoints:/genes/ensembl_genes/Downloads genes from Ensembl in text format. Specify a genome build by using the parameters37or38.Usage:curl -X 'GET' 'http://0.0.0.0:8000/genes/ensembl_genes/?build=38' > genes_GRCh38.txt/transcripts/ensembl_transcripts/Downloads gene transcripts from Ensembl in text format. Specify a genome build by using the parameters37or38.Usage:curl -X 'GET' 'http://0.0.0.0:8000/transcripts/ensembl_transcripts/?build=38' > transcripts_GRCh38.txt/exons/ensembl_exons/Downloads gene exons from Ensembl in text format. Specify a genome build by using the parameters37or38.Usage:curl -X 'GET' 'http://0.0.0.0:8000/exons/ensembl_exons/?build=38' > exons_GRCh38.txtWhat is left to do?The basic structure is outlined and implemented, however there are many details left to implement before
this can be used.
Some of the basic endpoints are in place but these need to be extended according to the needs of the
users. Also the gene information needs to be completed, this will be done in a similar fashion as inScout.
Package: schul-cloud-url-crawler
This crawler fetches ressources from urls and posts them to a server.PurposeThe purpose of this crawler is:We can provide test data to the API.It can crawl ressources which are not active and cannot post.Other crawl services can use this crawler to upload their conversions.It has the full crawler logic but does not transform into other formats.Maybe we can create recommendations or a library for crawlers from this case.RequirementsThe crawler should work as follows:Provide urlsas command line argumentsas a link to a file with one url per lineProvideressourcesas one ressource in a fileas a list of ressourcesThe crawler must be invoked to crawl.ExampleThis example gets a ressource from the url and post it to the api.python3-mressource_url_crawlerhttp://localhost:8080\https://raw.githubusercontent.com/schul-cloud/ressources-api-v1/master/schemas/ressource/examples/valid/example-website.jsonAuthenticationYou can specify theauthenticationlike this:--basic=username:passwordfor basic authentication--apikey=apikeyfor api key authenticationFurther RequirementsThe crawler does not post ressources twice.This can be implemented bycaching the ressources locally, to see if they changedcompare ressourcecompare timestampremoving the ressources from the database if they are updated after posting new ressources.This may require some form of state for the crawler.
The state could be added to the ressources in aX-Ressources-Url-Crawler-Sourcefield.
This allows local caching and requires getting the objects from the database.
Package: schulich-ignite
sparkJupyter Lab ipython extension used for teaching theSchulich Ignite sessions.Table of contentsDocumentationFilesBuildingTesting locallyDocumentationTheuser documentationis built using mkdocs. To build locally you will need to pip install:mkdocsmkdocs-materialDeveloper documentation can be found inCONTRIBUTING.md.FilesAll the files are built in pure markdown and can be found in/docs, the site configuration (including nav links) can be found inmkdocs.yml.BuildingTo build a local copy runmkdocs --serveand you will have a local copy available athttps://localhost/8000A release will build every time new code is pushed to the gh-pages branch, but can also be manually triggered via github actions pipelinesTesting locallyInstall NodeJS using one of the methods below:If on Windows, you can download binaries fromtheir website, or install using a package manager such as choco.If on Linux/Mac, run the following:sudoapt-getinstallnodejsOr if using Conda, run the following:condainstall-cconda-forgenodejsNext, you must install the required jupyter lab extensionsjupyterlabextensioninstall@jupyter-widgets/jupyterlab-manageripycanvasipyeventsNow, either clone the repo and install a development version, or install the up-to-date version from PyPI# Cloning and installing this repogitclonegit@github.com:Schulich-Ignite/spark.git
pipinstall-espark# Or, install latest version from PyPIpipinstall--upgradeschulich-igniteFinally, you can open JupyterLab and navigate to the test folder, and run any of the ipynb files.
Package: schulplots
schulplots - a tool for generating 2D plots in "German school style"schulplotsallows you to create 2D graphs of functions that look like what students are familiar with.The figure is described using a description file that is converted into a visual representation byschulplots.ExampleThis image is generated by the following description in YAML format:figure:height:8cmwidth:10cmaxes_descriptors:-axes:height:6cmwidth:8cmx_min:-3y_min:-2bottom:1cmleft:1cmgraphs:-function:sin(x)label:$\sin(x)$areas:-function:-sin(x)-0*xlabel:$A = \int_0^\pi \sin(x)\,dx$condition:y1 >= y2plot_args:alpha:0.3color:redThe description file has main sections:figure: This section contains information about the entire figure. In the example, it specifies the height and width of the figure.axes_descriptors: This section contains a description of axis systems and graphs/areas to be plotted within these axis systems.It is also possible to draw multiple axis systems with multiple graphs:Installationschulplotsrequires a recent version of Python. If you have Python installed (including pip, the python package manager), you can install it  fromPyPiwithpip install schulplots.Run from ColabYou can use schulplots without installation directly in Google Colab. For an example, clickhere.DocumentationYou can find detailed documentationhere(sorry, German only for now).LimitationsThe tool is limited to plotting function graphs in "typical" value ranges. It is intentionally not a comprehensive plotting tool for scientific purposes.The tool was specifically developed for the conventions commonly used in the German-speaking region for function graphs (axes at the zero line, arrows in the positive direction, squared paper with a 5mm grid, etc.).It is not a tool for changing graph parameters through a graphical user interface (GUI).
Package: schumacher
SchumacherOCRБиблиотека предоставляет модули для работы с изображениями в педагогическихУстановкаpipinstallSchumacherOCRРабота с изображениемВыделение иллюстраций и аннотацийfromSchumacher.OcrimportProcessorProcessorРабота с документом или книгойfromSchumacher.OcrimportProcessorProcessorДатасетыДля оценки качества моделирования вы можете использовать уже размеченный датасет с аhttps://huggingface.co/datasets/NMashalov/ru_educational_book_datasetsОбучениеРазметка вLabel Studio.Для разметки репозиторий необходимо склонировать и установитьdockerдля вашей операционной системыДля клонирования выполнитеgit cloneДалее следуетеРазработкаСопровождающая статья с описаниемстатьяПубликация репозитория на pypi выполняется через Github Actions
Package: schwab-py
schwab-py: A Schwab API Wrapperschwab-apiBackgroundIn 2020, Charles Schwab completed its purchase of TDAmeritrade. Prior to this
purchase, TDAmeritrade operated (in the author’s personal opinion) the most
high-quality, accessible, and cost effective trading API. It offers developers
access to their TDAmeritrade accounts, trading in equities, ETFs, and options,
plus a wide range of historical data.Since this purchase, Schwab has begun to transition TDAmeritrade customers onto
their own service. In late 2022, the announced the TDAmeritrade REST API will be
included in this transition, which will happen over the course of 2023.What isschwab-api?The author of this repo (Alex Golec) had previous authoredtda-api, an
unofficial python wrapper around the previous TDAmeritrade API. This library is
currently the most popular method of accessing this API, with a community of
hundreds of active users on our Discord server.While the details of the forthcoming Schwab API have not yet been announced,
this repository serves as a placeholder for a python wrapper around it. It
currently has no functionality. Stay tuned for updates as they become available.Disclaimer:schwab-api is an unofficial API wrapper. It is in no way
endorsed by or affiliated with TD Ameritrade, Charles Schwab or any associated
organization. Make sure to read and understand the terms of service of the
underlying API before using this package. The authors accept no responsibility
for any damage that might stem from use of this package. See the LICENSE file
for more details.
Package: schwicv
SchwiCVInstallationYou can install the SchwiCV Tools fromPyPI:pip install schwicvThe package is supported on Python 3.6 and above.How to useTimer Libfrom schwicv import Timer

tmr = Timer(0.1)        # Makes Instance of Timer class with 0.1 seconds init time
tmr.remaining_time      # Output of remaining time in seconds
tmr.remaining_time_ms   # Output of remaining time in milliseconds
tmr.execution_time      # Output of execution time since last start in seconds
tmr.execution_time_ms   # Output of execution time since last start in milliseconds
tmr.time_stamp          # Output of actual time stamp as datetime
tmr.time_stamp_str      # Output of actual time stamp yearmonthday-hhmmss-Âµs example: 20210708-075514-612456
tmr.remaining_percent   # Output of remaining time in percent
tmr.time_over           # True if code needed more or equal 0.1 seconds
tmr.restart()           # Restarts the timer with previous init time

tmr.start(1)            # Restart timer with 1 second init time, if re-use instance
Package: schwifty
Gotta get schwifty with your IBANsschwiftyis a Python library that let’s you easily work with IBANs and BICs
as specified by the ISO. IBAN is the Internation Bank Account Number and BIC
the Business Identifier Code. Both are used for international money transfer.Featuresschwiftylets youvalidatecheck-digits and the country specific format of IBANsvalidateformat and country codes from BICsgenerateBICs from country and bank-codegenerateIBANs from country-code, bank-code and account-number.get the BIC associated to an IBAN’s bank-codeaccess all relevant components as attributesSee thedocsfor more inforamtion.VersioningSince the IBAN specification and the mapping from BIC to bank_code is updated from time to time,schwiftyusesCalVerfor versioning with the schemeYY.0M.Micro.InstallationTo installschwifty, simply:$pipinstallschwiftyDevelopmentWe use theblackas code formatter. This avoids discussions about style preferences in the same
way asgofmtdoes the job for Golang. The conformance to the formatting rules is checked in the
CI pipeline, so that it is recommendable to install the configuredpre-commit-hook, in order to
avoid long feedback-cycles.$pre-commitinstallYou can also use thefmtMakefile-target to format the code or use one of the availableeditor
integrations.Project Informationschwiftyis released underMITlicense and its documentation lives atRead the Docs. The
code is maintained onGitHuband packages are distributed onPyPINameSinceswiftandswiftlywere already taken by the OpenStack-project, but we somehow wanted
to point out the connection to SWIFT, Rick and Morty came up with the idea to name the projectschwifty.
Package: schwimmbad
schwimmbadprovides a uniform interface to parallel processing pools
and enables switching easily between local development (e.g., serial processing
or withmultiprocessing) and deployment on a cluster or supercomputer
(via, e.g., MPI or JobLib).InstallationThe easiest way to install is viapip:pip install schwimmbadSee theinstallation
instructionsin thedocumentationfor more information.DocumentationThe documentation forschwimmbadis hosted onRead the docs.AttributionIf you use this software in a scientific publication, please cite theJOSSarticle:@article{schwimmbad,
  doi ={10.21105/joss.00357},
  url ={https://doi.org/10.21105/joss.00357},
  year  ={2017},
  month ={sep},
  publisher ={The Open Journal},
  volume ={2},
  number ={17},
  author ={Adrian M. Price-Whelan and Daniel Foreman-Mackey},
  title ={schwimmbad: A uniform interface to parallel processing pools in Python},
  journal ={The Journal of Open Source Software}}LicenseCopyright 2016-2021 the contributors.schwimmbad is free software made available under the MIT License. For details
see the LICENSE file.
Package: schwurbler
Mangle strings by repeated Google TranslateDescriptionThis module offers functions to destroy text by feeding it through multiple
languages in Google Translate.InstallationThe project is available on PyPI, so simply invoke the following to install the
package:pip install schwurblerUsageSchwurbler’s functions are contained in theschwurblerpackage, so simply
import it:importschwurblerThe two main functions are fixed path schwurbles and set ratio schwurbles. The
former translates text through a fixed set of languages and the latter randomly
picks languages to translate a string through until it only resembles the
original by a certain token set ratio:importschwurblertranslated=schwurbler.path_schwurbel(['en','ja','en'],'Hello world!')translates=schwurbler.set_ratio_schwurbel('Hello world!','en',ratio=50)More information on the usage can be found in theAPI reference.
Package: sci
A Python 3 package or simply a collection of convenience and wrapper functions supporting tasks
frequently needed by scientists.installpip3 install sciorpip3 install--user--upgradesciuse the--userflag on shared computers where you do not have root access. It will install the
package in a place like~/.local/lib/python3.x/site-packages/sci. You can delete that folder
later to remove the package.design goalsSimplicity: wrap frequently used workflows into simple functions that make life easier for
scientists. Most import statements should move into functions (except for frequently used ones
like os, sys) to avoid confusion during autocomplete with VS Code and other IDEs.Verbose but easily consumable docstrings: Docstrings are accessible via code autocomplete in IDEs
such as VS Code or Atom and through automated documentation environments such as sphinx. Each
docsting should start with an example use case for the function.functional programming paradigm: While using classes is permitted we encourage writing fewer
classes and more functions (perhaps with decorators)Cross-platform: The code should work on Linux (RHEL and Debian based), Windows and Mac OS X.Python 3 only compatibility, Python 2.x is legacy and we do not want to invest any extra time in
it.How to contribute your own codegit clonegit@github.com:FredHutch/sci-pkg.gitcreate a new branch (eg : sci-yourname)paste your function into module sci/new.py.Make sure you add an example call in the first line of the doc string.Add your test case to sci-pkg/sci/tests
Package: sci2pdf
Descriptionsci2pdf is a module ofbibcureDownloads pdfs via a DOI number, article title or a bibtex file, using
the database of libgen(sci-hub).Install$ sudo pip install sci2pdfFeatures and how to useGiven a bibtex file$ sci2pdf -i input.bibGiven a DOI number…$ sci2pdf 10.1038/s41524-017-0032-0Given a title…$ sci2bib --title An useful paperLocation folder as argument$ sci2pdf -i input.bib -l somefoler/
Package: sci4all
# Sci4All – scientific toolbox for high school and higher educationSci4All is a scientific toolbox for high school and higher education.Sci4All builds on scipy with the aim to deliver simple, expressive and
intuitive interfaces for various operations, intended to be appropriate for
interactive use in tools such as Jupyter Notebook. The library aims to offer
interfaces that are effective and powerful, yet simple to use.Key objectives of Sci4All are:It should be easy to use with a natural and intuitive API, in
a way that makes it suitable for non-programmers at the high school level.It should prepare students for using scientific tools in higher education.
Interfaces should be kept simple, but not at the expense of over-simplifying
or “dumbing down” the tools.It should build on and provide access to strong lower level scientific
tools, methodologies and algorithmic programming, within an environment that
is suitable for continued use by students in further higher education studies
and academic workThough the main target audience for the toolbox is high school students,
when possible it should aim to design interfaces that are also appropriate
for use in research and higher education, offering more convenient, intuitive
or terse access to functionality in libraries that Sci4All builds on.Sci4All provides friendly, expressive and intuitive interfaces to some
capabilities of modules such as SciPy and Matplotlib, thus making certain
scientific functionality of those modules accessible to non-programmers.
However, the full power of those modules as well as the Python programming are
still available, allowing students to gradually adopt more advanced use of
those libraries and as their skills grow.By offering Sci4All for scientific work at the high school level, our hope
is that students will have access to a set of tools that are not only
appropriate for their current educational level, but also provide experience
with a proper modern programming language (python), enable methodologies and
work habits appropriate for higher level scientific work, and offer hands-on
experience with an ecosystem of open source tools that can also serve their
future needs.# Sci4All licenseSci4All is released under the [GNU Lesser General Public License
v3.0](https://www.gnu.org/licenses/lgpl-3.0-standalone.html) or later. License
details are included with the library source code.# InstallingOnce released, the library with source code can be installed from
[PyPI](https://pypi.org/), and can also be downloaded from the
[Sci4All website](https://www.sci4all.org).# Getting information about Sci4AllInformation will be available at the
[Sci4All website](https://www.sci4all.org).# Project statusThe project is in early development and will be released as a pre-alpha
in near future. Stay tuned …
Package: scia
sciaPython logging extension - crogeo.orgInstallationFrom sourcesgitclonehttps://github.com/crogeo/scia.gitcdscia
pipinstall.From PyPipipinstallsciaDocumentationConfig file: log.ini[loggers]keys=root,daily[handlers]keys=console,daily[formatters]keys=fmt[logger_root]level=INFOhandlers=consolequalname=rootpropagate=0[logger_daily]level=DEBUGhandlers=console,dailyqualname=%(project)spropagate=0[handler_daily]class=scia.handlers.TimedRotatingFileHandlerlevel=DEBUGformatter=fmtargs=('logs/%(project)s.log', 'midnight')[handler_console]class=StreamHandlerlevel=DEBUGformatter=fmtargs=(sys.stdout,)[formatter_fmt]format=%(asctime)s - %(name)10s - %(levelname)8s - %(message)sUsagefromsciaimportget_loggerlog=get_logger('myproject')log.debug('Debug message')log.info('Info message')log.warning('Warning message')log.error('Error message')Project name configurationfromsciaimportconfigconfig.project='myproject'# The logger name and the filename: logs/myproject.logconfig.inifile='log.ini'# Configuration fileLicenseCrogeo scia isMIT licensed.
Package: sciagraph
Sciagraph: the performance and memory profiler for Python data processingWhether it's detecting disease, modeling the electric grid, or whatever data processing you do with Python, inefficient code is a cost you can't afford to pay:If it takes 30 minutes for your code to run, debugging minor changes can waste your whole afternoon.If your program runs out of memory—it's dead, and you're not getting any results until you fix that.Once you're running in production at scale, inefficient software means throwing money at your cloud provider.
You probably need that money more than they do.On the other hand, the faster your software, the easier it will be for you to iterate and improve.
And the faster your software, the happier your users (and accountant) will be.That's where profilers come in: tools that will help you find speed and memory bottlenecks in your code, so that instead of guessing, you can quickly fix the problem.
Unfortunately, profilers that work well for web applications don't necessary work as well when it comes to data processing.
You need a profiler designed foryourkind of software.Sciagraph is a profiler that gives you deep visibility into your Python code's speed and memory usage—with a focus on data science, scientific computing, and data processing.It's designed specifically for the needs of people like you, from measurements to visualizations to integrations (Jupyter, MLFlow, Celery, and more.)Learn more athttps://sciagraph.com.
Package: sci-analysis
sci-analysisAn easy to use and powerful python-based data exploration and analysis toolCurrent Version:2.2 --- Released January 5, 2019What is sci-analysis?sci-analysis is a python package for quickly performing statistical data analysis. It provides a graphical representation of the supplied data as well as the statistical analysis. sci-analysis is smart enough to determine the correct analysis and tests to perform based on the shape of the data you provide, as well as how the data is distributed.The types of analysis that can be performed are histograms of numeric or categorical data, bi-variate analysis of two numeric data vectors, and one-way analysis of variance.What's new in sci-analysis version 2.2?Version 2.2 adds the ability to add data labels to scatter plots.The default behavior of the histogram and statistics was changed from assuming a sample, to assuming a population.Fixed a bug involving the Mann Whitney U test, where the minimum size was set incorrectly.Verified compatibility with python 3.7.Getting started with sci-analysisThe documentation on how to install and use sci-analysis can be found here:http://sci-analysis.readthedocs.io/en/latest/RequirementsPackages: pandas, numpy, scipy, matplotlib, sixSupports python 2.7, 3.5, 3.6, and 3.7Bugs can be reported here:https://github.com/cmmorrow/sci-analysis/issues
Package: scian-ciiu
SCIAN-CIIUA library to search the corresponding mexican scian/ciiu given an input parameterHow to useAfter installing the package use following import:from scian_ciiu import scian_id_to_ciiu, scian_string_to_ciiu, ciiu_id_to_scian, ciiu_string_to_scianThen use following commands:scian_id = "111219"result_dict = scian_id_to_ciiu(scian_id)Or:scian_string = "Cultivo"result_dict = scian_string_to_ciiu(scian_string)Or:ciiu_id = "0111"result_dict = ciiu_id_to_scian(ciiu_id)Or:ciiu_string = "Cultivo"result_dict = ciiu_string_to_scian(ciiu_string)