Saravanan666/pypi-org huggingface dataset:
Package: pyscaffoldext-beeproject
pyscaffoldext-beeprojectPyScaffoldextension tailored for my own simple structured projects. This extension is powered bypyscaffoldext-dsprojectThe final directory structure looks like:Project_Dir
├── AUTHORS.rst             <- List of developers and maintainers.
├── CHANGELOG.rst           <- Changelog to keep track of new features and fixes.
├── LICENSE.txt             <- License as chosen on the command-line.
├── README.md               <- The top-level README for developers.
├── data
├── docs                    <- Directory for Sphinx documentation in rst or md.
├── models                  <- Trained and serialized models, model predictions,
│                              or model summaries.
├── notebooks               <- Jupyter notebooks. Naming convention is a number (for
│                              ordering), the creator's initials and a description,
│                              e.g. `1.0-fw-initial-data-exploration`.
├── reports                 <- Generated analysis as HTML, PDF, LaTeX, etc.
│   └── figures             <- Generated plots and figures for reports.
├── src
│   └── Project_Name        <- Actual Python project which can be deploy to production
│       └── environment.yaml                <- Actual Python project need conda environment yaml file
│       └── run_python_project_main.py      <- Actual Python project some one part main execute script
│       └── supervisor_project_main.ini     <- Actual Python project some one part main script supervisor ini template file
│       └── project_name                    <- Actual Python project some one package template
│       └── __init__.py                     <- Use for sphinx auto documents
├── tests                   <- Unit tests which can be run with `py.test`.UsageJust install this package withpip install pyscaffoldext-beeprojectand note thatputup -hshows a new option--beeproject.
Creating a data science project is then as easy as:putup --beeproject Simple_ProjectNoteThis project has been set up using PyScaffold 3.2. For details and usage
information on PyScaffold seehttps://pyscaffold.org/.
Package: pyscaffoldext-custom-extension
pyscaffoldext-custom-extensionPyScaffold extension that lets you create your own custom extensions.DescriptionThis extension serves as a support for the users interested in developing their own extension for PyScaffold.
It configures your project so that you can start writing your extension logic and tests right away,
taking care of all the wiring required to conform to PyScaffold’s needs.Let’s say you want to create an extension namednotebooksthat creates a notebooks folder with some templateJupyter notebook.
After having installed this extension with:pip install pyscaffoldext-custom-extensionyou will be able to just use it with:putup --custom-extension notebooksThis will create a typical PyScaffold project template with some modifications:the topmost namespace will bepyscaffoldextto have a unified namespace for PyScaffold extensions,assures that the package (aspip/PyPIsees it) is namedpyscaffoldext-notebooksinsetup.cfg,sets the correctinstall_requiresas well as theoptions.entry_pointsparameters insetup.cfg,automatically activates the extensions--no-skeleton,--pre-commit,--cirrusand
since we want clean-coded, high-quality extensions,creates aextension.pymodule holding a class which serves you as a template for your extension,adds basic unit tests checking that the invocation of your extension works and that it complies with ourflake8code guidelines,provides a modifiedREADME.rstindicating that this is a PyScaffold extensions and how to install it.Making Changes & ContributingThis project usespre-commit, please make sure to install it before making any
changes:pip install pre-commit
cd pyscaffoldext-custom-extension
pre-commit installIt is a good idea to update the hooks to the latest version:pre-commit autoupdatePlease also check PyScaffold’scontribution guidelines,NoteFor more information about PyScaffold and its extension mechanism, check outhttps://pyscaffold.org/.
Package: pyscaffoldext-markdown
pyscaffoldext-markdownPyScaffoldextension which replacesreStructuredTextformatted files
byMarkdownformat (with the help ofMyST) except forSphinx-related files.UsageJust install this package with eitherpip install pyscaffoldext-markdownorconda install -c conda-forge pyscaffoldext-markdownand note thatputup -hshows a new option--markdown.
Basically this extension will replaceREADME.rstby a properREADME.mdand
activate the support of Markdown files in Sphinx.Building and ReleasingBy default, thetoxconfiguration generated byPyScaffoldis compatible
with Markdown (as implemented in this extension). This means that (after
installingtoxwithpiporpipx) you can run:tox-edocs# to build your documentationtox-ebuild# to build your package distributiontox-epublish# to test your project uploads correctly in test.pypi.orgtox-epublish----repositorypypi# to release your package to PyPItox-av# to list all the tasks availablePlease remember that the commandpython setup.py releaseis no longer
recommended, so if you don't liketox, please consider usingSphinxandtwinedirectly:python-mpipinstall-Upipsetuptoolswheelsphinxtwine
pythonsetup.pybdist_wheel# to build your package distributionsmake-Cdocshtml# to build your docstwineuploaddist/*# to release your package to PyPIMaking Changes & ContributingThis project usespre-commit, please make sure to install it before making any
changes:pipinstallpre-commitcdpyscaffoldext-markdown
pre-commitinstallIt is a good idea to update the hooks to the latest version:pre-commitautoupdatePlease also check PyScaffold'scontribution guidelines.NoteThis project has been set up using PyScaffold 4.0. For details and usage
information on PyScaffold seehttps://pyscaffold.org/.
Package: pyscaffoldext-nox
Nox for pyscaffold.UsageJust install this package withpip install ${project}and note thatputup-hshows a new option--nox. Use this flag to use nox for your next project.This project was inspired bySarthakJariwala’s pyscaffold nox extensionand their efforts to create a pyscaffoldext-nox plugin. See more infohere.Making Changes & ContributingThis project usespre-commit, please make sure to install it before making any
changes:pip install pre-commit
cd pyscaffoldext-nox
pre-commit installIt is a good idea to update the hooks to the latest version:pre-commit autoupdateDon’t forget to tell your contributors to also install and use pre-commit.NoteThis project has been set up using PyScaffold 4.2.2. For details and usage
information on PyScaffold seehttps://pyscaffold.org/.
Package: pyscaffoldext-pyproject
pyscaffoldext-pyprojectThis is a simple PyScaffold extension which serves as a blueprint.
It’s sole purpose is to create apyproject.tomlfile according to[PEP 518].
This extension was bootstrapped with PyScaffold’scustom-extension:putup pyscaffoldext-pyproject --custom-extensionRead more about creating an extension underhttp://pyscaffold.org/.UsageJust install this package withpip installpyscaffoldext-pyprojectand note thatputup-hshows a new option--pyproject.
Using this will create a defaultpyproject.toml.
Package: pyscaffoldext-travis
pyscaffoldext-travisConfigure yourPyScaffold-generated project to work withTravis CI.PyScaffoldis a development tool focused in creating distributable Python packages.
This extension automatically configures the generated packages to useTravis CI,
a very popular and maturecontinuous integrationsolution that allows devs to
test their code and perform a series of automated tasks, bringing confidence to
their workflow.LOOKING FOR CONTRIBUTORS- If you use PyScaffold or Travis CI and would
like to help us as a contributor (or even as one of the maintainers) for
this extension, please send us an email or open an issue, we would love to
have you on board.QuickstartThis extension can be directly installed withpip:pipinstallpyscaffoldext-travisOr, if you preferpipx:pipxinstallpyscaffold# if you haven't installed pyscaffold yetpipxinjectpyscaffoldpyscaffoldext-travisNote that, after the installation,putup-hwill show a new option--travis. Use this option to indicate when you are want to create a
package with automated tasks running on theTravis CIplatgorm.
For example:putup--travismyappPlease refer toTravis’ docsto get started.Making Changes & ContributingThis project usespre-commit, please make sure to install it before making any
changes:pip install pre-commit
cd pyscaffoldext-travis
pre-commit installIt is a good idea to update the hooks to the latest version:pre-commit autoupdatePlease also check PyScaffold’scontribution guidelines.NoteThis project has been set up using PyScaffold 4.0b1. For details and usage
information on PyScaffold seehttps://pyscaffold.org/.
Package: pyscaffold-interactive
An interactive Python/DataScience project template generator based onPyScaffoldInstallationRecommended (using pipx)pipx installpyscaffold-interactiveRefer topipx documentationfor information on how to get pipxAlternatively (using pip)pip installpyscaffold-interactiveUsageAs simple as :putup-interactiveDescriptionInteractively create a python package or datascience project template using PyScaffoldSetup a new python project and interactively add details like project name, author name, email, url, descriptionChoose from a selection of licensesConfigure automated testing usingtoxSetup continuous integration usingTravis-CIOption to add pre-commit file during project setupCreate DataScience projects interactively (using the same command)In addition, you get all of PyScaffold’s native commands! Just doputup--help
Package: pyscagnostics
pyscagnosticsPython wrapper for computing graph theoretic scatterplot diagnostics.Scagnostics describe various measures of interest for pairs of variables, based on their appearance on a scatterplot.  They are useful tool for discovering interesting or unusual scatterplots from a scatterplot matrix, without having to look at every individual plot.Wilkinson L., Anand, A., and Grossman, R. (2006). High-Dimensional visual analytics: Interactive exploration guided by pairwise views of point distributions. IEEE Transactions on Visualization and Computer Graphics, November/December 2006 (Vol. 12, No. 6) pp. 1363-1372.Installationpip install pyscagnosticsUsagefrompyscagnosticsimportscagnostics# Using NumPy arrays or listsmeasures,_=scagnostics(x,y)print(measures)# Using Pandas DataFrameall_measures=scagnostics(df)formeasures,_inall_measures:print(measures)Documentationdefscagnostics(*args,bins:int=50,remove_outliers:bool=True)->Tuple[dict,np.ndarray]:"""Scatterplot diagnostic (scagnostic) measuresScagnostics describe various measures of interest for pairs of variables,based on their appearance on a scatterplot.  They are useful tool fordiscovering interesting or unusual scatterplots from a scatterplot matrix,without having to look at every individual plot.Example:`scagnostics` can take an x, y pair of iterables (e.g. lists or NumPy arrays):```from pyscagnostics import scagnosticsimport numpy as np# Simulate data for examplex = np.random.uniform(0, 1, 100)y = np.random.uniform(0, 1, 100)measures, bins = scagnostics(x, y)```A Pandas DataFrame can also be passed as the singular required argument. Theoutput will be a generator of results:```from pyscagnostics import scagnosticsimport numpy as npimport pandas as pd# Simulate data for examplex = np.random.uniform(0, 1, 100)y = np.random.uniform(0, 1, 100)z = np.random.uniform(0, 1, 100)df = pd.DataFrame({'x': x,'y': y,'z': z})results = scagnostics(df)for x, y, result in results:measures, bins = resultprint(measures)```Args:*args:x, y: Lists or numpy arraysdf: A Pandas DataFramebins: Max number of bins for the hexagonal grid axisThe data are internally binned starting with a (bins x bins) hexagonal gridand re-binned with smaller bin sizes until less than 250 empty bins remain.remove_outliers: If True, will remove outliers before calculationsReturns:(measures, bins)measures is a dict with scores for each of 9 scagnostic measures.See pyscagnostics.measure_names for a list of measuresbins is a 3 x n numpy array of x-coordinates, y-coordinates, andcounts for the hex-bin grid. The x and y coordinates are re-scaledbetween 0 and 1000. This is returned for debugging and inspection purposes.If the input is a DataFrame, the output will be a generator yielding a tuples ofscagnostic results for each column pair:(x, y, (measures, bins))"""
Package: pyscal
pyscalPython tool module for relative permeability/SCAL support in reservoir simulationDocumentationhttp://equinor.github.io/pyscalFeature overviewCommand line tool for generating Eclipse input from parameters
in an XLSX- or CSV-file.API to create relative permeability curves through correlations or
tables.Consistency checks for three-phase setups, ensures compatibility of
oil-water tables and gas-oil tables.Support for handling uncertainty, doing book-keeping for low, base
and high cases, and the possiblity to interpolate between these
cases using a number from -1 to +1.Command line toolExample use with CSV input for one SATNUM:$catrelperminput.csvSATNUM, swl, sorw, Nw, Now1,      0.1, 0.05, 2, 3$pyscalrelperminput.csv--delta_s0.1-orelperm.incWritten to relperm.incwhererelperm.inccan be used directly as an INCLUDE file in Eclipse or Flow.
The same table as in the CSV above could have been in an XLSX file also.Python API usageUsing the Python API, the same curves as above can be constructed withfrompyscalimportWaterOilwo=WaterOil(h=0.1,sorw=0.05,swl=0.1)wo.add_corey_water(nw=2)wo.add_corey_oil(now=3)print(wo.SWOF())which will produce the outputSWOF---- pyscal: 0.4.1-- swirr=0 swl=0.1 swcr=0.1 sorw=0.05-- Corey krw, nw=2, krwend=1, krwmax=1-- Corey krow, now=3, kroend=1-- krw = krow @ sw=0.46670-- Zero capillary pressure-- SW     KRW       KROW      PC0.1000000 0.0000000 1.0000000 00.2000000 0.0138408 0.6869530 00.3000000 0.0553633 0.4471809 00.4000000 0.1245675 0.2709139 00.5000000 0.2214533 0.1483818 00.6000000 0.3460208 0.0698148 00.7000000 0.4982699 0.0254427 00.8000000 0.6782007 0.0054956 00.9000000 0.8858131 0.0002035 00.9500000 1.0000000 0.0000000 01.0000000 1.0000000 0.0000000 0/
Package: pyscal2
pyscal - python Structural Environment Calculator[!TIP]
Check outpyscal3, a completely new pyscal which is faster and can handle a large number of atoms, with a much more user-friendly interface.Complete documentation with examples availablehere.pyscalis a python module for the calculation of local atomic structural environments includingSteinhardt's bond orientational order parametersduring post-processing of atomistic simulation data. The core functionality of pyscal is written in C++ with python wrappers usingpybind11which allows for fast calculations with possibilities for easy expansion in python.Steinhardt's order parameters are widely used foridentification of crystal structures. They are also used to identify if an atom issolid or liquid.Installationpyscal can be installed directly using conda by the following statement-conda install -c conda-forge pyscalFrom repositorypyscal can be built from the repository by-git clone https://github.com/pyscal/pyscal.git
    cd pyscal
    python setup.py install --userCiting the workIf you use pyscal in your work, the citation of thefollowing articlewill be greatly appreciated:Sarath Menon, Grisell Díaz Leines and Jutta Rogal (2019). pyscal: A python module for structural analysis of atomic environments. Journal of Open Source Software, 4(43), 1824,https://doi.org/10.21105/joss.01824
