Saravanan666/pypi-org huggingface dataset:
Package: deltares_datasuite
deltares_datasuitePython package to easily work with STAC items in the Deltares Data Management SuiteInstallationpipinstall-Udeltares_datasuiteor install withPoetrypoetryadddeltares_datasuiteDevelopmentDeployment featuresGitHubintegration: issue and pr templates.Github Actionswith predefinedbuild workflowas the default CI/CD.Everything is already set up for security checks, codestyle checks, code formatting, testing, linting, docker builds, etc withMakefile. More details inmakefile-usage.Dockerfilefor your package.Always up-to-date dependencies with@dependabot. You will onlyenable it.Automatic drafts of new releases withRelease Drafter. You may see the list of labels inrelease-drafter.yml. Works perfectly withSemantic Versionsspecification.Open source community featuresReady-to-usePull Requests templatesand severalIssue templates.Files such as:LICENSE,CONTRIBUTING.md,CODE_OF_CONDUCT.md, andSECURITY.mdare generated automatically.Stale botthat closes abandoned issues after a period of inactivity. (You will onlyneed to setup free plan). Configuration ishere.Semantic Versionsspecification withRelease Please.Makefile usageMakefilecontains a lot of functions for faster development.1. Download and remove PoetryTo download and install Poetry run:makepoetry-downloadTo uninstallmakepoetry-remove2. Install all dependencies and pre-commit hooksInstall requirements:makeinstallPre-commit hooks coulb be installed aftergit initviamakepre-commit-install3. CodestyleAutomatic formatting usespyupgrade,isortandblack.makecodestyle# or use synonymmakeformattingCodestyle checks only, without rewriting files:makecheck-codestyleNote:check-codestyleusesisort,blackanddarglintlibraryUpdate all dev libraries to the latest version using one comandmakeupdate-dev-deps4. Code securitymakecheck-safetyThis command launchesPoetryintegrity checks as well as identifies security issues withSafetyandBandit.makecheck-safety5. Type checksRunmypystatic type checkermakemypy6. Tests with coverage badgesRunpytestmaketest7. All lintersOf course there is a command torulerun all linters in one:makelintthe same as:maketest&&makecheck-codestyle&&makemypy&&makecheck-safety8. Dockermakedocker-buildwhich is equivalent to:makedocker-buildVERSION=latestRemove docker image withmakedocker-removeMore informationabout docker.9. CleanupDelete pycache filesmakepycache-removeRemove package buildmakebuild-removeDelete .DS_STORE filesmakedsstore-removeRemove .mypycachemakemypycache-removeOr to remove all above run:makecleanup📈 ReleasesYou can see the list of available releases on theGitHub Releasespage.We followSemantic Versionsspecification.We useRelease Please. As pull requests are merged, a release Pull Request is kept up-to-date listing the changes, ready to publish when you’re ready. With the categories option, you can categorize pull requests in release notes using labels.🛡 LicenseThis project is licensed under the terms of theMITlicense. SeeLICENSEfor more details.
Package: deltares-wave-toolbox
Deltares Wave ToolboxA Python toolbox for wave analysisFeaturesFrom a time series of water level elevations, the toolbox can calculate:the wave spectrumspectral wave parameters such as wave heigth and different wave periodswave height exceedance curvestheoretical wave spectra and wave height distributionsHow to install the toolbox?The package is available at pip. To install the package run:pip install deltares-wave-toolboxWhere to find information about the Deltares Wave Toolbox?See the online manual for information about the toolbox. In addition, the examples folder contains scripts with applications of the toolbox and a Jupyter notebook is available in the documentation folder.CreditsJan Kramer <jan.kramer@deltares.nl>Menno de Ridder <menno.deridder@deltares.nl>Ivo van der Werf <ivo.vanderwerf@deltares.nl>Joost den Bieman <joost.denbieman@deltares.nl>This package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History1.0.0 (2023-10-27)Initial release
Package: deltas
An open licensed (MIT) library for performing generating deltas (A.K.A sequences
of operations) representing the difference between two sequences of comparable
tokens.Installation:pip install deltasRepo:http://github.com/halfak/DeltasDocumentation:http://pythonhosted.org/deltasNote this library requires Python 3.3 or newerThis library is intended to be used to make experimental difference detection
strategies more easily available.  There are currently two strategies available:deltas.sequence_matcher.diff(a, b):A shameless wrapper arounddifflib.SequenceMatcherto get it to work
within the structure ofdeltas.deltas.segment_matcher.diff(a, b, segmenter=None):A generalized difference detector that is designed to detect block moves
and copies based on the use of aSegmenter.Example:>>> from deltas import segment_matcher, text_split
>>>
>>> a = text_split.tokenize("This is some text.  This is some other text.")
>>> b = text_split.tokenize("This is some other text.  This is some text.")
>>> operations = segment_matcher.diff(a, b)
>>>
>>> for op in operations:
...     print(op.name, repr(''.join(a[op.a1:op.a2])),
...           repr(''.join(b[op.b1:op.b2])))
...
equal 'This is some other text.' 'This is some other text.'
insert ' ' '  '
equal 'This is some text.' 'This is some text.'
delete '  ' ''
Package: deltascf-aims
deltaSCF-aimsAn application to test the development of core level spectroscopy simulation methods in FHI-aimsRequirementspython pipAccess to an FHI-aims binary with the basis sets saved atFHIaims/species_defaults. Note that theFHIaims/top level directory can be at any writeable location in your filesystem asdeltaSCF-aimswill ask for the location of this.InstallationPyPiThis package is available to download on PyPi. To install, simply executepipinstalldeltascf-aimsAnd the binary should be available on your path asdeltascf.Cloning the RepositorySetup of a virtual environment is automated using poetry. Ensure poetry is installed with:pipinstallpoetryIt is recommended to usepyenvto manage the local python version, however this is not essential. If this is desired, then simply install and set the local python version. You should also tell poetry the environment you wish to use to create a virtual environment. For example:pyenvinstall3.11.1
pyenvlocal3.11.1
poetryenvuse3.11Then install the virtual environment:poetryinstallThen either enter the poetry virtual environment withpoetry shell, and use deltaSCF-aims, as described below, or prefix commands to deltaSCF-aims withpoetry run.UsageIt is necessary to have a compiled FHI-aims binary. The location needs to be specified and is then saved by the application. If you wish to change the binary name/location, simply invoke the app with the-boption.The click library has been used to parse command line arguments. To view all the options, rundeltascfwith the help flag:deltascf--helpMore extensible documentation of usage will be provided at a later date.
Package: deltascope
This package is designed to quantify biological structures in 3D image data.FeaturesCompare sets of 3D biological images to identify differencesAutomatically align the structure in the image to correct for variation introduced during mounting and imagingGenerate descriptive graphs that quantify both the average and variation of the dataUse machine learning techniques to classify samples and identify regions of statistically significant differenceInstallationPackage hosted onPyPI.$ pip install deltascopeSupportComplete documentation is available onRead the Docs.Check out theFrequently Asked Questionpage.Submit an issue describing a problem or question on the project’s Githubissue tracker.ContributeIssue Tracker:https://github.com/msschwartz21/deltascope/issuesSource Code:https://github.com/msschwartz21/deltascopeLicenseThis project is licensed under the GNU General Public License.
Package: delta-scraper
delta-scraperIN EARLY DEVELOPMENTPython library for scraping data sources and creating readable deltas.For background, seeScraping hurricane Irma.ConceptsThis library allows you to definescrapers, which are objects that know how to retrieve information from a source (usually a web API, but scrapers can be written to operate against HTML or other formats) and persist that data somewhere as JSON.When a scraper fetches fresh information it has the ability to compare that data to the old data and use the difference to create a human-readable message.These capabilities can be combined with a git repository to create a commit log, with human-readable commit messages that accompany a machine-readable diff againts the generated JSON.Seedisaster-scrapersanddisaster-datafor some examples of this pattern in action.Basic usageYou can define new scrapers by subclassingDeltaScraper. Here's an example which scrapes a list of FEMA shelters.class FemaShelters(DeltaScraper):
    url = "https://gis.fema.gov/geoserver/ows?service=WFS&version=1.0.0&request=GetFeature&typeName=FEMA:FEMANSSOpenShelters&maxFeatures=250&outputFormat=json"
    owner = "simonw"
    repo = "disaster-data"
    filepath = "fema/shelters.json"

    record_key = "SHELTER_ID"
    noun = "shelter"

    def fetch_data(self):
        data = requests.get(self.url, timeout=10).json()
        return [feature["properties"] for feature in data["features"]]

    def display_record(self, record):
        display = []
        display.append(
            "  {SHELTER_NAME} in {CITY}, {STATE} ({SHELTER_STATUS})".format(**record)
        )
        display.append(
            "    https://www.google.com/maps/search/{LATITUDE},{LONGITUDE}".format(
                **record
            )
        )
        display.append("    population = {TOTAL_POPULATION}".format(**record))
        display.append("")
        return "\n".join(display)
