Saravanan666/pypi-org huggingface dataset:
Package: dilax
dilaxDifferentiable (binned) likelihoods in JAX.Installationpython-mpipinstalldilaxFrom source:gitclonehttps://github.com/pfackeldey/dilaxcddilax
python-mpipinstall.Usage - Model definition and fittingSee more inexamples/dilaxin a nutshell:importequinoxaseqximportjaximportjax.numpyasjnpimportdilaxasdlxjax.config.update("jax_enable_x64",True)# define a simple model with two processes and two parametersclassMyModel(dlx.Model):def__call__(self,processes:dict,parameters:dict)->dlx.Result:res=dlx.Result()# signalmu_mod=dlx.modifier(name="mu",parameter=parameters["mu"],effect=dlx.effect.unconstrained())res.add(process="signal",expectation=mu_mod(processes["signal"]))# backgroundbkg_mod=dlx.modifier(name="sigma",parameter=parameters["sigma"],effect=dlx.effect.gauss(0.2))res.add(process="background",expectation=bkg_mod(processes["background"]))returnres# setup modelprocesses={"signal":jnp.array([10.0]),"background":jnp.array([50.0])}parameters={"mu":dlx.Parameter(value=jnp.array([1.0]),bounds=(0.0,jnp.inf)),"sigma":dlx.Parameter(value=jnp.array([0.0])),}model=MyModel(processes=processes,parameters=parameters)# define negative log-likelihood with data (observation)nll=dlx.likelihood.NLL(model=model,observation=jnp.array([64.0]))# jit it!fast_nll=eqx.filter_jit(nll)# setup fit: initial values of parameters and a suitable optimizerinit_values=model.parameter_valuesoptimizer=dlx.optimizer.JaxOptimizer.make(name="ScipyMinimize",settings={"method":"trust-constr"})# fitvalues,state=optimizer.fit(fun=fast_nll,init_values=init_values)print(values)# -> {'mu': Array([1.4], dtype=float64),#     'sigma': Array([4.04723836e-14], dtype=float64)}# eval model with fitted valuesprint(model.update(values=values).evaluate().expectation())# -> Array([64.], dtype=float64)# gradients of "prefit" model:print(eqx.filter_grad(nll)({"sigma":jnp.array([0.2])}))# -> {'sigma': Array([-0.12258065], dtype=float64)}# gradients of "postfit" model:@eqx.filter_grad@eqx.filter_jitdefgrad_postfit_nll(where:dict[str,jax.Array])->dict[str,jax.Array]:nll=dlx.likelihood.NLL(model=model.update(values=values),observation=jnp.array([64.0]))returnnll(where)print(grad_postfit_nll({"sigma":jnp.array([0.2])}))# -> {'sigma': Array([0.5030303], dtype=float64)}ContributingSeeCONTRIBUTING.mdfor instructions on how to contribute.LicenseDistributed under the terms of theBSD license.
Package: dilbert.py
RequirementsThis module requires the following modules:beautifulsoup4requestsInstallationPython 3.8 or higher is required.To install the stable version, do the following:# Unix / macOSpython3-mpipinstall"dilbert.py"# Windowspy-mpipinstall"dilbert.py"To install the development version, do the following:$gitclonehttps://github.com/Infiniticity/dilbert.pyLinksdilbertDocumentation
Package: dilcher-configuration
Dilcher-configurationThe dilcher-configuration Django app is used to provide easily manageable settings
for Django projects.It does not define any data model on its won. Instead, it provides an abstract
class (Setting) that can be inherited from.
This class then allows to add additional attributes that should be editable.When such a class is saved, thenpre_saveandpost_savesignals
will take care of ensuring that timestamps are
updated and only one set of Settings is active at a time.This module does not define any Django Admin views, you will need to do that
in your own app.
Package: dillinger
# Dillinger: Deadly accurate multi-armed banditsDillinger is a guide to using Bayesian optimization to select new actions for multi-armed bandits. The core of the project is a **Gaussian Process** class that can be fit to observations from multi-armed bandits. To facilitate demonstration, the package also has the following features: a data generator that simulates LTV of customers based on a price sensitivity curve, and an implementation of the Softmax bandit algorithm.This project is still very much under construction, as I'm adapting an existing project to make it more useable and accessible to those interested in applying Bayesian optimization to A/B tests or multi-armed bandit experiments.See `demos\` for examples of how to use this package.
Package: dill-tils
DilllonB07 UtilitiesDill_tils is a package that has my commonly used functions inside it for ease of use.InstallationAnyone can use this package by installing it from PyPi via one of the following commands:Pippipinstalldill_tilspip3installdill_tilspython-mpipinstalldill_tilspython3-mpipinstalldill_tilsPoetrypoetryinstalldill_tilsCondacondainstalldill_tilsPipenvpipenvinstalldill_tilsUsageJust import the modules you need and get started!LicenseThis project is licensed under the LGPLv3 license.
Package: di-logging
di-loggingProduct logging library to provide consistent logging across components.Loggers can be obtained thusly:fromdi_loggingimportget_loggerlogger=get_logger(__name__)This code should be placed at the top level within a module and this logger used throughout the component.If an application or system is being written the logging should be configured within the main entry point;fromdi_loggingimportconfigure_loggingif__name__=="__main__":configure_logging()do_the_stuff()This will setup the logging for the system.Release Process☛ Includes a semantic release system, which generates a new release on GitHub, including a changelog.The version is automatically changed accordingly to the commit message that results from merging the PR.☛breaking-change/CAP-123Something runs the pipeline and bumps major version:1.0.0 → 2.0.0☛feature/CAP-123 Somethingruns the pipeline and bumps minor version:1.0.0 → 1.1.0☛fix/CAP-123 Somethingruns the pipeline and bumps patch version:1.0.0 → 1.0.1☛CAP-123 Somethingjustruns the pipeline⚠ If this flow is unclear to you, don't hesitate in contacting DevOps team ⚠How to run locallyCreate a.envfile from the existent.env.examplefile. Make sure to update it accordingly with your environment variables.Using poetrypoetry config virtualenvs.create truepoetry config virtualenvs.in-project truepoetry installUsing docker containerExecutemake start-dependenciesin order to start whichever dependencies your project might have. You should always have the base Python image.Executemake runand your application should be running.Executemake stop-dependencieswhen you no longer need to execute your project.Executemake sync-requirementsto rebuild the docker image.How to know whichmakerecipes are availableRunmakeHow to run testsRunmake testHow to run tests with coverage reportRunmake coverage
Package: dim
# DIM - Docker Image MonitorListen on docker events and register image usage time.## Installation```sudo pip install git+http://github.com/stratoscale/dim.git```The installation will add the dim service to systemd, make sure you reload it.```systemctl daemon-reloadsystemctl enable dim.servicesystemctl start dim.service```## UsageTo display the images last start time run```dim-display```example output```+-----------------------------------------------------------------------------------+-------------------+| Image                                                                             | Last Start Time   |+===================================================================================+===================+| fakes3:latest                                                                     | 7 hours ago       |+-----------------------------------------------------------------------------------+-------------------+| mariadb:10.1.19                                                                   | 7 hours ago       |+-----------------------------------------------------------------------------------+-------------------+| consul:0.9.2                                                                      | 7 hours ago       |+-----------------------------------------------------------------------------------+-------------------+| dynamodb:latest                                                                   | 7 hours ago       |+-----------------------------------------------------------------------------------+-------------------+| postgres:latest                                                                   | 2 days ago        |+-----------------------------------------------------------------------------------+-------------------+| mariadb:10.1.26                                                                   | 6 days ago        |+-----------------------------------------------------------------------------------+-------------------+| gotty:latest                                                                      | 11 days ago       |+-----------------------------------------------------------------------------------+-------------------+| rabbitmq:3.5.1-management                                                         | 18 days ago       |+-----------------------------------------------------------------------------------+-------------------+```For more options run:```dim-display -h``````usage: dim-display [-h] [-q] [-w WHITELIST] [-m MIN_AGE] [-r] [-s {age,image}]Display Images Last Start Time.optional arguments:-h, --help            show this help message and exit-q, --quiet           If set, returns only the image names-w WHITELIST, --whitelist WHITELISTImages whitelist file-m MIN_AGE, --min-age MIN_AGEMinimum image age in seconds-r, --reverse         If set images will be sorted by reversed order-s {age,image}, --sort-by {age,image}If set images will be sorted by that attribute```
Package: dima-db
Copyright (c) 2018 Frame.ioPermission is hereby granted, free of charge, to any person obtaining a copyof this software and associated documentation files (the "Software"), to dealin the Software without restriction, including without limitation the rightsto use, copy, modify, merge, publish, distribute, sublicense, and/or sellcopies of the Software, and to permit persons to whom the Software isfurnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in allcopies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ORIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THEAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHERLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THESOFTWARE.Description:# DIMAA command-line tool to list, inspect and kill database queries.We've been using this tool since 2017 at Frame.io and decided to open source it. There will be a blog post with more details on the Frame.io Engineering Blog soon. Previous git history has been wiped by our security team.# Setup:1. Clone this repo2. Set up the credentials (see below)3. Run: `python setup.py install`(homebrew setup is being worked on)# Credential SetupDatabase credentials can be provided in 2 ways - in a `~/.dima_creds` file or as environment variables. DIMA will look first for the environment variables, and then to the creds file. You can set the following environment variables:DIMA_DB_DBNAMEDIMA_DB_USERDIMA_DB_HOSTDIMA_DB_PORTDIMA_DB_PASSWORDor place them in a `~/.dima_creds` file (the prefix `~/` means that it should be in your home directory). A sample file `sample_creds` is in this repo.You can add more credentials for different databases underneath, as long as they use a different prefix. E.g.DIMA_DB2_DBNAMEDIMA_DB2_USER...To inspect a non-default DB, use the `-c` option, e.g. for a prefix `DIMA_DB2_...` use:dima -c DB2 show 123# Usage:dimaShows a list of running queriesdima show [PID]Inspects a specific running querydima rm [-f] [Lock / filter keyword / PID]Terminates queries either with `wait_event_type` "Lock" or according to a filter keyword or PID. Use -f to avoid the confirmation.# Screenshots<img src="https://github.com/Frameio/homebrew-dima/raw/master/img/dima_cmd.png" alt="dima command" width="500"/><img src="https://github.com/Frameio/homebrew-dima/raw/master/img/dima_show_cmd.png" alt="dima show command" width="500"/><img src="https://github.com/Frameio/homebrew-dima/raw/master/img/dima_rm_cmd.png" alt="dima rm command" width="500"/>Platform: UNKNOWNClassifier: Programming Language :: Python :: 2.7Classifier: License :: OSI Approved :: MIT LicenseClassifier: Operating System :: OS IndependentClassifier: Topic :: Database
Package: dimae
dim_aeDimensionality Reduction Autoencoder built with Keras TFPackage installationpip install dimaeUsage exampleimportpandasaspdimporttensorflowastffromdimae.autoencoders.autoencoderimportAEdf=pd.DataFrame(...)n_features=df.shape[1]output_features=10ae=AE(n_features,output_features)batch_size=8epochs=15dataset=tf.data.Dataset.from_tensor_slices((df.values.astype('float32'),df.values.astype('float32')))t_dataset=dataset.batch(batch_size)ae.compile(optimizer='adam',loss='mse')ae.fit(t_dataset,epochs=epoches)encoder=ae.generate_encoder()encoder.summary()
Package: dimcat
DiMCATDIgital Musicology Corpus Analysis ToolkitA Python library for processing and analyzing notated music on a very large scale. It is under heavy development and
has just seen its v1.0.0 alpha release. The library is developed by the Digital and Cognitive Musicology Lab at the
École Polytechnique Fédérale de Lausanne (EPFL) in Switzerland and a white paper has been published asHentschel, J., McLeod, A., Rammos, Y., & Rohrmeier, M. (2023). Introducing DiMCAT for processing and analyzing notated music on a very large scale. Proceedings of the 24th International Society for Music Information Retrieval Conference, 516–523.https://ismir2023program.ismir.net/poster_52.htmlInstallationDiMCAT is available on PyPI and can be installed via pip:pipinstalldimcatQuickstartDiMCAT compiles frictionless datapackages. To play around with the alpha release, we recommend downloading the package
which corresponds to the DCML corpora that are currently public. The package consists of two files:dcml_corpora.zip(data)dcml_corpora.json(metadata)The data package can be loaded into DiMCAT as follows:fromdimcatimportDatasetD=Dataset.from_package("dcml_corpora.datapackage.json")AcknowledgementsDevelopment of this software tool was supported by the Swiss National Science Foundation within the
project “Distant Listening – The Development of Harmony over Three Centuries (1700–2000)”
(Grant no. 182811). This project is being conducted at the Latour Chair in Digital and Cognitive
Musicology, generously funded by Mr. Claude Latour.The software project has been set up using PyScaffold 4.2.1.
Package: dimcli
DimcliDimcli is a Python client for accessing the Dimensions Analytics API. It makes it easier to authenticate against the API, send queries to it and process the JSON data being returned.>>>importdimcli