Package: pyscal3
pyscal - python Structural Environment CalculatorComplete documentation with examples availablehere.pyscal3, a completely new pyscal which is faster and can handle a large number of atoms, with a much more user-friendly and intuitive interface. Adds more features such as more structure creation including grain boundaries, selection, and deletion of atomsInstallationpyscal3 can be installed directly using conda by the following statement-conda install -c conda-forge pyscal3From repositorypyscal can be built from the repository by-git clone https://github.com/pyscal/pyscal3.git
    cd pyscal3
    pip install .Citing the workIf you use pyscal3 in your work, the citation of thefollowing articlewill be greatly appreciated:Sarath Menon, Grisell Díaz Leines and Jutta Rogal (2019). pyscal: A python module for structural analysis of atomic environments. Journal of Open Source Software, 4(43), 1824,https://doi.org/10.21105/joss.01824Works using pyscalFor a complete list of publications which used pyscal, seehere.
Package: pyscale
General purpose Python framework for writing highly scalable applications.AboutA typical application consists of several modules. Each module has its own
process, stores a pidfile in ‘tmp/pids’, and has a logfile in ‘logs’.A RPC protocol is implemented on top of zeromq in order to allow for
inter-module communication. Modules have an auto-adjustable number of workers
in order to cope with a high number of requests. These rpc requests will block
until that module becomes available.
Read more about zeromq athttp://zguide.zeromq.org/Each module consists of several gevent greenlets. A basic module will already
contain a few greenlets that handle incoming rpc requests. You can spawn
additional greenlets for your own needs.
Read more about gevent athttp://www.gevent.org/TasksYou can manage and debug your modules using built-in tasks. Type ‘cake’ at a
bash prompt when inside your project to see available tasks and what they do.
You can also define your own taks.CommandsTo create a new project:$ pyscale new <name>To generate a new module:$ pyscale generate <name>To start, stop, debug, view logs and more check out available cake tasks:$ cake
$ cake start
$ cake stop
$ cake status
$ cake log
$ cake consoleUsageTo execute an rpc request on another module:self.sock('modname').method(*args, **kwargs)You can also use properties, and chain requests:self.sock('modname').prop.method()You can also issue requests on all available modules:self.multisock('*').method()To spawn another greenlet in a module either use the ‘job’ decorator or:self.jobs.spawn(func)To debug your application use logs and the console.RequirementsSystem Dependencies:zeromqatdPython Dependencies:pyzmqgeventgevent_zeromqcakeargparsejinja2nose
Package: pyscaleio
Python library that provides convenient way to interact with ScaleIO/VxFlex REST API.Supported ScaleIO/VxFlex versions: 2.0Supported Python versions: 2.6, 2.7, 3.4, 3.5, 3.6Library is under development!FeaturesCurrently supported:Simple API client with base methods according to ScaleIO/VxFlex documentationORM-like models (StoragePool, Volume, etc.)Scheme validation for API responsesTODO:HATEOAS links processingInstallationInstall viapip:$pipinstallpyscaleioInstall as RPM package usingyumordnfon Fedora/RHEL/CentOS:$dnfcoprenablemiushanov/pyaddons$dnfcoprenablemiushanov/pyscaleio$dnfinstallpython-scaleioUsageCreate and register API client:importpyscaleio# create API clientclient=pyscaleio.ScaleIOClient.from_args("gateway_address","admin","password")# register it for using in modelspyscaleio.add_client(client)Find and modify resources:# get all volumes in clustervolumes=pyscaleio.Volume.all()assertlen(volumes)==1# or, get volume by specified idvolume=pyscaleio.Volume.one_by_name("test_volume")# and access some volume attributesassertvolume.name=="test_volume"assertvolume.size==8*constants.GIGABYTE# or, resize it to new sizevolume.resize(16)volume.update()# updates model dataassertvolume.size==16*constants.GIGABYTECreate or delete resources:# create new volume in storage poolvolume=pyscaleio.Volume.create(16,"storage_pool_id","new_volume")assertvolume.name=="new_volume"assertvolume.size==16*constants.GIGABYTE# delete volumevolume=pyscaleio.Volume.one_by_name("test_volume")volume.delete()Tune client and models options:pyscaleio.configure(# retries count for each requestrequest_retries=0,# network timeout for requestsnetwork_timeout=30,# name of exported volume (according to udev/rules.d)volume_name="emc-2{system_id}{volume_id}",# prefix of exported volumevolume_prefix="/dev/disk/by-id")volume=pyscaleio.Volume.one_by_name("test_volume")assertvolume.path=="/dev/disk/by-id/emc-27947a0127a79ce60ca29f20900000008"TestsTests for this library divided to unit tests and functional tests.
Functional tests requires ScaleIO installation and available REST API Gateway service. For running functional tests usetoxenvironment with namefunctionalwith passed variables:scaleio_host- IP address or hostname of ScaleIO REST API Gatewayscaleio_user- usernamescaleio_passwd- passwordscaleio_is_secure-1for usinghttpsscheme otherwise0(optional)scaleio_trace- level of logging to stderr (optional)Example:$scaleio_host=localhostscaleio_user=adminscaleio_passwd=passwdtox-efunctional
Package: pyscales
This module provides representations for musical notes and intervals in the
basic 12-note even tempered system that is typically used in western music. It
provides basic arithmetic and conversion to and from midi numbers.Classes, Functions and DefinitionsThis module provides the following classes:Note: represents a musical noteInterval: represents the interval between two notesIt also provides the following utility functions:get_midi_number(note_string)-> midi numberin_chord(note, root, chord)-> booleanThe following intervals are predefined:P1 = unison = Interval(0)
m2 = semitone = Interval(1)
M2 = Interval(2)
m3 = Interval(3)
M3 = Interval(4)
P4 = Interval(5)
aug4 = dim5 = Interval(6)
P5 = Interval(7)
m6 = Interval(8)
M6 = Interval(9)
m7 = Interval(10)
M7 = Interval(11)
P8 = octave = Interval(12)The following chord types are predefined:MAJOR = (unison, M3, P5)
MINOR = (unison, m3, P5)
SEVENTH = (unison, M3, P5, m7)ExamplesSome examples of use:>>> Note('c') - Note('a-2')
Interval(16)
>>> Note('c') + M3
Note(64)
>>> (Note('c3') + P5).get_note_string()
'G3'
>>> in_chord(Note('c5'), Note('a'), MINOR)
True
>>> in_chord(Note('c5'), Note('a'), MAJOR)
FalseInstallingTo install pyscales, usepip install pyscales.
Package: pyscal-rdf
pyscal_rdfpyscal_rdfis a python tool for ontology-based creation, manipulation, and quering of structures.pyscal_rdfuses theComputational Material Sample Ontology (CMSO).The package is currently under activate development and could be  unstable .You can trypyscal_rdfhere:Jupyter notebookGUIInstallationSupported operating systemspyscal_rdfcan be installed on Linux and Mac OS based systems. On Windows systems, it is recommended to useWindows subsystem for Linux.Using pippip install pyscal-rdfUsing condaconda install -c conda-forge pyscal-rdfBuilding from the repositoryWe strongly recommend creating a conda environment for the installation. To see how you can install conda seehere.Once a conda distribution is available, the following steps will help set up an environment to usepyscal_rdf. First step is to clone the repository.git clone https://github.com/pyscal/pyscal_rdf.gitAfter cloning, an environment can be created from the included file-cd pyscal_rdf
conda env create -f environment.ymlThis will install the necessary packages and create an environment called rdf. It can be activated by,conda activate rdfthen, installpyscal_rdfusing,pip install .Usingpyscal_rdfComing soon..AcknowledgementsThis work is supported by theNFDI-Matwerkconsortia.