Saravanan666/pypi-org huggingface dataset:
Package: dsFrameworkTest
ds-frameworkdata science framework#how to install
pip install dsframework#how to use
##list of commands:dsf-cli - to get all cli optionsdsf-cli generate project my-new-project - to generate new project named my-new-projectinside generated project folder(cd my-new-folder)dsf-cli g forcer my-new-forcer - creating new forcer (will be automatically injected to pipeline after last exist forcer)dsf-cli g predictable my-new-predictable - creating new predictable (will be automatically injected to pipeline after last exist predictable)dsf-cli run-server - will run local server with port 8080available endpoints depend on projecthttp://localhost:8080/parse,http://localhost:8080/predictwill validate input based on input scheme and execute pipelinehttp://localhost:8080/testwill run mock test using Data science portaldsf-cli create-deploy-files - deploy files generated automatically when creating new project this is an option to create all non exist deploy files,if deploy file was deleted by mistake you can recreate itif dsframework version was update with updated deploy files you can delete deploy files and recreate themdsf-cli create-cloud-eval-files - cloud eval files this is an option to create all non exist cloud eval files
Package: dsfr_structure
Documentation du Package d'Extensions MkDocs DSFRCe document fournit une vue d'ensemble complète du package d'extensions MkDocs, y compris les détails sur chaque
extension, la structure du projet, l'utilisation de Poetry, et les instructions pour l'installation et le développement.Structure du Projetdsfr_structure/: Dossier racine du package.extension/: Contient les différentes extensions.blockquote/: Extension pour les blockquotes.__init__.py: Contient la logique de l'extension de blockquote.table/: Extension pour les tables.__init__.py: Contient la logique de l'extension de table.all_extensions.py: Fichier pour enregistrer toutes les extensions.tests/: Contient les tests unitaires pour les extensions.pyproject.toml: Fichier de configuration Poetry pour le package.ExtensionsDsfrBlockQuoteExtensionFonctionnalité :Permet la transformation des citations
enblocks de mise en exergue du DSFRDsfrTableExtensionFonctionnalité :Permet la transformation des tableaux
entableaux du DSFRUtilisation de PoetryCommandes Principales :poetry install: Pour installer les dépendances.poetry build: Pour construire le package.poetry publish: Pour publier le package sur PyPI.Installation pour le DéveloppementClonez le dépôt :Accès au dépôt.Installation Locale :Utilisezpip install -e .pour installer le package en mode éditable pour le rendre
disponible localement.TestsExécution des Tests :Comment exécuter les tests unitaires avecpoetry run testoupython -m unittest discover -s tests.
Package: dsfun
DSfunThis package is under development and limited for now. Eventually, it will contain a special categorical loss function class for training machine learning algorithms. The goal features include:Wrapping in a simple interface for many useful loss functions based on confusion matrixDifferentiability (compatibility with tensorflow)Scalable to multilabel problemsTime efficiency optimizationsWorking with missing labelsLimitations:Loss function that aren't widely studied, should be used with caution and proper validationIf calculating on batches, it might give a biased estimation of global lossAs the class is broad, some of the functions might not converge at allInstalationpip install dsfunUsage exampleimport tensorflow as tf
from dsfun import f1_loss, f1_score

y_true = tf.constant([[1.0, 0.0], [1.0, 1.0], [0.0, 1.0], [0.0, 1.0]])
y_pred = tf.constant([[0.5, 0.5], [0.5, 0.5], [1.0, 0.0], [0.0, 1.0]])