>>>dimcli.login(key="private-key-here",endpoint="https://app.dimensions.ai/api/dsl/v2")>>>dsl=dimcli.Dsl()>>>res=dsl.query("""search grants for "malaria" return researchers""")>>>print(res.json){'researchers':[{'id':'ur.01332073522.49','count':75,'last_name':'White','first_name':'Nicholas J'},{'id':'ur.01343654360.43','count':59,'last_name':'Marsh','first_name':'Kevin'},.............],'_stats':{'total_count':8735}}CLIDimcli includes also a command line interface (CLI) that aims at simplifying the process of learning the grammar of the Dimensions Search Language (DSL).JupyterDimcli plays nice with Jupyter notebooks too. It comes with various magic commands for querying the API, transforming JSON data into dataframes and turning them into interactive tables with hyperlinks - so that data can be inspected further on external websites.More infoFor more information see theGetting Started with Dimclitutorial.Current version: seepypi homepage. Source code hosted ongithub.Comments, bug reportsDimcli lives onGithub. You can fileissuesor pull requests there. Suggestions, pull requests and improvements welcome!
Package: dime
Virtual Desktop time tracker___||_|________|.|||-_||___|_|_|_|_|___|Askedforlast1day(s)From:00:00-12,Mar2017[Oldestrecord:03:57-13,Mar2017]╒═══════════╤════════════╕│Desktop│HH:MM:SS│╞═══════════╪════════════╡│Main│0:05:01│╘═══════════╧════════════╛
Package: dimedbpy
dimedbpy: Python wrapper for the DIMEdb REST APIdimedbpy provides a way to interact with the DIMEdb web service in Python. It provides metabolite queries by name, structure, and isotope information.Here's a quick example, showing how to retrieve metabolites by its name:fromdimedbpyimportget_metabolitesmetabolites=get_metabolites("name","Caffeine")formetaboliteinmetabolites:print(metabolite.isotopic_distributions)ResourcesDIMEdb Help PageWikiLicenseCode released underthe MIT license.
Package: dim-editor
DimDim is a simple terminal-based text editor inspired by Vim. Its aim is to provide an easier and less functional alternative to learning Vim.InstallationYou must have Python 3.8 or higher to run Dim.Install via PipTo install using pip, run the following command.pipinstalldim-editorThen, you can launch the editor withdim
python-mdimBuilding ManuallyTo build Dim manually, clone or download this repository and navigate into the main folder.On Windows, you must run this command to install curses.pipinstall-rwin-requirements.txtYou can run the editor withpythondim/dim.pyThere are tools available to compile the Python application into an executable format. If you decide to use one of these tools, make sure that dim/debug and dim/tutorial are included as subdirectories.
Package: dimensigon
Dimensigon (DM)is our backend technology at store.dimensigon.com to bootstrap ELASTIC Services.As main features:Polyglot or Heterogeneous orquestrationsMesh NetworkingDecentralization of IoT or IoT 2.0 as we understand it for our own implementation.Distributed-Decentralized Server Management, High-complex orchestrationsFull RESTful and easily embeddableDistributed Vault for Configuration Management or SecretsLog FederationDouble Encryption (SSL + Encrypted messaging by default)ACLs for higher granularity and security control on top of OS Security.All these functionality makesDimensigon (DM)a good standard for companies serving as Coordination layer for all automation technologies (Polyglot).Dimensigon(DM) lowers the costs of administration and simplify the management of high-complex environments like Hybrid Multi-Cloud.Dimensigon (DM)is a 100% Python and REAL Open Source project.REAL Open Source=> No Freemium or Enterprise versions would be available in the future
Package: dimensionality-reductions-jmsv
What is it?dimensionality_reductions_jmsvis a Python package that provides three methods (PCA, SVD, t-SNE) to apply dimensionality reduction to any dataset. Aslo provides two methods (KMeans y KMedoids) to clustering.Installing the packageRequests is available on PyPI:pipinstalldimensionality_reductions_jmsvTry your firstdimensionality reduction with PCAfromdimensionality_reductions_jmsv.decompositionimportPCAimportnumpyasnpX=(np.random.rand(10,10)*10).astype(int)pca=PCA(n_components=2)X_pca=pca.fit_transform(X)print("Original Matrix:",'\n',X,'\n')print("Apply dimensionality reduction with PCA to Original Matrix:",'\n',X_pca)Try your firstKMeans clusterfromdimensionality_reductions_jmsv.clusterimportKMeansfromsklearn.datasetsimportmake_blobsimportmatplotlib.pyplotaspltX,y=make_blobs(n_samples=500,n_features=2,centers=4,cluster_std=1,center_box=(-10.0,10.0),shuffle=True,random_state=1,)k=KMeans(n_clusters=4,init_method='kmeans++',random_state=32,n_init=10)m=k.fit_transform(X)plt.scatter(X[:,0],X[:,1],c=k._assign_clusters(X))plt.title('Cluster KMeans')plt.show();
Package: dimensionalquantity
# Dimensional quantitieshttps://en.wikipedia.org/wiki/Dimensional_analysisTest benchmark for:
*https://pypi.python.org/pypi/numericalunits*https://pypi.python.org/pypi/Pint/0.7.2# testing and coverage
This module is tested using py.test and the code coverage is checked usinghttps://pypi.python.org/pypi/pytest-covUse the runcovtests.sh script in tests to run the tests and produce a coverage report.
Package: dimensions
dimensions==========A pure Python library for reading the width and height of images.installation------------`pip install dimensions`Done.usage-----For a single image:> dimensions src/sample.pngsrc/sample.pngwidth: 405height: 239content_type: image/pngWildcards also work (escape \* in markdown for PyPi RST...):> dimensions src/\*.pngsrc/sample.pngwidth: 405height: 239content_type: image/pngsrc/sample2.pngwidth: 473height: 469content_type: image/pngAs always, full details are available via `dimensions -h`.In Python code, simply call `dimensions.dimensions`. If you provide asequence of filenames, you get back a sequence of tuples; if you providejust a single filename, you get back a single tuple.import dimensionsdims = dimensions.dimensions('./src/sample.png')# (405, 239, 'image/png', './src/sample.png')future------- release newer version to PyPi
Package: dimep
Detection of Ipsilateral Motor Evoked PotentialsDiMEPstands forDetection ofipsilateralMotorEvokedPotentials and was developed byRobert Guggenbergerat theInstitute of Neuromodulation and Neurotechnology of the University Hospital Tübingen.InstallationInstall the stabel release from PyPI withpip install dimepand the most recent development  tip withpip install git+https://github.com/translationalneurosurgery/tool-dimep.git.UsageAccess the algorithms withfromdimep.apiimport<algorithm>and subsequently call them, e.g. withfromdimep.apiimportlewislewis(trace=trace,tms_sampleidx=500,fs=1000)# where the trace is the single-channel EMG recording# tms_sampleidx marks the onset of the TMS pulse# and fs is the sampling rate.DocumentationRead the documentation onreadthedocs.
Package: dime-pytorch
Distance to Modelled Embedding (DIME)This repo contains an implementation of DIME, which is a method to detect out-of-distribution (OOD) observations in deep
learning. DIME provides a flexible method to detect OOD-observations with minimal computational overhead and simply assumes
access to intermediate features from an ANN.The workflow how DIME works is summarized in four steps.Given a trained ANN and training set observations, obtain intermediate feature representations of the
training set observations (here denoted embedding). If the embeddings are higher than 2-dimensional,
aggregate to a 2D-matrix NxP-matrix (for instance by global average pooling in the context of
NxCxHxW-representations from a CNN).Linearly approximate the training set embedding by a hyperplane found by truncated singular value decomposition.Given new observations, obtain the corresponding intermediate representation.In the embedding space, measure the distance to the hyperplane (modelled embedding) to determine whether
observations are OOD.In an optional step following 2., you can calibrate the distances against a calibration set to obtain probabilities of
observing an observation with less than or equal distance to the observed distance.Get startedSimply install from pip:pip install dime-pytorchExamplesGiven a 2D-tensor, fit the hyperplane.from dime import DIME

x = torch.tensor(...) # N x P torch 2D float-tensor.
modelled_embedding = DIME().fit(x)To obtain probabilities, calibrate percentiles. Preferably against
separate dataset. Chaining is fine.:x_cal = torch.tensor(...)  # N_cal x P torch 2D float-tensor.
modelled_embedding = DIME().fit(x).calibrate(x_cal)Given fitted hyperplane, you can calculate distances on new observations:x_new = torch.tensor(...)  # N_new x P 2D float-tensor.
modelled_embedding.distance_to_hyperplane(x_new)  # -> 1D float-tensor, length N_newTo obtain probabilities of that the new observations have a distance
calibration set observations are equal or less than the new distance,
you need to have calibrated the percentiles as shown above. Then you
receive the probablities by passingreturn_probablities-keyword:modelled_embedding.distance_to_hyperplane(x_new, return_probabilites=True) # -> 1D float-tensor, length N_newYou can also use the alternative formulation of distance within the hyperplane, optionally as probabilities:modelled_embedding.distance_within_hyperplane(x_new)  # -> 1D float-tensor, length N_newLicenseDistributed under the MIT-license. See LICENSE for more information.Â© 2021 Sartorius AG