Saravanan666/pypi-org huggingface dataset:
Package: deltacloud
A Python client forDeltacloud APIREST interface.FeaturesBasic operations with images, instances, hardware-profiles and realmsManage instances using start, stop, destroy and reboot operationsCreate new instance from imageInstallpip install deltacloudExamplesLaunching an instancefrom deltacloud import Deltacloud
client = Deltacloud('http://localhost:3001/api', 'mockuser', 'mockpassword')
instance = client.create_instance('img1', {'hwp_id': 'm1-small'})Listing images/hardware profiles/realms/instancesprint(client.images())
print(client.hardware_profiles())
print(client.realms())
print(client.instances())Stopping an instanceinstance = client.instances()[0]
instance.stop()ContributionsMichal FojtikTomas SedovicMartin PackmanLicenseLicensed under Apache License, Version 2.0 Copyright (C) 2009  Red Hat, Inc.Seehttp://www.apache.org/licenses/LICENSE-2.0
Package: deltacloud_heat
Deltacloud backend for Heat===========================`Heat(http://heat-api.org/)`_ brings orchestration, autoscaling and high availability to `OpenStack(http://www.openstack.org/)`_. Since January 2013, it's possible to configure Heat to use a backend other than OpenStack.This project makes `Deltacloud(http://deltacloud.apache.org/)`_ into a backend Heat that can use. This means you can utilise Heat to provision your deployments on oVirt, EC2, Rackspace and `anything else that Deltacloud supports(http://deltacloud.apache.org/supported-providers.html)`_.Prerequisities--------------* `Deltacloud server 1.1.0 or higher(http://deltacloud.apache.org/download.html)`_* `Heat ``2013.1.g3`` or higher(https://github.com/openstack/heat/tags)`_(i.e. what's going to be the G release. You have to build it from source for now)Setup-----#. Install the Deltacloud server and start it#. Install Heat#. ``pip install deltacloud_heat``#. Add this line to `/etc/heat/heat-engine.conf`::cloud_backend=deltacloud_heat#. Add the following lines to `/etc/heat/heat-api.conf`::[paste_deploy]flavor = custombackend#. Start Heat engine, API and all the other services.Authentication--------------Pass the username, password and Deltacloud entrypoint url via the `X-Auth-User`, `X-Auth-Key` and `X-Auth-URL` HTTP headers to the Heat API requests:curl -v -H 'accept: application/json' -H 'content-type: application/json' \-H 'x-auth-user: mockuser' -H 'x-auth-key: mockpassword' \-H 'x-auth-url: http://localhost:3002/api' \http://localhost:8004/v1/admin/stacksDevelopment status------------------Extremely early. Don't expect anything to work at this time. Bugs, comments, patches are very much welcome.License-------Apache License, version 2.0
Package: deltacode
BranchLinux (Travis)developDeltaCode is a simple command line utility that leverages the power
ofscancode-toolkitto determine file-level differences between two codebases.During a typical software release cycle, development teams and software
compliance experts want insight into how a codebase has changed during each
release iteration. Specifically, these users need a utility that can point out
places in a codebase where material license and other provenance changes have
occurred. This is where DeltaCode comes in.DeltaCode provides an accurate means of comparing two ScanCode result files,
and returning any possible changes that have occurred between the two given
scanned codebases. DeltaCode currently has the ability to detect file size and
license changes, as well as means to detect when files have been moved to new
locations.We are continuously working on new features, such as detecting copyright changes
and detecting package version changes.Quick StartFor more comprehensive installation instructions and development instructions, see:Comprehensive InstallationFor development instructions, see:Development InstructionsMake sure you have Python 2.7 installed:Download and install Python 2.7 32 bits for Windowshttps://www.python.org/ftp/python/2.7.14/python-2.7.14.msiDownload and install Python 2.7 for Machttps://www.python.org/ftp/python/2.7.14/python-2.7.14-macosx10.6.pkgDownload and install Python 2.7 for Linux via distro package managerNext, download and extract the latest DeltaCode release from:https://github.com/nexB/deltacode/releases/Open a terminal, extract the downloaded release archive, thencdto
the extracted directory and run this command to display the command
help. DeltaCode will self-configure if needed:./deltacode --helpRun a sample delta./deltacode -n samples/samples.json -o samples/samples.jsonRun a simple delta saved to theoutput.jsonfile:./deltacode -n samples/samples.json -o samples/samples.json -j output.jsonThen openoutput.jsonto view the delta results.To get DeltaCode results for your codebase, installscancode-toolkitand generate a
scan for each of the codebases you wish to ‘Delta’SupportIf you have a problem, a suggestion or found a bug, please enter a ticket at:https://github.com/nexB/deltacode/issuesFor other questions, discussions, and chats, we have:an official Gitter channel athttps://gitter.im/aboutcode-org/discussGitter also has an IRC bridge athttps://irc.gitter.im/an official #aboutcode IRC channel on freenode (server chat.freenode.net)
for DeltaCode and other related tools. Note that this receives
notifications from repos so it can be a tad noisy. You can use your
favorite IRC client or use the web chat athttps://webchat.freenode.net/Source codehttps://github.com/nexB/deltacode.gitLicenseApache-2.0 with an acknowledgement required to accompany the delta output.See the NOTICE file for more details.Documentation & FAQhttps://github.com/nexB/deltacode/wiki
Package: delta-coding
Python package implementing delta coding.How do I install this package?As usual, just download it using pip:pipinstalldelta_codingTests CoverageSince some software handling coverages sometime get slightly different results, here’s three of them:Usage examplefromdelta_codingimportdelta_codingdelta_coding(0)# 1delta_coding(1)# 0100delta_coding(2)# 0101delta_coding(3)# 01100delta_coding(4)# 01101delta_coding(5)# 01110delta_coding(6)# 01111delta_coding(7)# 00100000delta_coding(8)# 00100001
Package: deltadash
deltadash.pyA simple, dependency-less library for programatically interfacing with DeltaDash's file formats.Current featuresdeltadash.py currently includes the following features:Difficulty reading and deserialisationDifficulty writing and deserialisationExampleHere is an example of how to read, modify and write a DeltaDash map through the deltadash.py library!# deltadash.py map reading examplefromdeltadash.maps.difficultyimportDifficulty# Read a .dd filediff=Difficulty.from_file("test_res/debug.dd")# Print the difficulty's full nameprint(diff.full_name)# Change the difficulty namediff.name="New Name"# Write the difficulty to a new filediff.into_file("test_res/debug_new.dd")You may view more examples in theexamplesdirectory of this repo!
Package: deltadask
deltadaskA connector for reading Delta Lake tables into Dask DataFrames.Install withpip install deltadask.Read a Delta Lake into a Dask DataFrame as follows:importdeltadaskddf=deltadask.read_delta("path/to/delta/table")It's a lot more efficient for Dask to read a Delta table compared to a Parquet data lake.  Parquet tables are of course faster than CSV tablesas explained in this video.  Delta tables are the next big performance improvement for Dask users.Basic usageSuppose you have a Delta table with the following three versions.Here's how to read the latest version of the Delta table:deltadask.read_delta("path/to/delta/table").compute()id
0   7
1   8
2   9And here's how to read version 1 of the Delta table:deltadask.read_delta("path/to/delta/table",version=1).compute()id
0   0
1   1
2   2
0   4
1   5Delta Lake makes it easy to time travel between different versions of a Delta table with Dask.Seethis notebookfor a full working example with an environment so you can replicate this on your machine.Why Delta Lake is better than Parquet for DaskA Delta table stores data in Parquet files and metadata in a trasaction log.  The metadata includes the schema and location of the files.A Dask Parquet data lake can be stored in two different ways.Parquet files with a single metadata fileParquet files without a metadata fileParquet files with a single metadata file is bad because of scaling limitations.Parquet files without a metadata file require expensive file listing / Parquet footer queries to build the overall metadata statistics for the data lake.  It's a lot faster to fetch this information from the Delta transaction log.Delta Lake is better because the transaction log is scalable and can be queried must faster than a data lake.How to make reads fasterYou can make Delta Lake queries faster by using column projection and predicate pushdown filtering.  These tactics allow you to send less data to the cluster.Here's an example of how to query a Delta table with Dask and take advantage of column pruning and predicate pushdown filtering:ddf=deltadask.read_delta("path/to/delta/table",columns=["col1"],# column pruningfilters=[[('col1','==',0)]]# predicate pushdown)This query only sendscol1to the cluster and none of the other columns (column projection).This query also uses the transaction log to idenfity files that at least contain some data withcol1equal to zero.  If a file contains no matching data, then it won't be read.  Depending on how the data is organized, a lot of files can be skipped.  You can skip the number of files even more by partitioning or Z ORDERING the data.How this library is builtThedelta-rslibrary makes it really easy to build the deltadask connector.All the transaction log parsing logic is handled by delta-rs.  You can just plug into the APIs to easily build the Dask connector.
Package: deltae
deltaeWritten in Python.Requires 3.6 or greater (uses f-strings)Currently has DeltaE1976, DeltaE2000 with the others looking to be implemented in the future.Based on the whitepaper by Gaurav Sharma, Wencheng Wu and Endul N. Dala from the University of Rochester NYUser Dependancies:NoneDev Dependancies:Pandas for creating test_functions.pyBackgroundUses the data set provided from:http://www2.ece.rochester.edu/~gsharma/ciede2000/dataNprograms/CIEDE2000.xlsto test against. (converted to csv as rochester_data.csv)Based on using Bruce Lindblooms (http://www.brucelindbloom.com/) DE2000 calcuation. Then updated with the maths from the Rochester white paper.It seems as though Rochester uses a different calculation for hPrime, h1Prime, h2Prime and hBarPrime than Bruce. However the whole dataset does return the correct deltae2000 values for both formulas. Perhaps there are some combinations of lab values that would be different.InstallationPip:pip install deltaeExample Usage:importdeltaeTakes CIELAB values as a dictionary - example below:Lab1={'L':50.00,'a':2.6772,'b':-79.7751}Lab2={'L':50.00,'a':0.00,'b':-82.7485}Get the DeltaE 1976 Formula of 2 Lab Values:deltae.delta_e_1976(Lab1,Lab2)Get the DeltaE 2000 Formula of 2 Lab Values:deltae.delta_e_2000(Lab1,Lab2)
Package: deltae2000
deltae2000 is an implementation of the CIEDE2000 algorithm to calculate the perceptual
distance between two colours. This is implemented in pure Python with the intention to
run optimal on the PyPy interpreter.See theWikipedia articlefor
more information on the distance calculation.Example usage:fromdeltae2000importdelta_e_cie2000fromcolormath.color_conversionsimportconvert_colorfromcolormath.color_objectsimportsRGBColor,LabColordelta_e_cie2000(convert_color(sRGBColor(255,0,0,is_upscaled=True),LabColor),convert_color(sRGBColor(125,255,125,is_upscaled=True),LabColor))This is based on the implementation fromcolormathwhich uses Numpy in the implementation. Use the colormath version if you are using the
CPython interpreter.
Package: delta-env
delta-envThis is a very simple tool to report environment variable changes when a shell script is sourced. Useful while creatingmodulefilesfor various applications that are shipped with scripts that set up the user environment.This package does not depend on any additional python packages, only requirement ispython > 3.0.0.Does not work on Windows operating system.What the tool does is simply sourcing the given script and reporting differences from the default environment variables in an organized way.WARNINGThis tool WILL carry out the actions in the given script to be analyzed. If it is of harmful nature, damage will be done. Do NOT run this tool asroot. Do NOT run this tool with scripts that are of unknown/unstrusted sources!InstallationClone this repository,cdinto the cloned directory, and install viapip,pip install .UsageThis tool is meant to be used from the command line via the executabledelta-env,delta-env <path-to-script>The output will be displayed in the terminal screen, reporting added, removed and modified environment variables seperately.By default, modifications are reported with respect to thedefault user environmentthat is present after creation of a login shell. This behaviour can be changed by using the--from-currentargument to use the current environment (wheredelta-envis executed) as basis. Note that environment variables that were created without theexportcommand will not be passed to subprocesses, and hence will not be visible todelta-env.If no shell executable is supplied via--shell <path-to-shell>argument, it is obtained from the value of environment variableSHELL.
Package: delta-hydro
hydro 💧hydro is a collection of Python-basedApache SparkandDelta Lakeextensions.SeeKey Functionalityfor concrete use cases.Warning ⚠️hydro is well tested but not battle hardened, yet. Use it at your own risk.Installationpip install delta-hydroDocs 📖https://christophergrant.github.io/delta-hydroKey Functionality 🔑De-duplicate a Delta Lake table, in-place, without a full overwrite -hydro.delta.deduplicateCorrectly performSlowly Changing Dimensions (SCD)(types 1 or 2) on Delta Lake tables -hydro.delta.scdandhydro.delta.bootstrap_scd2Issue queries against Delta Log metadata, quickly and efficently getting things like partition sizes on huge tables -hydro.delta.partition_statsOther quality of life improvements likehydro.delta.detail_enhancedandhydro.spark.fieldsContributions ✨Contributions are welcome.Pleasecreate an issueand discuss before starting work on a feature to make sure that it aligns with the future of the project.Naming 🤓hydrois short for hydrologist, where a hydrologist is a person who studies water and its movement. Delta Lake, Data Lake, Lakehouse => water.ChatGPT and LLMs 🤖Some of this project's code and documentation was generated by a LargeLanguage Model(LLM), namelyChatGPT.We are proud prompt engineers, so we display the prompt that gave us the code in hydro's source (example).APIsThe topic of  SQL vs  DataFrames is a hot one in the data space.SQL certainly has its place in analytic and other ad-hoc use cases, but it is missing the expressive power of an imperative language.This project is a testament to the power of the mix of imperative and declarative expression that DataFrames give. A lot of this code would be very verbose or impossible to express with SQL.
Package: deltalake
Deltalake-pythonNativeDelta LakePython binding based ondelta-rswithPandasintegration.ExamplefromdeltalakeimportDeltaTabledt=DeltaTable("../rust/tests/data/delta-0.2.0")dt.version()3dt.files()['part-00000-cb6b150b-30b8-4662-ad28-ff32ddab96d2-c000.snappy.parquet','part-00000-7c2deba3-1994-4fb8-bc07-d46c948aa415-c000.snappy.parquet','part-00001-c373a5bd-85f0-4758-815e-7eb62007a15c-c000.snappy.parquet']See theuser guidefor more examples.InstallationpipinstalldeltalakeNOTE: official binary wheels are linked against openssl statically for remote
objection store communication. Please file Github issue to request for critical
openssl upgrade.Build custom wheelsSometimes you may wish to build custom wheels. Maybe you want to try out some
unreleased features. Or maybe you want to tweak the optimization of the Rust code.To compile the package, you will need the Rust compiler andmaturin:curlhttps://sh.rustup.rs-sSf|sh-s
pipinstallmaturinThen you can build wheels for your own platform like so:maturinbuild--release--outwheelsFor a build that is optimized for the system you are on (but sacrificing portability):RUSTFLAGS="-C target-cpu=native"maturinbuild--release--outwheelsCross compilationThe above command only works for your current platform. To create wheels for other
platforms, you'll need to cross compile. Cross compilation requires installing
two additional components: to cross compile Rust code, you will need to install
the target withrustup; to cross compile the Python bindings, you will need
to installziglang.The following example is for manylinux2014. Other targets will require different
Rusttargetand Pythoncompatibilitytags.rustuptargetaddx86_64-unknown-linux-gnu
pipinstallziglangThen you can build the wheel with:maturinbuild--release--zig\--targetx86_64-unknown-linux-gnu\--compatibilitymanylinux2014\--outwheelsIf you expect to only run on more modern system, you can set a newertarget-cpuflag to Rust and use a newer compatibility tag for Linux. For example, here
we set compatibility with CPUs newer than Haswell (2013) and Linux OS with
glibc version of at least 2.24:RUSTFLAGS="-C target-cpu=haswell"maturinbuild--release--zig\--targetx86_64-unknown-linux-gnu\--compatibilitymanylinux_2_24\--outwheelsSee note aboutRUSTFLAGSfromthe arrow-rs readme.
Package: delta-lake-trello-qxf2
Data pipeline using Delta Lake tablesWe have implemented the medallion architecture by using Delta Lake tables to store and analyse our Trello data.Bronze Delta Lake tables (Ingestion) - The raw data of all the cards of Trello boards and the Trello board members is ingested into these tables
Silver Delta Lake tables (Refinement) - The data from the Bronze tables is refined to pick required columns, join with the members lookup delta table and add board info
Gold Delta Lake tables (Aggregation) - Built based on specific use case. Eg: One of the tables consist of all the cards that are in doing list have no activity for specified number of days
Package: deltalanguage
DeltalanguageDeltalanguage allows the programmer to represent their computational model as a graph.
It allows the definition of heterogenous compute elements as well the transport mechanism between them.
Depending on which type of hardware a part of the program is running on,
the nodes of this graph get coded with Python (for the CPU) or Migen
(for the FPGAs).
A hardware abstraction layer is built into the language, that standardises
which operations can be triggered on qubits.
This makes Deltaflow portable across technologies.Deltalanguage is used by the Deltaflow-on-ARTIQ system, documentation
for this system and all its components can be foundhere.Quick LinksDocumentationPyPIGitHubRiverlane WebsiteOfficial Deltaflow DiscordContact UsIf you experience version incompatibilities, have feature requests or just want
to talk to our team about this project: send us anemail.
Package: deltaman
Deltaman - Parsing human time intervalspipinstalldeltamanGetting Startedfromdeltamanimportdelta_parserfordeltain("15s","3min","1h15m","1 day 12 hours","1m-15s"):parsed=delta_parser.parse(delta)print(f'{delta!r:20s}{parsed!r:20s}')That outputs'15s'                datetime.timedelta(seconds=15)
'3min'               datetime.timedelta(seconds=180)
'1h15m'              datetime.timedelta(seconds=4500)
'1 day 12 hours'     datetime.timedelta(days=1, seconds=43200)
'1m-15s'             datetime.timedelta(seconds=45)Note you can get more examples from the testing files.Testing$pytestOr$tox
Package: delta-nlp
DELTA - A DEep learning Language Technology plAtformDELTA is a deep learning based end-to-end natural language and speech processing platform. DELTA aims to provide easy and fast experiences for using, deploying, and developing natural language processing and speech models for both academia and industry use cases. DELTA is mainly implemented using TensorFlow and Python 3.Refer to github for more information:https://github.com/didi/delta
Package: delta-of-delta
Delta Of Delta EncodingThis has simple implementation of various ways to encoding timestamps used in time series databases.Rundelta-of-delta-demoto see examples of the output.Timestamp EncodingThis is the simplest encoding scheme, in this one we just store the timestamps. This is inefficient
because the raw bytes of successive timestamps only change a little over time.This can be used with thetimestamp_encodefunction or used when streaming data with theEncoderclass.Example:Input[1496163646, 1496163676, 1496163706, 1496163735, 1496163765]Output[1496163646, 1496163676, 1496163706, 1496163735, 1496163765]Delta EncodingThis scheme stores the initial timestamp and the differences between them. This helps because we use less
memory to store the delta instead of the whole timestampThis can be used with thedelta_encodefunction or used when streaming with theDeltaEncoderclass.Example:Input[1496163646, 1496163676, 1496163706, 1496163735, 1496163765]Output[1496163646, +30, +30, +29, +30]Delta of Delta EncodingThis scheme is based on Facebook's Gorilla time-series database and is also found in Prometheus. In this case
we know use the fact that we know that most entries come in at a constant rate (because we are collecting
metrics) we only store the delta of the time between this timestamp and the previous timestamp and the
time between the previous timestamp and the one before that. Most of the data coming in will be zeros
and therefore we will get a high compression rate.This can be used with thedelta_of_delta_encodefunction or when streaming with theDeltaOfDeltaEncoder.Example:Input[1496163646, 1496163676, 1496163706, 1496163735, 1496163765]Output[1496163646, +30, 0, -1, +1]The Encoder and Decoder classesThe Encoder and Decoder classes are stateful encoders and decoder that can be used to handle streaming
timestamps. The Encoder will record your initial timestamp in.initial_timestampfor easy decoding. You
initialize these classes with a timestamp and then as you pass in a new timestamp it will return the
encoded/decoded representation.The Encoding dataclassThe Encoding data class is a data structure that represents the timestamp stream encoded in some format.
They all have.initial_timestampproperty that holds the first timestamp in the series and then a
second property that is a list of the following values. (called.timestamps,.deltas, anddelta_of_deltasrespectively).
Package: deltapd
DeltaPDDeltaPD is a tool used to determine outliers in a gene tree when compared against a reference tree.Note: This project is currently in development and is not recommended for public use.InstallationIt is recommended to install DeltaPD using conda in a version-specific environment:condacreate-ndeltapd-cbiocondadeltapdOtherwise, DeltaPD can be installed via PyPI:python-mpipinstalldeltapdDeltaPD will be on the path after successful installation:deltapd-hDocumentationhttps://ecogenomics.github.io/DeltaPD/
Package: deltaray
deltarayThe deltaray library provides aDelta Laketable reader for theRayopen-source ML toolkit.QuickstartInstall from PyPI:pip install deltarayInstall from GitHub:pip install git+https://github.com/delta-incubator/deltaray.gitBasic use, check notebooks for more detailed example:# Standard Libraries
import pathlib

# External Libraries
import deltaray
import deltalake as dl
import pandas as pd


# Creating a Delta Table
cwd = pathlib.Path().resolve()
table_uri = f'{cwd}/tmp/delta-table'
df = pd.DataFrame({'id': [0, 1, 2, 3, 4, ], })
dl.write_deltalake(table_uri, df)

# Reading our Delta Table
ds = deltaray.read_delta(table_uri)
ds.show()Running Teststoxstandardizes running tests in Python. It handles
creating virtual environments for running tests alongsidepytest, our chosen testing
library. It also handles generating reports on test results.Open a bash shell (if on Windows use git bash, WSL, or any shell configured for bash commands).Clone this repo and navigate to the cloned folder.Installtoxfor running our test suite and managing our test environments:pipinstalltoxRun the test suite from the shell withtoxwhile in the cloned repo's directory:tox-snote: The-sflag prints results to stderr/stdout during pytest-ing.Building DistributionBuilding Wheel:python setup.py bdist_wheel sdistInstalling Wheel:pip install /path/to/wheel/..