Saravanan666/pypi-org huggingface dataset:
Package: dsmtpd
dsmptd: A debugger SMTP server for Humansdsmtpd is a small tool to help the developer without an smtp serverUsage$ dsmtpd -p 1025 -i 127.0.0.1
2013-01-13 14:00:07,346 INFO: Starting SMTP server at 127.0.0.1:1025InstallationFor the installation, we recommend to use a virtualenv, it’s the easy way if you want to discover this package:virtualenv ~/.envs/dsmtpd
source ~/.envs/dsmtpd/bin/activate

pip install dsmtpdDocumentationExecute dsmtpd with the –help flag and you will get the usage of this command:dsmtpd --helpThere are three options:-p You specify the port of dsmtpd (default is 1025)-i You specify the network interface (default is loopback, 127.0.0.1)-d You specify a Maildir directory to save the incoming emailsUse itHere is a small example:dsmtpd

swaks --from stephane@wirtel.be --to foo@bar.com  --server localhost --port 1025Contributinggit clone git://github.com/matrixise/dsmtpd.gitCopyright 2013 (c) by Stephane Wirteldsmtpd ChangelogHere you can see the full list of changes between each dsmtpd release.Version 0.3Release on May 26th 2021.Maildir capture: added early check (patch by Bernhard E. Reiter)Remove the support of DocoptRemove the support of Python 2.x (dead in 2020)Support Python 3.6+Improve the classifiers for PyPIMigrate to PEP 517Fix License into setup.pyAdd tests for the CLI using argparse instead of docoptVersion 0.2Release on January 21st 2013.Allow to store the incoming emails in a maildir via the ‘-d’ argumentVersion 0.1Release on January 14th 2013.Implement a basic serverShow the message in the log
Package: ds-my-data
My - DataThis repository contains the code to work with the database of theMy Project. This library uses theMy modelpackage to define the database models. It uses SQLModel to talk to the database. This package is published on PyPI asds-my-datato prevent name clashes with other packages.InstallingInstalling this Python library can be done with the regularpiptooling:pipinstallds-my-dataAfter installing, you can use it. In the documentation on GitHub page is explained how to use it.DevelopingIf you want to develop on this library, you can create your own development environment, or use the DevContainer provided in this repository. To use the provided DevContainer, all you have to do is open this repository in VScode and selectOpen in Dev Containerin the command palette. You need to have theDev Containersextension installed for this and you need Docker or PodMan to run the container.
Package: ds-my-model
My - ModelThis repository contains the models for the My project. The models that are defined in this repository define what object types are possible and how they should behave. This package is published on PyPI asds-my-modelto prevent name clashes with other packages.InstallingInstalling this Python library can be done with the regularpiptooling:pipinstallds-my-modelAfter installing, you can use it. In the documentation on GitHub page is explained how to use it.DevelopingIf you want to develop on this library, you can create your own development environment, or use the DevContainer provided in this repository. To use the provided DevContainer, all you have to do is open this repository in VScode and selectOpen in Dev Containerin the command palette. You need to have theDev Containersextension installed for this and you need Docker or PodMan to run the container.
Package: ds-my-snippets
DS SnippetsTrechso de código úteis sobre DataScienceAutor: Rafael Morais de AssisComo criar nova versãoCriar pacote here
python setup.py sdist bdist_wheelInstalar aqui e testar
pip install -e .Como atualizar o pacote=> (mandar para o test-py)
twine upload --repository-urlhttps://test.pypi.org/legacy/dist/*
=> mandar para Pypi (pip
python -m twine upload dist/*Como usarInstalar com pipUse!se estiver no colba/kaggle!pip install ds-my-snippetsChamandoimport ds_my_snippets as dsTrecho que funcionaimport pandas as pd
import seaborn as sns
import ds_my_snippets as ds

iris = sns.load_dataset('iris')
iris = ds.reduce_mem_usage(iris)Chamando todas as funçõesdir(ds) # lista todas as funçôes do módulo
Package: dsnd-probability-tl2024
dsnd-probability-tl2024 packagePackage includes a Gaussian and Binomial class for calculating and visualizing a Gaussian and Binomial distributions respectively.Files1. Generaldistribution.py 
    a.  Parent class
2. Binomialdistribution.py
    a. Contains Binomial class
3. Gaussiandistribution.py
    a. Contains Gassian classinstallationpip install dsnd-probabilitytl2024import the distributionfrom dsnd-probability-tl2024 import Gaussian, BinomailInstantiate Guassian Object1. g_instance = Gaussian(10,7)
2. g_instance.data = [1, 3, 99, 100, 120, 32, 330, 23, 76, 44, 31]
3. g_instance.calculate_mean()
4. g_instance.calculate_stdev()
5. g_instance.pdf(25)
6. g_instance.plot_histogram()
7. g_instance.plot_histogram_pdf()Instantiate Binomial Object1. b_instance1 = Binomial(.4,25)
2. b_instance1.data = [0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]
3. b_instance1.calculate_mean()
4. b_instance1.calculate_stdev()
5. b_instance1.pdf(5)
6. b_instance1.plot_bar_pdf()
7. b_instance2_ = Binomial(.4, 60)
8. binomial_sum = b_instance1 + b_instance2
9. print(binomial_sum)
Package: dsne
DSNEVisualizing Data Velocity using DSNE.Preprint.
Python library containing DSNE algorithms.InstallationRequirementscblasoropenblas.
Tested version is v0.2.5 and v0.2.6 (not necessary for OSX).From Github:git clone https://github.com/songtingstone/dsne
cd dsne/
make cleanpackageFrom PyPI:pip install dsneFrom conda:conda install -c maxibor dsneUsageBasic usage:fromdsneimportDSNEW=DSNE(X,V,Y)ExamplesSimulation with Exact Velocity EmbeddingsSimulation with Approximate Velocity EmbeddingsPancreasAlgorithmsDSNEDirection Stochastic Nearnest Neighbor Embedding of Velocity
Package: dsnparse
dsnparseParsedsn connection url strings. Responsible for parsing dsn strings in projects likepromandmorp.This is a generic version ofdj-database-url.So, now you can create dsns like this:scheme://user:pass@host:port/path?query=query_val#fragmentFor example, let's look at a prom dsn:prom.interface.postgres.Interface://testuser:testpw@localhost/testdbNow let's parse it:importdsnparsedsn="prom.interface.postgres.Interface://testuser:testpw@localhost:1234/testdb"r=dsnparse.parse(dsn)print(r.scheme)# prom.interface.postgres.Interfaceprint(r.username)# testuserprint(r.password)# testpwprint(r.host)# localhostprint(r.port)# 1234print(r.hostloc)# localhost:1234print(r.paths)# ['testdb']Also, dsnparse can easily use environment variables:r=dsnparse.parse_environ('ENVIRONMENT_VARIABLE_NAME')I tried to keep the interface very similar tourlparseso it will feel familiar to use.CustomizingBy default,dsnparse.parse(dsn)returns aParseResultinstance, but that can be customized:importdsnparseclassMyResult(dsnparse.ParseResult):defconfigure(self):# expose an interface propertyself.interface=self.schemedsn="Interface://testuser:testpw@localhost:1234/testdb"r=dsnparse.parse(dsn,parse_class=MyResult)print(isinstance(r,MyResult))# Trueprint(r.interface)# InterfaceInstallUse pip:pip install dsnparseor use pip with github:pip install -U "git+https://github.com/Jaymon/dsnparse#egg=dsnparse"
Package: dsntnn
:warning:I have helped integrate DSNT intoKornia(from v0.1.4). New users are advised to use that implementation instead of this one. Existing users should note that the "normalised" coordinate system differs between the two implementations (seehttps://github.com/anibali/dsntnn/issues/15).PyTorch DSNTThis repository contains the official implementation of the differentiable
spatial to numerical (DSNT) layer and related operations.$pipinstalldsntnnUsagePlease refer to thebasic usage guide.ScriptsRunning examples$python3setup.pyexamplesHTML reports will be saved in theexamples/directory. Please note that thedsntnnpackage must
be installed withpip installfor the examples to run correctly.Building documentation$mkdocsbuildRunning testsNote: The dsntnn package must be installed before running tests.$pytest# Run tests.$pytest--cov=dsntnn--cov-report=html# Run tests and generate a code coverage report.Other implementationsTensorflow:ashwhall/dsntBe aware that this particular implementation represents coordinates in the (0, 1)
range, as opposed to the (-1, 1) range used here and in the paper.If you write your own implementation of DSNT, please let me know so that I can add it to
the list. I would alsogreatlyappreciate it if you could add the following notice
to your implementation's README:Code in this project implements ideas presented in the research paper
"Numerical Coordinate Regression with Convolutional Neural Networks" by Nibali et al.
If you use it in your own research project, please be sure to cite the
original paper appropriately.License and citation(C) 2017 Aiden NibaliThis project is open source under the terms of theApache License 2.0.If you use any part of this work in a research project, please cite the following paper:@article{nibali2018numerical,title={Numerical Coordinate Regression with Convolutional Neural Networks},author={Nibali, Aiden and He, Zhen and Morgan, Stuart and Prendergast, Luke},journal={arXiv preprint arXiv:1801.07372},year={2018}}
Package: dsolve
dsolvedsolveis a package to solve systems of dynamic equations in Python.Sequence Space$$F(X,\mathcal{E})=0$$$$f_t(x_{t-1},x_{t},x_{t+1},\epsilon_t)=0\qquad \forall t$$SymbolicA package to solve systems of dynamic equations with Python. It understands $\LaTeX$ syntax and it requires minimum specifications from the user end. It solves problems of the form:$$A_0\begin{bmatrix}x_{t+1}\ E_{t}[p_{t+1}]\end{bmatrix}=A_1\begin{bmatrix}x_{t}\ p_{t}\end{bmatrix}+\gamma z_t$$with $x_t$ given. Following Blanchard Kahn notation, $x_{t}$ are state variables (known at time $t$) while $p_{t}$ are forward-looking variables, and $z_t$ are shocks with $E_t[z_{t+1}]=0$. The solver uses the Klein (2000) algorithm which allows for $A_0$ to be invertible.Returns the matrix solution$$p_t=\Theta_p x_t+Nz_t$$
$$x_{t+1}=\Theta_x x_t+Lz_t$$and methods to plot impulse responses given a sequence of $z_t$The main class of the package isKlein, which stores and solves the dynamic system. It takes a list of strings that are written as $\LaTeX$ equations, a dictionary that define the numeric values of the parameters, and the specification ofx,pandz, specified as a list of $\LaTeX$ strings or a long string separated by commas.Usage (for more examples check thenotebook tutorial)fromdsolve.solversimportKlein# Your latex equations here as a list of stringseq=['\pi_{t}=\beta*E\pi_{t+1}+\kappa*y_{t}+u_{t}','y_{t}=Ey_{t+1}+(1-\phi)*E[\pi_{t+1}]+\epsilon_{t}','\epsilon_{t}=\rho_v*\epsilon_{t-1}+v_{t}']# Your calibration here as a dictionarycalibration={'\beta':0.98,'\kappa':0.1,'\phi':1.1,'\rho_v':0.8}# Define pre-determined variables, forward looking variables, and shocks as strings separated by commas or a list of strings.x='\epsilon_{t-1}'p='\pi_t, y_t'z='v_t, u_t'system=Klein(eq=eq,x=x,p=p,z=z,calibration=calibration)# Simulate the inpulse response of a shock v_{0}=0 for 12 periods when \epsilon_{-1}=0system.simulate(x0=0,z={'v_{t}':1},T=12)Flexible input readingThe standarized way to write a variable isE_{t}[x_{s}]to represent the expectation ofx_{s}at timet. butdsolveunderstands other formats.Ex_{s},E[x_s]andEx_sare quivalents toE_{t}[x_{s}], and the subscripttis assumed.Greek symbols can be writen as\rhoor justrho.dsolveunderstands fractions and sums.\sum_{i=0}^{2}{x_{i,t}}producesx_{0,t}+x_{1,t}+x_{2,t}and fraction\frac{a}{b}produces(a)/(b)
Package: dsort
dsortdsort - sorts YAML/JSON according to a configurable preferenceFree software: MIT licenseDocumentation:https://dsort.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.0.1 (2022-11-01)First release on PyPI.
Package: dspace
IntroductionThis package provides a DSpace interface on top of the Python OAI-PMH library,
pyoai. After providing the OAI-PMH server URL, items can be harvested either
by collection handle or individually. Additional harvesting options such as
dates are passed through directly to the pyoai client.Changes in version 2SWORD integration was added to support depositing items into the repository.
This requires some changes in the URL handling on the Repository class.History2.0 (2011-03-24)Added a SWORD client for pushing new items to the DSpace repository1.0 (2010-08-19)Repository class for interfacing with the OAI-PMH server of a DSpace repsitoryDefault METS based metadata extraction
Package: dspace-client
DSpace rest client for v7 or aboveUsingpip install dspace-clienton code:fromdspaceimportDSpaceClientclient=DSpaceClient("https://api7.dspace.org/server/")client.login("dspacedemo+admin@gmail.com","dspace")print(client.get_items())GoalsImplement all endpoints on DSpace Rest ContractConfigurable by defaultAll authentication methodsAsync supportFeaturesAuthenticaion using login/passwordAutorefresh tokenAuto XSRF tokenObjects are pydantic friendly not dicts
Package: dspace-rest-client
DSpace Python REST Client LibraryThis client library allows Python 3 scripts (Python 2 probably compatible but not officially supported) to interact with
DSpace 7+ repositories, using the DSpace REST API.This library is a work in progress and so far offers basic create, update, retrieve functionality for
Community, Collection, Bundle, Item, Bitstream, Group and User (EPerson) objects.Help with extending the scope and improving the code is always welcome!PyPI homepage:https://pypi.org/project/dspace-rest-client/RequirementsPython 3.x (developed using Python 3.8.5)Python Requests module (seerequirements.txt)Working DSpace 7 repository with an accessible REST APIInstallationTo install with pip:pip install dspace_rest_client(orpip3orpython -m pipas appropriate to your environment)To install manually, clone this repository and install the requirements:git clone https://github.com/the-library-code/dspace-rest-python.git
pip install -r requirements.txtUsageAfter installing dependencies, you're ready to run the script.
You can either pass the base API URL to the DSpaceClient() constructor or set them as environment variables.Some environment variables can be used when setting up the REST client connection.DSPACE_API_ENDPOINTis the base URL of your endpoint eg.http://localhost:8080/serverDSPACE_API_USERNAMEandDSPACE_API_PASSWORDare credentials to use for authentication.See theexample.pyscript for an example of community, collection, item, bundle and bitstream creation.
Just set the credentials and base URL at the top of the script to match your test system, or if you've set environment
variables, remove the arguments from the DSpaceClient() instantiation and the environment variables will be used as
defaults.The output from theexample.pyscript should look something like:╰─$ python example.py                                                                                                                                                                                                              1 ↵
Updating token to 9730dfb9-c4ea-4f56-a2f0-4dc4cacf5059
Authenticated successfully as kim@shepherd.nz
API Post: Updating token to b44f91c2-5386-4c11-a1ca-1ea06613fae4
{"timestamp":"2022-02-10T05:44:12.758+00:00","status":403,"error":"Forbidden","message":"Access is denied. Invalid CSRF token.","path":"/server/api/core/communities"}
API Post: Retrying request with updated CSRF token
community 31264734-49c0-4bff-8ed7-e09e3abbfe7a created successfully!
New community created! Handle: 123456789/10
collection c010ef9c-2483-47c3-83af-8a8c1f72e888 created successfully!
New collection created! Handle: 123456789/11
item e59dfc7a-f96e-4897-a913-e962b220132b created successfully!
New item created! Handle: 123456789/12
New bundle created! UUID: 528d1dd9-ca62-4609-bb2e-1ab367299447
New bitstream created! UUID: 4740048b-25fa-4040-b0d1-4b27f13de75d
All finished with example data creation. Visit your test repository to review created objectsCreditsCreated byKim ShepherdforThe Library Code GmbHwith support from Universität HohenheimLicenseThis work is licensed under theBSD 3-Clause LicenseCopyright 2021 The Library Code GmbH
Package: dspack
Python Package with several DataStrucutes implemented#from ds.sll import *
#from ds.dll import *
#from ds.graph import *
#from ds.avl import *
#from ds.trie import *
#from ds.segmenttree import *
#from ds.inset import *
#from ds.treeset import *
#from ds.avl import *To find about the implementation of datastructure you can use help commands#help(avl)
#help(graph)
#help(bst)
#help(binarytree)
#help(inset)
#help(segmentree)
#help(trie)
#help(sll)
#help(dll)
#help(treeset)
#help(redblacktree)Sample implementaion of the Doubly Linked List Data Structure#arr = [i for i in range(7)]
#dll = dll(arr) 		you can also declare a null dll
#print(dll)
#dll.add(7)
#dll.add(9,1)			add(index = 0 by default,val)
#print(dll)
#dll.remove(9)			dll.remove(val)
#a = dll.getNode(6)		gets pointer to the node
#print(a.data)
#print(len(dll))
#print(dll)
Package: dspam-milter
dspam-milter READMEDSPAM milter is an implementation of the milter interface available in
several MTAs forDSPAM, a statistical spam and content filter for e-mail.
The milter talks to the DSPAM daemon over the regular DSPAM socket, using
the DLMTP protocol.Development of dspam-milter is hosted onGithub, releases can be downloaded
fromPypi. For questions, bugs and patches, please open anissue. You can
also try to send ane-mail.RequirementsPython 2.7 (python)DSPAM running in daemon modepymilter(python-milter)InstallationTo install, runpip installdspam-milterin order to get everything
installed. If you downloaded/forked the git repository, you can usepython setup.py installin the repository root.Milter usageDspam-milter is a ready to use application. The commanddspam-miltershould
have been installed in your path. Behaviour of the daemon can be controlled
by a configuration file. You can create the default config by runningdspam-milter--default-config>/etc/dspam-milter.cfg.In general,dlmtp_*settings under[dspam]need to be configured, and
DSPAM configuration needs to be altered to match these. Details on which
changes need to be made in the DSPAM configuration are also available
in the config file.When the configuration files have been altered and DSPAM is reloaded to enable
the new config, you can run dspam-milter by executingdspam-milter--config/etc/dspam-milter.cfg. There is also an upstart init script available
in the misc/ folder for those running Ubuntu.FeaturesCurrently the package contains:dspam.client: A client (python class) that can talk to a DSPAM daemon over a socket.dspam.milter: A milter application to use DSPAM classification in an MTA.LicenseThe dspam-milter code is available under the New (3-clause) BSD license.
See LICENSE for details.
Package: dsp-basicalgorithms
Package consists of several basic dsp algorithms implemented such as linear convolution,
circular convolution, Discret fourier transform, Auto-Correlation, Cross-Correlation, Fir filter, IIR
filter design.The package helps students to conduct DSP Lab(18ECL57) programs pertaining to
VTU 2018-CBCS scheme with ease.Change Log0.123(20/8/2021)=============Fourth Release
Package: dspbp
Dyson Sphere Program blueprint tool, python bindings.FeaturesLoad and save blueprint files.Replace blueprint items and recipes (partial).Upgrade buildings.Print blueprint info.Example usageimport dspbp
from dspbp import DSPItem

data = open("my_blueprint.txt", "rb").read()
bp = dspbp.load(data)

replacement = {
    DSPItem.IronOre: DSPItem.CopperOre,
    DSPItem.IronIngot: DSPItem.CopperIngot,
}
bp.replace_item(replacement)

open("edited_blueprint.txt", "wb").write(dspbp.save(bp))Brief referencePyBlueprintBlueprint class.DSPItemDSP item enum. Usedir(DSPItem)to get a list of all item types.DSPRecipeDSP recipe enum. Usedir(DSPRecipe)to get a list of all recipes.dspbp.load(data: bytes) -> PyBlueprintLoad a blueprint from abytesobject.dspbp.save(bp: PyBlueprint) -> bytesTurn a blueprint into abytesobject.PyBlueprint.icon_text: strIcon text property. Use it to set blueprint text under the icons.PyBlueprint.get_description(self) -> strGet blueprint description.PyBlueprint.replace_item(self, r: dict[DSPItem, DSPItem])Replace items in the blueprint. Any item with a key inrgets replaced with a
corresponding value.Supports belt labels, logistic station slots and item icons.TODO: inserter filters, splitter filters, traffic monitors.PyBlueprint.replace_item(self, r: dict[DSPRecipe, DSPRecipe])Replace recipes in the blueprint. Any recipe with a key inrgets replaced
with a corresponding value.PyBlueprint.replace_both(self, r: dict[DSPItem, DSPItem])Replace both items and recipes. Items get converted into a most basic recipe.PyBlueprint.replace_building(self, r: dict[DSPItem, DSPItem])Upgrade and downgrade buildings.
Package: dspca
Demixed Subspace Principal Component Analysis (dsPCA)dsPCA is a dimensionality reduction algorithm for high-dimensional data such as neural population activity. dsPCA describes high-dimensional data by finding best demixed linear coding axes for targeted variables and finding linear dimensions that concicely describe the remaining variance in the data. The demixed coding axes for targeted variables are identified with a supervised approach, and then the axes that capture the remaining variance in the data are identified with an unsupervised approach. Importantly, dsPCA completely removes the linear coding of target signals from data before the unsupervised axis identifications. Therefore, dsPCA decomposes a high-dimensional data into a subspace that fully captures all target signals in the data and a subspace that is free of all target signals.
The details of the algorithm can be found in[Hattori and Komiyama,Neuron, 2021]InstallationRun the following command to install the package.pip install dspcaHow to usedsPCA code is written for Python 3.xPlease check an example demo indsPCA_demo.ipynbfor the basic implementation.After installation, import dsPCAfrom dspca.dspca import dsPCAProvide data ([# of observations] X [# of dimensions to be reduced]) and targets ([# of observations] X [# of targets])dsPCA(data=data, targets=targets)The outputs of the function are in the order ofprojection_target_subspace
projection_targetfree_subspace
ax_targets, ax_targetfree
target_subspace_signal
targetfree_subspace_signal
target_subspace_var
targetfree_subspace_var
total_var
dot_target_axprojection_target_subspaceProjection of data onto demixed target signal axes.projection_targetfree_subspaceProjection of population activity to the axes of target-free subspace.ax_targetsAxis vectors for the target signal subspace.ax_targetfreeAxis vectors for the target-free signal subspace.target_subspace_signalPearson correlation coefficient between the projected data along each target axis and the targeted task-related variables.targetfree_subspace_signalPearson correlation coefficient between the projected data along each target-free axis and the targeted task-related variables.target_subspace_varData variance along each taraget axis.targetfree_subspace_varData variance along each taraget-free axis.total_varTotal data variance of the original input data.dot_target_axMatrix with dot products between pairs of target axis vectors.CitationPlease cite the following paper:Hattori, R. and Komiyama, T. (2021). Context-dependent persistency as a coding mechanism for robust and widely distributed value coding.Neuron, doi: 10.1016/j.neuron.2021.11.001.