print(f1_loss(y_true, y_pred, 'macro'))
print(f1_score(y_true, y_pred, 'macro'))
Package: ds-gear
Data science gear (ds-gear) is a Python API for advanced machine learning algorithms built on top of sklearn, tensorflow and keras and is distributed under the Mit license.DescriptionRNN_MTO_Classifier:Text scoring RNN based on Many-to-One architecture.Example applications include sentiment analysis, review scoringRNN_MTM_Classifier:Text classification RNN based on Many-to-Many architecture.Example applications include Named entity recognition, machine translationInstallationDepenenciesPython (> 3.6)NumpyPandassklearnMatplotlibPylintDoxypypyNltk (==3.5)kerastensorflowkeras-contrib (need to be installed prior to this package)User installationkeras-contrib installation (please refer to git repo @https://github.com/keras-team/keras-contrib)package installation:pip install ds-gearSource codeYou can check the latest sources with the command:git clone https://github.com/AI-Companion/ds-gear.git
Package: dsgen
dsgenLicenseApache License Version 2.0Usagea) used in a single app:# app/settings.pyfromdjango.test.signalimportsetting_changedfromdsgen.utilsimportDSettingclassAppSetting(DSettting):SETTING_NAME='DEMO_APP_SETTING'DEFAULT={'':False,}defget_passthrough_fields(self):fields=('MEDIA_ROOT',)returnfieldsapp_setting=AppSetting()setting_changed.connect(app_setting.signal_handler_setting_changed)b) used in project:# project/settings.pyimportosfromdsgen.utilsimportDSGeneratorclassProjectSetting(DSGenerator):DEFAULT_JSON_FILE='project.json'default_app_list=['django.contrib.auth','coolapp',]_proj=ProjectSetting(json_path=os.getenv('PROJECT_CONFIG_JSON',os.path.join('/etc','coolproject',ProjectSetting.DEFAULT_JSON_FILE)))__dir__=_proj.get_config_field_list__getattr__=_proj.get_config_value
Package: dsgepy
dsgepyThis is a Python library to calibrate, estimate and analyze linearized DSGE models. The interface is inpired by the
dynare interface which allows for symbolic declarations of the variables and equations. The implemented bayesian
estimation method uses markov chain monte carlo (MCMC) to simulate the posterior distributions of the parameters. This
library is an effort to bring the DSGE toolset into the open-source world in a full python implementation, which allows
to embrace the advantages of this programming language when working with DSGEs.InstallationYou can install this development version using:pip install dsgepyKalman FilterComputing the likelihood of models involve using the kalman filter.pykalmanis available for python, but some
adjustments to the original library are needed to use with this library. Soin order fordsgepyto work you need
the corrected version ofpykalman, availablehere. Make sure to clone this
version and add it to the interpreter befor usingdsgepy. The corrections here correct the waypykalmanhandles
masked numpy arrays and deals with ill-estimated covariance matrices.ExampleA full example on how to use this library with a small New Keynesian model is available inthis Jupyter notebook. The model used
in the example is descibred briefly by the following equations:Model EspecificationFor now, the model equations have to be linearized around its steady-state.
Soon, there will be a functionality that allows for non-linearized declaration
of the equilibrium conditions.Model SolutionThe solution method used is based on the implementation of Christopher A. Sims'gensysfunction. You can find the
author's original matlab codehere. The paper explaining the solution
method isthis one.Model EstimationThe models are estimated using Bayesian methdos, specifically, by simulating the posterior distribution using MCMC
sampling. Simulations are typically long, so there is a functionality that allows you to stop a simulation and continue
it later from where it stoped.AnalysisThere are functionalities for computing Impulse-Response funcions for both state variables and observed variables.
Historical decomposition is also available, but only when the number of exogenous shocks matches the number of
observed variables.DrawbacksSince there is symbolic declaration of variables and equations, methdos involving them are slow, so the MCMC methods
typically take a long time to run. Although there is room for improvement for the efficiency of these estimation
algorithms.ContributingIf you would like to contribute to this repository, plese check thecontributing guidelineshere. Alist of feature suggestionsis available on the projects page of this
repository.More Information and HelpIf you need more information and help, specially about contributing, you can contact Gustavo Amarante ondeveloper@dsgepy.com
Package: ds-get
ds_get - Thin client for interfacing with Synology DownloadStation.
Primarily used to add magnet and torrent files.Associate magnet: and .torrent uris with this script in your browser and directly start them in your Synology DSFree software: MIT licenseFeaturesSend magnet links and torrent files to Synology DS Get via command lineCheck download tasksInstallationpip install -e git+https://github.com/dekomote/ds_get.git#egg=ds_getSoon on the PyPiUsageusage: ds_get [-h] [–ip_address [IP_ADDRESS]] [–port [PORT]] [–username [USERNAME]] [–password [PASSWORD]] [–secure [SECURE]][–cert_verify [CERT_VERIFY]] [–dsm_version [DSM_VERSION]] [–debug [DEBUG]]
links [links …]Some of the arguments can also be set in env: DSGET_IP_ADDRESS DSGET_PORT DSGET_USERNAME DSGET_PASSWORD DSGET_SECURE DSGET_CERT_VERIFY DSGET_DSM_VERSION DSGET_DEBUGBugs / TODOUse the issue tracker
Package: dsgnutils
Copyright 2015 define().This file is part of dsgnutils.dsgnutils is free software: you can redistribute it and/or modify it under theterms of the Lesser GNU General Public License as published by the FreeSoftware Foundation, either version 3 of the License, or (at your option) anylater version.dsgnutils is distributed in the hope that it will be useful, but WITHOUT ANYWARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR APARTICULAR PURPOSE.  See the Lesser GNU General Public License for moredetails.You should have received a copy of the Lesser GNU General Public License alongwith dsgnutils.  If not, see <http://www.gnu.org/licenses/>.DOCUMENTATION COMING SOON -- THE FOLLOWING IS ONLY A DRAFTGOALS:These are utilities that make python 3.4.3 nice for me.  Its probably notfor you.  :DASSUMPTIONS:general:--  You understand that all bets are off with a major version of zero--  You love debian (this is not designed for portability)--  tested in ubuntu 14.04, and used in ubuntu 12.04 vms by author--  you use python 3.4.3 or can altinstall and use it--  you will run dsgnutils nosetests (from source, make test, or makewebtest) to figure out if it all seems to be working for you (waswritten for and tested on on ubuntu 14.04)--  NB: nosetests-capturestderr currently has an import problemwhich we patch via bin/reinstall.sh from the git repo for thismoduleF_Lock:--  really...don't use this yet ... am trying to find a way to locksqlite databases.  Some friends of mine and I are fond of sqlitebecause it avoids installing a whole dbms for simple applications,but flocks turn out to be somewhat complicated, so not sure this isbug free or even the right way to go ... still having a play withit--  notes 2 self:--  in your infrastructure, all linux machines have kernel version> x.y.z--  in your infrastructure, all linux machines have NFS version >x.y.zwriteXGPL:you use git for your version control
Package: dsgov.migration
dsgov.migrationA plugin for migratin content for Plone 5 or Plone 6 from Plone exported content in JSON.DocumentationIn progress.InstallationInstall dsgov.migration by adding it to your buildout:[buildout]

