Saravanan666/pypi-org huggingface dataset:
Package: diff2d
This package is used to calculate 2-dimensional diffusion on a regular grid with the initial conditions
defined in a png file. The border conditions are handeled by rolling over to the oposite edge and using the
value specified there.
This module is the final state in a row of examples for solving the same problem. All examples, shifting the very
first quick&dirty soultion over a function-based version to this version are published in the GIT-project:https://github.com/mmaelicke/diffusion.gitThis module was programmed in order to illustrate proper programming for scientist using an easy to understand
example. It does neither claim to be performant nor comprehensive to solve diffusion problems.
The example was taken from the great book: High Performance Python by Micha Gorelick and Ian Ozsvald (O’Reilly).
[Copyright 2014 Micha Gorelick and Ian Ozsvald, 978-1-449-36159-4].InstallationInstall this package using:UsageThere is a command line tool calleddiffusion.pythat takes an image with the initial conditions as a first
argument, The diffusion parameter D as a second argument, the time step per increment dt as third argument and
the total time steps to be simulated as fourth argument.pythondiffusion.pyimage.pngDdtiterations
Package: diffable-sql
Diffable SQLThis is a small tool that outputs SQL from a number of databases in a sorted, diff-friendly order.InstallThe tool supports any databasethat SQLAlchemy supports.
You must install the correct connector for your database:$ pip install diffable-sql
$ pip install psycopg2-binary # postgres
$ pip install mysqlclient # mysqlUsageYou can pass any number of DSNs as arguments, for examplepostgresql:///db-name. The tool will output normalised SQL
DDL statements for each DSN.$diffable-sqlsqlite:///db.sqlite3
CREATETABLEsometable(fooVARCHAR,idBIGINTNOTNULL);ALTERTABLEsometableADDCONSTRAINTcPRIMARYKEY(id);ALTERTABLEsometableADDCONSTRAINTcUNIQUE(foo);CREATEINDEXiONsometable(foo);Specifically:The tables and columns will be sorted by nameIndexes and constraints will be renamed asiandcDeferrable constraint information will be hiddenIdentity columns will be hiddenThese allow schemas to be more easily diffed.JSON outputPassing--output-format=jsonwill output a json structure for each table, containing information on the column
types, SQL, nullability, indexes and constraints:$poetryrundiffable-sqlsqlite:///tools/db.sqlite3--output-format=json|jqOutputs:{"name":"sometable","database":"tools/db.sqlite3","columns":{"id":{"type":"BIGINT","sql":"id BIGINT NOT NULL","nullable":false},"foo":{"type":"VARCHAR","sql":"foo VARCHAR","nullable":true}},"indexes":[{"name":"foobar","type":"Index","sql":"CREATE INDEX foobar ON sometable (foo)","columns":["foo"],"expressions":[]}],"constraints":[{"name":null,"type":"PrimaryKeyConstraint","sql":"ALTER TABLE sometable ADD PRIMARY KEY (id)","columns":["id"],"expression":null},{"name":null,"type":"UniqueConstraint","sql":"ALTER TABLE sometable ADD UNIQUE (foo)","columns":["foo"],"expression":null}]}Args$diffable-sql--helpUsage: diffable-sql [OPTIONS] [dsn]...Options:--no-rename-indexes TEXT        Don't rename indexes--no-rename-constraints TEXT    Don't rename constraints--no-ignore-deferrable-constraints TEXTInclude deferrable constraint information--no-ignore-identity-columns TEXTDon't ignore identity column information--output-format [sql|json]--help                          Show this message and exit.
Package: diffabs
DiffAbsDiffAbs is a PyTorch implementation of multiple abstract domains that
can be used in certifying or reasoning neural networks. Implemented
purely using PyTorch, it is differentiable and supports GPU by
default, thus amenable for safety/robustness driven training on
abstract domains.Currently, the following abstract domains are implemented:Vanilla interval domain;DeepPoly domain (https://dl.acm.org/doi/10.1145/3290354);Domain notesDeepPoly ReLU heuristics:A variant of the original DeepPoly domain is implemented where the
ReLU approximation is not heuristically choosing between two choices
(either pickingy = xory = 0as the new upper bound). Right
now it is fixed to choosingy = 0, because there was Galois
connection violation observed if this heuristic is
enabled. Basically, it is observed in experiment that a smaller
abstraction may unexpectedly incur larger safety distance than its
containing larger abstraction.Supported systemsAlthough it is currently tested on Mac OS X 10.15 and Ubuntu 16.04
with Python 3.7 and PyTorch 1.5, it should generalize to other
platforms and older PyTorch (perhaps ≥ v1.0) smoothly.However, Python ≤ 3.6 may be incompatible. Because type annotations
are specified everywhere and the type annotation of self class is only
supported by__future__.annotationsin Python 3.7. If using Python
3.6, this needs to use 'type string' instead.InstallationIn your virtual environment, either install directly from this repository bygit clone git@github.com:XuankangLin/DiffAbs.git
cd DiffAbs
pip install -e .or directly install from PyPI:pip install diffabsTestingTest cases for individual abstract domains are under thetests/directory and can be run using commandpytestNote thattorchvisionis needed to run the tests for conv/maxpool layers.LicenseThe project is available open source under the terms ofMIT
License.
Package: diffacto
RequirementsAnacondaPython3.5+Packages needed:numpy 1.10+scipy 0.17+pandas 0.18+networkx 1.10+scikit-learn 0.17+pyteomics3.3+Installation viapippip install diffactoUsagediffacto.py [-h] -i I [-db [DB]] [-samples [SAMPLES]] [-log2 LOG2]
                     [-normalize {average,median,GMM,None}]
                     [-farms_mu FARMS_MU] [-farms_alpha FARMS_ALPHA]
                     [-reference REFERENCE] [-min_samples MIN_SAMPLES]
                     [-use_unique USE_UNIQUE]
                     [-impute_threshold IMPUTE_THRESHOLD]
                     [-cutoff_weight CUTOFF_WEIGHT] [-fast FAST] [-out OUT]
                     [-mc_out MC_OUT]
optional arguments:
-h, --help            show this help message and exit
-i I                  Peptides abundances in CSV format. The first row
                      should contain names for all samples. The first column
                      should contain unique peptide sequences. Missing
                      values should be empty instead of zeros. (default:
                      None)
-db [DB]              Protein database in FASTA format. If None, the peptide
                      file must have protein ID(s) in the second column.
                      (default: None)
-samples [SAMPLES]    File of the sample list. One run and its sample group
                      per line, separated by tab. If None, read from peptide
                      file headings, then each run will be summarized as a
                      group. (default: None)
-log2 LOG2            Input abundances are in log scale (True) or linear
                      scale (False) (default: False)
-normalize {average,median,GMM,None}
                      Method for sample-wise normalization. (default: None)
-farms_mu FARMS_MU    Hyperparameter mu (default: 0.1)
-farms_alpha FARMS_ALPHA
                      Hyperparameter weight of prior probability (default:
                      0.1)
-reference REFERENCE  Names of reference sample groups (separated by
                      semicolon) (default: average)
-min_samples MIN_SAMPLES
                      Minimum number of samples peptides needed to be
                      quantified in (default: 1)
-use_unique USE_UNIQUE
                      Use unique peptides only (default: False)
-impute_threshold IMPUTE_THRESHOLD
                      Minimum fraction of missing values in the group.
                      Impute missing values if missing fraction is larger
                      than the threshold. (default: 0.99)
-cutoff_weight CUTOFF_WEIGHT
                      Peptides weighted lower than the cutoff will be
                      excluded (default: 0.5)
-fast FAST            Allow early termination in EM calculation when noise
                      is sufficiently small. (default: False)
-out OUT              Path to output file (writing in TSV format).
-mc_out MC_OUT        Path to MCFDR output (writing in TSV format).
                      (default: None)ExampleExamples are given in theexampledirectory.
Package: diff-and-patch
A simple python package which serves as a framework for diffing and patching complex objects. Inspired by Shreyas Kulkarni and git diff and patch.Quick linksPyPi:https://pypi.org/project/diff-and-patch/Source:https://github.com/thulasi-ram/diff-and-patchDocs:https://github.com/thulasi-ram/diff-and-patch
Package: diffbot
How to use it:>>>importdiffbot>>>json_result=diffbot.article('https://github.com',token='…')The above simple example is a shortcut for using thediffbot.Clientclass.>>>importdiffbot>>>client=diffbot.Client(token='…')>>>json_result=client.article('https://github.com')The above calls are shortcuts for using thediffbot.api()function
and thediffbot.Client.apimethod:>>>importdiffbot>>>client=diffbot.Client(token='…')>>>json_result=client.api('article','https://github.com')ToPOSTdata (text or HTML) to the API, use thetextorhtmlarguments:>>>importdiffbot>>>client=diffbot.Client(token='…')>>>json_result=client.api('article','https://github.com',html='''
... <h1>Introducing GitHub Traffic Analytics</h1>
... <p>We want to kick off 2014 with a bang, so today we're happy to launch
... traffic analytics!</p>
... ''')Command line interface:$pythondiffbot.py-husage:diffbot.py[-h][-a][-fFILE]apiurltokenpositionalarguments:apiAPItocall.Oneoneof'article','frontpage','product','image','analyze'or'discussion'.urlURLtopassasthe'url'parameter.tokenAPIkey(token).Getoneathttps://www.diffbot.com/.optionalarguments:-h,--helpshowthishelpmessageandexit-a,--allRequestallfields.-fFILE,--fileFILEFiletoreaddatafrom.Use'-'toreadfromSTDIN.$pythondiffbot.pyarticlehttps://github.comTOKENOutput of the above example:{"icon":"https://github.com:443/apple-touch-icon-144.png","sections":[…],"title":"Build software better, together.","url":"https://github.com/"}Features:Python 2+3 supportGoogle App Engine supportRequestssupport (but no dependency)Passespyflakes,pep8,flake8,pylintscore 10/10Simple & small (1 file, <200 LOC)Command line interface
Package: diffbot-kg
Diffbot Knowledge Graph ClientDescriptionPython client for the Diffbot Knowledge Graph API.Installationpipinstalldiffbot-kgUsagefromdiffbot_kgimportDiffbotSearchClient,DiffbotEnhanceClientsearch_client=DiffbotSearchClient('your_api_key')enhance_client=DiffbotEnhanceClient('your_api_key')# Search for entitiessearch_results=search_client.search({query='type:Organization name:Diffbot'})# Enhance an entityenhanced_entity=enhance_client.enhance({query='type:Organization name:Diffbot'})ContributingContributions to this project are welcome. - see the CONTRIBUTING.md file for details.LicenseThis project is licensed under the MIT License - see the LICENSE file for details.
Package: diffcalc-core
Python implementation of angle calculations for six-circle X-ray or neutron
diffractometer that follows a model described in[You1999].Free software: Apache Software License 2.0Documentation:https://diffcalc-core.readthedocs.io.This package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.References[You1999]H. You.Angle calculations for a ‘4S+2D’ six-circle diffractometer.J. Appl. Cryst. (1999).32, 614-623.(pdf link).
Package: diffcool
diffcoolINTRODUCTIONdiffcool is a calculator of cool/mcool files provided by Hi-C processing software.
This software generates Hi-C visualization tool-compatible mcool files.INSTALLpip install diffcoolUSAGEdiffcool.py [-h] [-i mcool files [mcool files ...]] [-c control mcool files] [-t treated mcool files] [-o directory] [--resolution RESOLUTION] [--verbose]Options:
  -h, --help            show this help message and exit
  -i mcool files [mcool files ...]
                        mcool files
  -c control mcool files
                        mcool file
  -t treated mcool files
                        mcool file
  -o directory          output directory
  --resolution RESOLUTION
                        resolution
  --verbose
Package: diffcord
Diffcord Python SDKA Python wrapper for the Diffcord API written in Python.Installationpip install diffcordPycord ExamplefromdiffcordimportClient,VoteWebhookListener,UserBotVote,UserVoteInformationimportdiscordintents=discord.Intents.default()bot=discord.Bot(intents=intents)asyncdefsend_stats_success():""" Handle stats successfully sent to Diffcord"""print("Stats sent successfully!")asyncdefsend_stats_failure(e:Exception)->None:""" Handle stats failed to send to Diffcord error"""print("Stats failed to send:",e)asyncdefon_vote(vote:UserBotVote)->None:""" Handle the vote."""# LOGIC HERE... (give rewards, etc.)# example: send a DM to the user who voteduser=awaitbot.fetch_user(vote.user_id)# Get the discord user object from the user idawaituser.send("Thanks for voting!")# Send a DM to the user who voted# create Diffcord client & webhook listener# "port" represents the port to listen on for incoming vote webhooks from Diffcord, choose any port you would like which is not in usediff_webhook_listener=VoteWebhookListener(port=8080,handle_vote=on_vote,verify_code="WEBHOOK_AUTH_CODE_HERE")diff_client=Client(bot,"YOUR_DIFFCORD_API_TOKEN",diff_webhook_listener,send_stats_success=send_stats_success,send_stats_failure=send_stats_failure)bot.diff_client=diff_client# on startup event@bot.eventasyncdefon_ready():# start the webhook listener & start send statsawaitdiff_client.start()# required@bot.slash_command(name="example")asyncdefexample_command(ctx):# get user vote infouser_vote_info:UserVoteInformation=awaitdiff_client.get_user_vote_info(ctx.author.id)# get amount of bot votes this monthbot_votes_this_month:int=awaitdiff_client.bot_votes_this_month()# respondmessage=f"You have voted{user_vote_info.monthly_votes}times this month! This bot has{bot_votes_this_month}votes this month!"awaitctx.respond(message)bot.run("YOUR_BOT_TOKEN")
Package: diffcsv
![PyPI](https://img.shields.io/pypi/v/diffcsv.svg) [![Build Status](https://travis-ci.org/ugursogukpinar/diff-csv.svg?branch=master)](https://travis-ci.org/ugursogukpinar/diff-csv)# diffcsvIt finds differences between two version of a csv file which are built with same structure.### Requirements---- Python 3.x### Setup---```$ pip install diffcsv```### Usage---```diffcsv [-h] [--primary-key PRIMARY_KEY][--based-on BASED_ON [BASED_ON ...]] [--delimiter DELIMITER]old_csv new_csvpositional arguments:old_csv               Path of old csv filenew_csv               Path of new csv fileoptional arguments:-h, --help            show this help message and exit--primary-key PRIMARY_KEYCommon key of two csv files--based-on BASED_ON [BASED_ON ...]--delimiter DELIMITERDelimiter of csv files```Example:- version-1.csv```id,key,value,created_at1,key-1,value-1,2018-01-012,key-2,value-2,2018-02-01```- version-2.csv```id,key,value,created_at1,key-1,value-1-altered,2018-01-013,key-3,value-3,2018-02-02```Run:```bash$ diffcsv /path/of/version-1.csv /path/of/version-2.csv --primary-key id --based-on key value```Output:```"id","key","value","created_at","DIFF_STATUS""2","key-2","value-2","2018-02-01","DELETED""3","key-3","value-3","2018-02-02","INSERTED""1","key-1","value-1-altered","2018-01-01","UPDATED"```### Contributers[**Kaan ant**](https://github.com/kaanant)
Package: diffdir
diffdirInstallationpipinstalldiffdirUsagediffdir[--ignorestring_to_ignore]dir_adir_bInterfaceSuppose$treedir_a
dir_a
├──common.txt
└──foo└──end$treedir_b
dir_b
├──bar
│└──end
└──common.txtThenOnlyindir_a:/fooOnlyindir_b:/bar(0)Diffdir_adir_b/common.txt(q)Quit;(d)Diffall;(dX)DifflineXLicenseMIT License

Copyright (c) [year] [fullname]

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, 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 THE
SOFTWARE.
Package: diffeq-solver-tk
diff-eq-solverAn application that uses the finite difference method to solve various types of differential equations, such as the
heat equation and wave equation. The solution is written to a table in an Excel file, and the solution is visually
displayed on a plot. For time dependent PDEs, the plot is animated.Installationpip3 install diffeq-solver-tkUsageThe GUI can be started withdetk. Once you open the solver, choose a differential equation type through the
navigation bar above and enter the parameters for your equation. Clicking "Solve" will run the solving algorithm
for your equation and generate a static plot in the right window. After a solution is prepared, you can export the
solution as an xlsx file by clicking "Export". For partial differential equation types, you can play an animation
in the right window by clicking "Play" and switch back to the static plot by clicking "Show Plot".diffeq-solver-tk can also be used in the command-line by runningdetk solve <diff-eq-type> <infile> <outfile>.
Examples of valid<infile>files are provided intests/queries.Dev WikiFirst order differential equationsSecond order differential equationsOne-dimensional Heat EquationOne-dimensional Wave Equation
Package: diffeqtorch
diffeqtorchBridgesDifferentialEquations.jlwith PyTorch. Besides benefitting from the huge range of solvers available inDifferentialEquations.jl, this allows taking gradients through solvers usinglocal sensitivity analysis/auto-diff. The package has only been tested with ODE problems, and in particular, automatic differentiation is only supported for ODEs usingForwardDiff.jl. This can be extended in the future,contributions are welcome.ExamplesSimple ODE problem to demonstrate the interface and confirm gradients with analytical solutionSIR model for a slighlty more complicated model with numerical gradient checkingHodgkin-Huxley model for a realistic example from NeuroscienceInstallationPrerequisites for usingdiffeqtorchare installation of Julia and Python. Note that the binary directory ofjulianeeds to be in yourPATH.Installdiffeqtorch:$ pip install diffeqtorch
$ export JULIA_SYSIMAGE_DIFFEQTORCH="$HOME/.julia_sysimage_diffeqtorch.so"
$ python -c "from diffeqtorch.install import install_and_test; install_and_test()"We recommend using a custom Julia system image containing dependencies. By setting the environment variableJULIA_SYSIMAGE_DIFFEQTORCH, an image will be created and used automatically. This may take a while but will improve speed afterwards.UsagefromdiffeqtorchimportDiffEqf="""function f(du,u,p,t)du[1] = p[1] * u[1]end"""de=DiffEq(f)u0=torch.tensor([1.])tspan=torch.tensor([0.,3.])p=torch.tensor([1.01])u,t=de(u0,tspan,p)See alsohelp(DiffEq)and examples provided innotebooks/.LicenseMIT
Package: diffeqzoo
diffeqzooSo, what was the initial condition of the restricted three-body problem again?diffeqzoodelivers all differential equation test problems in one place. It works with numpy and jax.InstallationGet the most recent stable version from PyPi:pip install diffeqzooOr directly from GitHub:pip install git+https://github.com/pnkraemer/diffeqzoo.gitThese commands assume that NumPy or JAX are installed separately by the user.
Read more about installing this packagehere.Features includeOscillating systems (Lotka-Volterra, Fitzhugh-Nagumo, Van-der-Pol, ...)Chaotic systems (Lorenz63, Lorenz96, Roessler, ...)Epidemiological models (SIR, SEIR, SIRD, ...)N-Body problems and celestial mechanics (Rigid-body, restricted-three-body, Pleiades, Henon-Heiles, ...)Chemical reactions (HIRES, ROBER, ...)Boundary value problemsAs well asFlexibly NumPy and JAX-backends. Other than one of those two, there are 0 (zero!) dependencies.Mathematical descriptionsand BibTex entriesof the ODE problemsCompatibility with all NumPy/JAX-based ODE solvers: SciPy, JAX, Diffrax, ProbNum, Tornadox, etc..and many more goodies.DOCUMENTATION:documentationISSUE TRACKER:issue trackerQuick example>>>fromdiffeqzooimportivps,backend>>>backend.select("numpy")>>>>>># Create test problems like this>>>f,u0,t_span,f_args=ivps.lotka_volterra()>>>x=f(u0,*f_args)>>>print(x)[-10.10.]>>>>>># The numpy backend determines the type of input/output>>>print(type(x))<class'numpy.ndarray'>>>>>>># All sorts of ODEs are available, e.g., Rigid-Body:>>>f,u0,t_span,f_args=ivps.rigid_body()>>>print(f(u0,*f_args))[-0.1.125-0.]>>>>>>## make it jax>>>backend.change_to("jax")>>>f,u0,t_span,f_args=ivps.rigid_body()>>>x=f(u0,*f_args)>>>print(x)[-0.1.125-0.]>>>print(type(x))<class'jaxlib.xla_extension.ArrayImpl'>Similar projectsF. Mazzia et al. published atest set for IVP solversfor Matlab and Fortran.
There is a similartest set for BVP solvers. Neither one offers Python code, and both also run benchmarks, whichdiffeqzoodoes not care about at all.E. Hairer et al. published theirstiff ODE test set, but there is no Python codeNonlinearBenchmarkhosts datasets of nonlinear dynamical system observations. They are quite specialised problems, and don't contain the textbook problems like Lotka-Volterra, van der Pol, etc..DifferentialEquations.jl providesexample ODE problemsin Julia.ProbNum's problem zoooffers a similar set of problems todiffeqzoo(no surprise -- the set of authors intersects) but tied to ProbNum's ODE solver interface.diffeqzoois less of an API, switches more flexibly between numpy and jax (at the time of developing), and contains more problems.W. Gilpinpublished a benchmarkfor forecasting and data-driven modeling, which comes with a large number of (mostly chaotic) dynamical systems.J. Meier lists a number of ODE attractorson his website.GeometricProblems.jl curates a similar list of example problems with interesting geometric structure, in Julia (link)Anything missing in this list? Please open an issue or make a pull request.
Package: differ
Python library to calculate differences between objects.Right now, it supports calculating differences between objects built
up of dicts, lists, tuples and base types.The major advantage compared to other diff tools is it is able to detect
“slightly” changed objects that were repositioned in a list:fromdifferimportcompare_objectsseq1=[{'a':1,'b':1,'c':1},{'a':2,'b':2,'c':2},{'a':3,'b':3,'c':3},]seq2=[{'a':30,'b':30,'c':3},{'a':2,'b':20,'c':2},{'a':1,'b':1,'c':10},]diff=compare_objects(seq1,seq2)Result:{'added':[],'changed':[0,1,2],'distance':1.0,'equal':[],'removed':[],'total':3,'changes':{0:{'diff':{'added':[],'changed':['c'],'changes':{'c':{'distance':1.0,'left':1,'right':10}},'distance':0.3333333333333333,'equal':['a','b'],'removed':[],'total':3},'distance':0.3333333333333333,'pos':2},1:{'diff':{'added':[],'changed':['b'],'changes':{'b':{'distance':1.0,'left':2,'right':20}},'distance':0.3333333333333333,'equal':['a','c'],'removed':[],'total':3},'distance':0.3333333333333333,'pos':1},2:{'diff':{'added':[],'changed':['a','b'],'changes':{'a':{'distance':1.0,'left':3,'right':30},'b':{'distance':1.0,'left':3,'right':30}},'distance':0.6666666666666666,'equal':['c'],'removed':[],'total':3},'distance':0.6666666666666666,'pos':0}}}Changelogv0.1.4AddedCHANGELOG.rstto distributed files (that was the problem!)v0.1.3Fixed issues with*.rstloading forlong_description.v0.1.1Initial version, with support for base objects.