Package: delta-sdk
DULMS SDKthis package is a simple non official SDK forDULMSthis package is still in development and the responses are pure from the server without any sanitizationinstallationpipinstalldelta-sdkusageimportingfromdelta_sdkimportdelta_authloginauth=delta_auth.Auth("https://dulms.deltauniv.edu.eg")auth.login("USERNAME","PASSWORD")get user dataauth=delta_auth.Auth("https://dulms.deltauniv.edu.eg")auth.login("USERNAME","PASSWORD")data=auth.get_user_data()print(data)get assginmentsauth=delta_auth.Auth('https://dulms.deltauniv.edu.eg')auth.login("USERNAME","PASSWORD")data=auth.get_assignments()print(data)get quizzesauth=Auth('https://dulms.deltauniv.edu.eg')auth.login("USERNAME","PASSWORD")data=auth.get_quizzes()print(data)using the coockies for other usesauth=Auth('https://dulms.deltauniv.edu.eg')auth.login("USERNAME","PASSWORD")cookies=auth.get_cookies()print(coockies['Id'])the coockies are stored in a dict with the following keys
 - Id
 - ASP.NET_SessionId
Package: delta-sharing
Delta SharingDelta Sharingis an open protocol for secure real-time exchange of large datasets, which enables secure data sharing across different computing platforms. It lets organizations share access to existingDelta LakeandApache Parquettables with other organizations, who can then directly read the table in Pandas, Apache Spark, or any other software that implements the open protocol.This is the Python client library for Delta Sharing, which lets you load shared tables aspandasDataFrames or asApache SparkDataFrames if running in PySpark with theApache Spark Connector library.Installation and UsageInstall usingpip install delta-sharing.To use the Python Connector, seethe project docsfor details.DocumentationThis README only contains basic information about the Delta Sharing Python Connector. Please readthe project documentationfor full usage details.
Package: deltasimulator
DeltasimulatorDeltasimulator is a build system developed by Riverlane. The system can be
used to compile SystemC modules for nodes in a Deltaflow graph and wire the
nodes up. From there a complete runtime executable can be compiled, or the
graph can be connected to a larger platform representing physical devices
such as the ARTIQ platform via a Hardware Abstraction Layer (HAL).Deltasimulator is a component of the Deltaflow-on-ARTIQ system, documentation
for this system and all it's 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: delta-spark
Delta LakeDelta Lakeis an open source storage layer that brings reliability to data lakes. Delta Lake provides ACID transactions, scalable metadata handling, and unifies streaming and batch data processing. Delta Lake runs on top of your existing data lake and is fully compatible with Apache Spark APIs.This PyPi package contains the Python APIs for using Delta Lake with Apache Spark.Installation and usageInstall usingpip install delta-sparkTo use the Delta Lake with Apache Spark, you have to set additional configurations when creating the SparkSession. See the onlineproject web pagefor details.DocumentationThis README file only contains basic information related to pip installed Delta Lake. You can find the full documentation on theproject web page
Package: delta-sync
Delta SyncThis package is not ready to use, still in developmentThis package will contain methods to sync delta table. It will useExamplefromdeltaimportDeltaTablefromdelta_syncimportsync_tablesource_table=DeltaTable.forName("<source table name>")output_table=DeltaTable.forName("<output table name>")status_table=DeltaTable.forName("<status table name>")sync_table(source_table,output_table,status_table)Installpippipinstalldelta-syncpoetrypoetryadddelta-sync
Package: deltat
DeltaT — A simple time duration parserParse a time string e.g. '2h 13m' or '1.5d' into a timedelta object.This is especially useful for command-line or configuration file parsing.Based on Peter's answer athttps://stackoverflow.com/a/51916936/2445204and virhilo's answer athttps://stackoverflow.com/a/4628148/851699According to Peter, "any license is fine", Marcel concurs. For the sake of
specificity, stating MIT license here, which should be compatible with most
licenses.
Package: delta-table-utils
delta_table_utilsDelta table utilities.The basic use case for this library is if you are working in Databricks and want to do upserts usingAutoLoader.Basic usage:fromdelta_table.delta_table_utilsimportDeltaTableColumn,DeltaTableschema_name='my_schema'table_name='my_table'# Define the delta table schemacolumn_list=[DeltaTableColumn('id',data_type='STRING',nulls_allowed=False,is_unique_id=True),DeltaTableColumn('col1',data_type='STRING',nulls_allowed=False),DeltaTableColumn('col2',data_type='DOUBLE'),DeltaTableColumn('col3',data_type='DOUBLE'),DeltaTableColumn('col4',data_type='DOUBLE'),DeltaTableColumn('created_at',data_type='TIMESTAMP'),DeltaTableColumn('updated_at',data_type='TIMESTAMP')]# Create the DeltaTable objectdelta_table=DeltaTable(schema_name=schema_name,table_name=table_name,upload_path="<location_of_data_in_s3>",column_list=column_list)# Create the table and start the streamdelta_table.create_if_not_exists(sqlContext)delta_table.stream(spark,cloudFiles_format='csv')Additional notesBy default, when you use thestreammethod in this library, it stops as soon as no new data is detected. This is useful if you don't want a cluster running all the time and rather you just want to update your delta tables on some sort of a schedule.
Package: deltatextsplitter
DeltaTextsplitter packageThis package is meant to provide an objective evaluation of the performance of thepdftextsplitterpackage in terms of
KPI's.The package includes a set of test documents with references in the form of excel-files.
These reference-files are human-produces excel-files containing the structure of
the test documents that the pdftextsplitter package should have recognised. This can then
be compared to the actual output of the pdftextsplitter package, so that the performance
of the package can be evaluated.The performance is evaluated in terms of the following two KPI'sstructure KPI = 1 - (fp + tn)(fp + tt)where tt = true total, the total number of structure elements in the reference-file,
fp = false positive, the number of structure elements that are present in the output, but not in the reference-file,
and tn = true negative, meaning tn = tt - tp, where tp = true positive,
the number of matching structure elements between the reference-file and the actual outcome.
Two structure elements are said to match if the fuzzy match ratio of their titles is >=80.0
(determined with the packagethefuzz) and their main structure types are equal.cascade kpi = 1 - uc/tpwhere uc = unequal cascades, a subset of the above number tp where the cascade levels
of the reference-file and the outcome of the package do not match.With these two KPI's, it is possible to quantify improvements made to the pdftextsplitter
package by calculating KPI's for each released version of pdftextsplitter.Getting startedThe KPI calculation can be performed efficiently by entering the following commands:
from deltattextsplitter import documentclassmydelta = deltattextsplitter()
mydelta.FullRun()The KPI's will then be printed, but can also be retrieved from:mydelta.structure_kpimydelta.cascade_kpiThe KPI's per test document can also be retrieved from:mydelta.documentarray[index].splitter.documentnamemydelta.documentarray[index].structure_kpimydelta.documentarray[index].cascade_kpiThere are 12 testdocuments in total.The FullRun-command is very CPU-intensive, as it needs to process all the test documents
with the pdftextsplitter-package (in dummy-mode). Once this has been done, one could
speed up the process of subsequent calculations by enteringmydelta.FullRun(False,False)to skip the pdftextsplitter-execution and only redo the KPI-calculation.
Package: deltatorch
deltatorchConceptdeltatorchallows users to directly useDeltaLaketables as a data source for training using PyTorch.
Usingdeltatorch, users can create a PyTorchDataLoaderto load the training data.
We support distributed training using PyTorch DDP as well.Why yet another data-loading framework?Many Deep Learning projects are struggling with efficient data loading, especially with tabular datasets or datasets containing many small imagesClassical Big Data formats like Parquet can help with this issue, but are hard to operate:writers might block readersFailed write can make the whole dataset unreadableMore complicated projects might ingest data all the time, even during trainingDelta Lake storage format solves all these issues, but PyTorch has no direct support forDeltaLakedatasets.deltatorchintroduces such support and allows users to useDeltaLakefor training Deep Learning models using PyTorch.UsageRequirementsPython Version > 3.8piporcondaInstallationwithpip:pip install  git+https://github.com/delta-incubator/deltatorchCreate PyTorch DataLoader to read our DeltaLake tableTo utilizedeltatorchat first, we will need a DeltaLake table containing training data we would like to use for training your PyTorch deep learning model.
There is a requirement: this table must have an autoincrement ID field. This field is used bydeltatorchfor sharding and parallelization of loading.
After that, we can use thecreate_pytorch_dataloaderfunction to create PyTorch DataLoader, which can be used directly during training.
Below you can find an example of creating a DataLoader for the following table schema :CREATETABLETRAINING_DATA(imageBINARY,labelBIGINT,idINT)USINGdeltaLOCATION'path'After the table is ready we can use thecreate_pytorch_dataloaderfunction to create a PyTorch DataLoader :fromdeltatorchimportcreate_pytorch_dataloaderfromdeltatorchimportFieldSpecdefcreate_data_loader(path:str,batch_size:int):returncreate_pytorch_dataloader(# Path to the DeltaLake tablepath,# Autoincrement ID fieldid_field="id",# Fields which will be used during trainingfields=[FieldSpec("image",# Load image using Pillowload_image_using_pil=True,# PyTorch Transformtransform=transform),FieldSpec("label"),],# Number of readersnum_workers=2,# Shuffle data inside the record batchesshuffle=True,# Batch sizebatch_size=batch_size,)
Package: delta-utils
Delta-utilsInstallationpip install delta-utilsTo deploy to PyPIFirst increase the version number in pyproject.toml (e.g. 0.0.13 -> 0.0.14)python3-mpipinstall--upgradebuild
python3-mbuild
python3-mpipinstall--upgradetwine
twineupload--skip-existingdist/*
Package: deltaver
Deltaver (Dependency Lag Calculator)OverviewThe "Deltaver" is a Python project designed to calculate the lag or delay in dependencies in terms of days. It provides insights into how outdated your project dependencies are, helping you stay up-to-date with the latest developments and security patches.Features:Dependency Lag Calculation: The tool analyzes the timestamp of the current dependency version and compares it with the latest available version, providing the time lag in days.Security Insights: Identify outdated dependencies to prioritize updates based on security considerations.Customization: Configure the tool to focus on specific dependencies or categories, allowing for flexibility in analysis.Getting StartedPrerequisitesMake sure you have the following installed:Python 3.xPip (Python package installer)InstallationpipinstalldeltaverUsageRun deltaver:deltaverrequirements.txtLicenseThis project is licensed under the MITLicense- see the LICENSE file for details.
Acknowledgments
Package: deltax
Python library to control a robot from 'Delta X Robot'exempleDeltaX Srobot=DeltaX(port="COM4",model=DeltaX.DeltaX_S)ifrobot.connect()==True:print("connected")robot.syncPosition()robot.wait_for_robot_response()print(robot.position())robot.syncInput(I=[0,1],A=[0])robot.wait_for_robot_response()print(robot.getDigitalInput(I=[0,1]))print(robot.getAnalogInput(A=[0]))robot.setDO(D=[0,1],value=DeltaX.ON)robot.wait_for_robot_response()while1:robot.moveL([20,0,-800])robot.moveL([-20,0,-800])robot.moveC(offset=[-30,-30],point=[-20,0])robot.wait_for_robot_response()DeltaX V2robot=DeltaX(port="COM4",model=DeltaX.DeltaX_V2)ifrobot.connect()==True:print("connected")robot.syncPosition()robot.wait_for_robot_response()print(robot.position())robot.setEndEffector(name=DeltaX.Vacuum)robot.wait_for_robot_response()robot.controlEndEffector(value=DeltaX.ON)robot.wait_for_robot_response()while1:robot.moveL([20,0,-270])robot.moveL([-20,0,-270])robot.moveC(offset=[-30,-30],point=[-20,0])robot.wait_for_robot_response()list func- connect
- disconnect
- is_connected
- sendGcode
- wait_for_robot_response
- robot_response
- isResponded
- lastGcodeState
- syncMotionParameters
- motionParameters
- sleep
- position
- angle
- homing
- syncPosition
- syncAngle
- syncInput
- getDigitalInput
- getAnalogInput
- setDO
- controlEndEffector
- setEndEffector
- disableSteppers
- setAcceleration
- setStartingAndEndingSpeeds
- setXYZOffset
- moveL
- moveC