...

eggs =
    dsgov.migrationand then runningbin/buildoutAuthorsFabio SantosContributorsFrancisco FilhoLicenseThe project is licensed under the GPLv2.Contributorshandryks@gmail.com,handryks@gmail.comChangelog1.0b3 (2022-01-19)Adds support for Plone 6.
Package: dsgrid-legacy-efs-api
dsgrid-legacy-efs-apidsgrid-legacy-efs-api is a Python API for accessing demand-side grid model (dsgrid) data produced for theElectrification Futures Study (EFS)InstallationTo get the basic package, run:pip install dsgrid-legacy-efs-apiIf you would like to run the example notebooks and browse the files available
through the Open Energy Data Initiative (OEDI), install the required extra
dependencies:pip install dsgrid-legacy-efs-api[ntbks,oedi]and also clone the repository. Then you should be able to run the .ipynb files
in the dsgrid-legacy-efs-api/notebooks folder, which include functionality for
directly browsing the OEDIoedi-data-lake/dsgrid-2018-efsdata files. If you would like
to use the HSDS service, please see the configuration instructions athttps://github.com/NREL/hsds-examples/.
Package: dsh
DSH  - the absent minded developer's shellOrganize the stuff you do via command lineYou might use this if you:Forget how you did that stuff in that project from a while backForget where stuff isWant a single, tab-completed view of the stuff you doWant to store credentials and stuff outside of project configNeed to do sutff in separate contexts/environments such as development vs productionWant a consistent 'api' for doing stuffWhat it doesAt the most basic level, it executes commands expressed in yamlCreates a tree of 'contexts' which consist of vars, commands, and subcontextsLocates and merges contexts defined in .dsh.*.yml filesProvides nested contexts/subshells for projects/environments under a root shellChanges current working directory to that of active shellProvides variable substitutionProvides inherited variables with overrideSample .dsh.yml:dsh:personal.python.projvars:app_name:projectXtest:-pytestinstall:-pip list installed | grep {{app_name}} && pip uninstall -y {{app_name}}-pip install -e .release:-tox -r-rm -rf build && rm -rf dist-python setup.py sdist bdist_wheel-twine upload -r pypi -u {{PYPI_USER}} -p {PYPI_PASS} dist/{{app_name}}*DemoWith dsh.yml files similar to the above, a dsh session might look like this:Installationpip install dsh
Package: dsharp-opac
DSHARP Mie-Opacity LibraryThis repository contains a module to carry out Mie opacity calculations based on
a range of astrophysically relevant optical datasets and to calculate the
default opacity tables used in the Disk Substructures at High Angular Resolution
Project (DSHARP, PI: S. Andrews).This package was created byT. BirnstielandC.P. Dullemond.CreditIf you use this package, please citeBirnstiel et al. (2018).If you use any optical constants, please cite the appropriate experimental papers. The reference will be displayed upon import of the constants.InstallationFromsource: go into the base directory (where thisREADME.mdis) and runpip install .Should you work on the sources, e.g. for including new optical constants or new mehtods, then we recommend linking the installation to the source folder. Changes to the sources will then be reflected uponimport dsharp_opacwithout the need to reinstall the package.last release frompypi.org:pip install dsharp_opacNote: some of the optical constants rely on data files that will be downloaded
upon first use of that particular class.Tests & ExamplesYou can find some jupyter notebooks in thenotebooks folderthat demonstrate some of the functionality of this package. It also contains the notebooks and data that were used to create the figures inBirnstiel et al. (2018).
Package: dshelper
dshelper is a visualization tool designed to help data scientists better examine their data sets.
It utilizeswxpythonand is closely integrated withpandasdata structures andmatplotlibfor plotting.
Here are some of the functionalities that dshelper offers:
- A view with raw data and its statistics
- Drag on the header to re-arrange columns
- Left click on the right panel to show/hide columns
- Plots in a few clicks: histogram, heatmap, correlation, scatter, box, violin, pair
- Bottom right buttons to hide panels and focus on data set
- Easy to use in command line, jupyter notebook and docker
Package: ds-helpers
What is it?ds-helpers is a Python package providing common helper functions for quick data analysis and modeling. Now you can simply call the helper functions for repetitive work and focus on other important things in your Data Science project.Where to get itThe source code is currently hosted on GitHub at:https://github.com/shashankwadhwa9/ds-helpersBinary installers for the latest released version are available at the Python package index.pip install ds-helpersLicenseMIT
Package: dshield
A Pythonic interface to the Internet Storm Center / DShieldAPI.Installationpip install dshieldUsageFor the full documentation, see theReadTheDocssite. If you just
want a quick start:>>> import dshield
>>> dshield.infocon()
{'status': 'green'}
>>> dshield.infocon(dshield.XML)
'<?xml version="1.0" encoding="UTF-8"?>\n<infocon>\n<status>green</status>\n</infocon>'
Package: dsi6
General Assembly Data Science Immersive PackageThis package is a growing collection of classes built by students of the San Francisco dsi6 cohort.It currently includes two classes, RegressionMetrics and ClassificationMetrics. In order to use either one, instantiate it as an object. The .fit() method takes a y_true and a y_pred, and builds out the metrics as attributes on the object. In order to return all the metrics at once as a nicely formatted DataFrame, simply call the .describe() method.We will continue updating this package as more classes are created.
Package: dsi-cocoa
Clinic Opinionated Codebase Oversight and AnalysisThis repository was developed in order to generate automated reports on how well codebases adhere to thecoding standardsof the University of Chicago's DSIClinic course.The goals of this codebase is to provide a quick and easy way to review code and to alert contributors where their code may be failing.Installationpip install cocoacocoaThis package contains a moduleevaluate_repowhich runs code testing libraries against a repository.How to runVia command line:cocoa/path/to/repoAs a python module:fromcocoa.evaluate_repoimportmainmain(["path/to/repo"])A few important notes:Make sure togit pullbeforerunning this code.This will get branch information for all branches.This will only run the analysis (pyflakeson python files) for the codein the current branch. So if you run this while your current branch ismainit will run onmain.If you want to do a full linting, then you can add the argument "LINT" to therun-code-analysiscommand, such as:cocoa /path-to-repo LINT
Package: dside
dsideDesign space identification tool for plotting and analysing design spaces (2D and 3D). Constraints with respect to key performance indicators (KPIs) are used to categorize the samples. Concave hulls (alpha shape) are used to identify design space (DSp) and quantify the size of the space. Given nominal operating point (NOP), an acceptable operating region (AOR) can be quantified to find the maximum multivariate allowable disturbance that the process can still handle while satisfying all constraints (multivariate proven acceptable range - MPAR).InstallationCurrently, dside requires pandas, numpy, and matplotlib. dside can be installed with the following commands.pipinstalldsideQuick OverviewUse this tool to visualize 2D and 3D design spaces, obtain mathematical representations of the design space boundary in the form of alpha shapes, calculate the size of the design space, and investigate nominal operating points in terms of performance and flexibility (acceptable ranges). Identification of multi-region spaces is possible.import dside
# 1. Create instance of ds with data from DataFrame df
ds = dside.DSI(df)
# 2. Screen the points using the constraints (dictionary)
ds.screen(constraints)
# 3. Find DSp boundaries based on vnames (list of variable names)
ds.find_DSp(vnames)
# 4. Plot the design space and the samples
ds.plot(vnames)
# 5. Plot the nominal point and AOR based on point x (list/numpy array)
ds.find_AOR(x)
# 6. Save the results in detailed output.txt file
ds.send_output('output')CitationPlease cite the followingpublicationif you are using dside for your own research.@article{sachio2023dsp,
    title={A model-based approach towards accelerated process development: A case study on chromatography},
    author = {Steven Sachio and Cleo Kontoravdi and Maria M. Papathanasiou},
    journal = {Chemical Engineering Research and Design},
    volume = {197},
    pages = {800-820},
    year = {2023},
    issn = {0263-8762},
    doi = {https://doi.org/10.1016/j.cherd.2023.08.016},
    url = {https://www.sciencedirect.com/science/article/pii/S0263876223005166},
}
Package: dsigm
## DSIGM Clustering Algorithm[![Travis (.com)](https://img.shields.io/travis/com/paradoxysm/dsigm?style=flat-square)](https://travis-ci.com/paradoxysm/dsigm)
[![Codecov](https://img.shields.io/codecov/c/gh/paradoxysm/dsigm?style=flat-square&token=5e48e76aa703404f901dea510983281a)](https://codecov.io/gh/paradoxysm/dsigm)
[![GitHub](https://img.shields.io/github/license/paradoxysm/dsigm?color=blue&style=flat-square)](https://github.com/paradoxysm/dsigm/blob/master/LICENSE)## OverviewThe Density-sensitive Self-stabilization of Independent Gaussian Mixtures (DSIGM) Clustering Algorithm is a novel algorithm that seeks to identify ideal clusters in data that allows for predictive classifications. DSIGM can be conceptualized as a two layer clustering algorithm. The base layer is a Self-stabilizing Gaussian Mixture Model (SGMM) that identifies the mixture components of the underlying distribution of data. This is followed by a top layer clustering algorithm that seeks to group these components into clusters in a density sensitive manner. The result is a clustering that allows for variable and irregularly shaped clusters that can sensibly categorize new data assumed to be part of the same distribution.More details regarding DSIGM can be found in the documentation [here](https://github.com/paradoxysm/dsigm/tree/0.3.1/doc).## Installation### Dependenciesdsigmrequires:` numpy scipy sklearn `dsigmis tested and supported on Python 3.4+ up to Python 3.7. Usage on other versions of Python is not guaranteed to work as intended.### User Installationdsigmcan be easily installed using`pip`` pip install dsigm `For more details on usage, see the documentation [here](https://github.com/paradoxysm/dsigm/tree/0.3.1/doc).## ChangelogSee the [changelog](https://github.com/paradoxysm/dsigm/blob/0.3.1/CHANGES.md) for a history of notable changes to dsigm.## Development[![Code Climate maintainability](https://img.shields.io/codeclimate/maintainability-percentage/paradoxysm/dsigm?style=flat-square)](https://codeclimate.com/github/paradoxysm/dsigm/maintainability)dsigmis still under development. As of0.3.1, only the Self-stabilizing Gaussian Mixture Model (SGMM) has been implemented.There are three main branches for development and release. [master](https://github.com/paradoxysm/dsigm) is the current development build; [staging](https://github.com/paradoxysm/dsigm/tree/staging) is the staging branch for releases; [release](https://github.com/paradoxysm/dsigm/tree/release) is the current public release build.## Help and Support### DocumentationDocumentation fordsigmcan be found [here](https://github.com/paradoxysm/dsigm/tree/0.3.1/doc).### Issues and QuestionsIssues and Questions should be posed to the issue tracker [here](https://github.com/paradoxysm/dsigm/issues).
Package: dsigma
dsigmais an easy-to-use python package for measuring gravitational galaxy-galaxy lensing. Using a lensing catalog, it estimates excess surface density around a population of lenses, such as galaxies in the Sloan Digital Sky Survey or the Baryon Oscillation Spectroscopic Survey. It has a broadly applicable API and can utilize data from the Dark Energy Survey (DES), the Kilo-Degree Survey (KiDS), and the Hyper-Suprime Cam (HSC) lensing surveys, among others. With core computations written in C,dsigmais very fast. Additionally,dsigmaprovides out-of-the-box support for estimating covariances with jackknife resampling and calculating various summary statistics. Below is a plot showing the excess surface density around galaxies in the CMASS sample calculated withdsigma.AuthorsJohannes LangeSong HuangDocumentationDocumentation fordsigmawith concept introductions, examples, and API documentation is available onreadthedocs.Attributiondsigmais listed in theAstronomy Source Code Library. If you find the code useful in your research, please citeLange & Huang (2022).Licensedsigmais licensed under the MIT License.