Saravanan666/pypi-org huggingface dataset:
Package: dave-vkostov
dave™DiscoveryAndVetting ofExoplanets™SummaryThis repository implements a pipeline to find and vet planets planets
using data from NASA K2 and TESS missions.The pipeline performs the following steps:Create a subset of targets for testingLight Curve Genertion/CoTrend -- remove instrumental effects
e.g. PDC light curves
Dan Foreman-Mackey's methodDetrend/Search for planets -- BLSFitting a planetary modelProduce vetting MetricsOutput useful data productsInstallation and RequirementsPlease consider installing DAVE in a new environment (with Python 3.6/3.7, gnuplot installation may be a problem with 3.8) as you'll need to pip install the following packages before proceeding: astropy, metric_learn, sklearn ,pyfits, astroquery, conda install gnuplot (from command line:  conda install -c conda-forge gnuplot ), PyGnuplot, parmap, bls, clipboard, lpproj, numba and eleanor.
After having installed all the dependencies, please pip install dave-vkostov.
Now you only need one last thing: go to the dave directory, open the tessPipeline directory and open the vet_tess_.py script. Here you will see some (3 or 4) lines of code with the path of my machine. Replace them with your path to the dave dir.
Thanks for installing.Example use for TESSfrom python:from dave.tessPipeline import vet_tess_
detrendType = "tess_2min"
clip = vet_tess_.runOneDv(detrendType, 2, 307210830, 1, 3.690613, 1356.2038, 1863, 1.27)
outfile = "tmp.txt"
export_ = vet_tess_.runExport(clip,outfile_)where input for runOneDv is: Sector, TIC ID, Planet Number, Period, BTJD, Transit Depth [ppm], Transit Duration [hours].Currently supported "detrendType" are "tess_2min" and "eleanor", where "tess_2min" refers to the SPOC short-cadence data, and "eleanor" refers to eleanor-generated FFI lightcurves
Package: david-home-automation
Home automationInstallationpip3installdavid-home-automation==0.1.38(sudoaptinstall--yesexpect&&cd$(mktemp-d)&&gitclonehttps://github.com/Heckie75/eQ-3-radiator-thermostat.gitx&&cdx&&cpeq3.exp$HOME/.local/bin)# (Optional) find your thermostat MACs viabluetoothctldevices# Create your config oncecat>~/.config/david-home-automation.yaml<<EOFthermostats:- mac_address: XX:XX:XX:XX:XX:XXname: Arbeitszimmerhosts:- broadcast_ip: 192.168.178.1mac_address: XX:XX:XX:XX:XX:XXname: DesktopEOF# You can also pass your config file path via an env variableexportHOME_AUTOMATION_CONFIG=your/path

python3-mdavid_home_automation.server--server-host=0.0.0.0--server-port5000Setup as a service./install.shSetup eq3 bluetoothFollowthe eq3.exp guidefor pairing your thermostats.
Make sure you do not connect/pair from multiple devices as the thermostats get easily confused.
If you are encountering strange connection issues or crypted error messages from the API (and by extension alsoeq3.exp), reset your thermostats to factory settings (see manual).
A useful debugging tool isbtmon.DevelopmentInstall poetrypoetry install
FLASK_ENV=development FLASK_APP=david_home_automation/main poetry run flask run --host=0.0.0.0 --port 5050
Package: davidia
DavidiaCreate a conda environment calleddavidiaconda env create --file environment.ymlActivate it:conda activate davidiaInstall Typescript dependencies (read pnpm'sinstallation guide, if needed)pnpm installBuild web clientpnpm buildRunning Python plot serverFrom the top level of the repository, you can run:cd server && uvicorn --factory davidia.main:create_apporPYTHONPATH=server python server/davidia/main.py -cOpenlocalhost:8000/clientto view it in the browser. Now test plot server with,PYTHONPATH=server python server/davidia/simple.pyBenchmarking the plot clientSet the environment variableDVD_BENCHMARKasonor add a-bargument:DVD_BENCHMARK=on PYTHONPATH=server python server/davidia/main.pyPYTHONPATH=server python server/davidia/main.py -c -bRun the script to trigger benchmarks:PYTHONPATH=server python server/davidia/demos/benchmark.pySee its builtin help using the-hargument.StorybookView the Storybookhere.To build and run the Storybook locally:pnpm build:storybookpnpm start:storybookDocumentationView the documentationhere.
Package: davies
DaviesDavies is a Python package for manipulating cave survey data.It is currently in a early phase of development, and its interfaces may change as it matures.Current support includes:Reading ofCompassProject (.MAK) and Data (.DAT)
source files, as well as compiled Plot (.PLT) files.Writing Compass Data (.DAT) files.ReadingPocketTopoexported .TXT survey files.That’s it! No loop closure algorithms, no visualization or editing tools (though ourexamplesdirectory contains scripts with which to build tools of this sort)Browse theDavies API documentation.Example usage with Compass survey data:from davies import compass

# Parse a .DAT file
datfile = compass.DatFile.read('MYCAVE.DAT')

print len(datfile)  # number of surveys in .DAT
>> 17

print datfile.length  # total surveyed footage including splays, etc.
>> 5332.2

print datfile.included_length  # total surveyed footage after discarding excluded shots
>> 5280.0

survey = datfile['BS']  # grab a survey by its survey designation

print survey.name
>> A

print survey.date
>> 2006-09-30

print survey.length  # surveyed footage including splays, etc.
>> 5332.2

print survey.included_length  # surveyed footage after discarding excluded shots
>> 5280.0

print survey.shots[0]
>> {'FROM': 'A1', 'TO': 'A2', 'LENGTH': 16.8, 'BEARING': 158.0, 'INC': -30.0, 'LEFT': 12.0, 'RIGHT': 15.0, 'UP': 15.0, 'DOWN': 20.0}

print survey.shots[0].azm  # azimuth after averaging front and backsights, magnetic declination
155.2This example shows who has surveyed the most footage in your Compass project:from davies import compass

cavers = {}

for datfilename in sys.argv[1:]:
    for survey in compass.DatFile.read(datfilename):
        for member in survey.team:
            cavers[member] = cavers.get(member, 0.0) + survey.length

for name in sorted(cavers, key=cavers.get, reverse=True):
    print "%s:\t%0.1f" % (name, cavers[name])InstallationThis software requiresPython 2.7. It willNOTwork with older Python releases, though itmaywork with Python 3.3+.Releases are available for installation from the Python Package Index, seeinstallation instructionsor simply run
the following command on Mac OS X or most Linux distributions:$> pip install daviesIf you’ve downloaded a source distribution or checked out from the git repository, install locally with:$> python setup.py installDevelopment happens onGitHub.NameThe name “Davies” is a tribute toWilliam E. Davies,
who pioneered the systematic cave survey of West Virginia and authoredCaverns of West Virginiain 1949. Bill Davies
later did the statewide cave survey for the state of Maryland, served the roles of President and Vice-President of the
National Speleological Society, and published the definitive US-wide karst map,Engineering Aspects of Karst. Davies
still serves as an inspiration today to the cave mappers of West Virginia, of the United States, and the World over.LicenseDavies is Free / Open Source software licensed under theMIT License,
and is copyright (C) 2013 - 2016 Myotisoft LLC.
Package: da-vinci
A simple image manipulation library aiming to make common image/photo
manipulation tasks easy. This library is still under development,
API may also change at any time.Requires PIL/Pillow.Example usage:from da_vinci import Image

image = Image('lena.jpg')
image.flip('horizontal')
image.resize(width=10, height=10)
image.save()

# Opening an image from URL, rotating and change it's format
image = Image('http://stamps.co.id/static/merchants/img/logo.png')
image.rotate(degrees=90)
image.set(format='jpg', quality=85)
image.save() # Creates a file logo.jpg

# Manipulating saturation, brightness, contrast and sharpness
# Accepts values range from -100 (decrease) to 100 (increase)
image.adjust(saturation=-100)
image.adjust(brightness=-75, contrast=50, sharpness=-20)If you need more extensive manipulation, an escape hatch to PIL
is also available:image = image.from_file('a.jpg')
pil_image = image.get_pil_image()
# Do whatever you need to do with the pil image
# And if you want to convert this back to a da_vinci image
image.set_pil_image(pil_image)TestsTo run tests:python -m unittest testsChangelogVersion 0.4.0Support Pillow 10Preserve EXIF data when image is rotatedVersion 0.3.0Added webp extension supportVersion 0.2.2Added bmp extension support
Package: davinciGPT
Welcome to davinciGPTdavinciGPT uses API from OpenAI and help you easily integrate it in your python project.Getting StartedTo get started, first install the module using the following command in your terminal:pip install davinciGPTTokenTo get your own token to get access to chatbot, please visithereExamplefromdavinciGPTimportChatbotbot=Chatbot(<YOURTOKEN>)res=bot.chatbot("Hello")print(res)Output:Hi there! How can I help you?
Package: davinci-resolve-api
DaVinci Resolve APIDaVinci Resolve APIFree software: MIT licenseDocumentation:https://davinci-resolve-api.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2022-05-22)First release on PyPI.
Package: davincirunsdk
davincirunsdkdavincirunsdkis a Notebook-friendly Ascend distributed training SDK for Jupyter-like interactive environmentsFeatureInitialize hccl file and set environment variable：RANK_TABLE_FILESet environment variables such as RANK_ID, RANK_SIZE according to hccl file, and start multiple training processesMonitor training, Notebook friendly, printable training log in NotebookQUICK STARTInstallationThe trial only requires direct installation using pypipip install davincirunsdkMOREFor more, see our github page:https://github.com/Wh1isper/davincirunsdk
Package: davtelepot
davtelepotThis project conveniently mirrors the Telegram bot API with the classBot.Please note that Python3.5+ is needed to run async code.Check requirements.txt for third party dependencies.Check outhelp(Bot)for detailed information.Project foldersdavtelepot/datafolderconfig.pycontains configuration settings (e.g. certificate path, local_host, port etc.)passwords.pycontains secret information to be git-ignored (e.g. bot tokens)*.dbfiles are SQLite databases used by bots*.log: log files (store log_file_name and errors_file_name indata/config.pymodule)examplesfolderThis folder contains full-commented and ready-to-run examples for simple davtelepot.bot Telegram bots.Usageimport sys

from davtelepot.bot import Bot

from data.passwords import my_token, my_other_token

long_polling_bot = Bot(token=my_token, database_url='my_db')
webhook_bot = Bot(token=my_other_token, hostname='example.com',
                  certificate='path/to/certificate.pem',
                  database_url='my_other_db')

@long_polling_bot.command('/foo')
async def foo_command(bot, update, user_record):
    return "Bar!"

@webhook_bot.command('/bar')
async def bar_command(bot, update, user_record):
    return "Foo!"

exit_state = Bot.run(
    local_host='127.0.0.5',
    port=8552
)
sys.exit(exit_state)Check outhelp(Bot)for detailed information.Webhook additional informationTo run a bot in webhook modality, you have to provide ahostnameandcertificateat bot instantiation and alocal_hostandportwhen callingBot.runmethod.Telegram will send POST requests athttps://{hostname}/webhook/{tokens}/usingcertificatefor encryptionaiohttp.web.Applicationserver will listen onhttp://{local_host}:{port}for updatesIt is therefore required a reverse proxy passing incoming requests to local_host.Example of nginx reverse proxy serving this purposeserver{listen8553ssl;listen[::]:8553ssl;server_nameexample.comwww.example.com;location/telegram/{proxy_passhttp://127.0.0.5:8552/;}ssl_certificate/path/to/fullchain.pem;ssl_certificate_key/path/to/privkey.pem;}Example of python configuration file in this situation# File data/config.py, gitignored and imported in main scripthostname="https://www.example.com:8553/telegram"certificate="/path/to/fullchain.pem"local_host="127.0.0.5"port=8552# Main scriptfromdata.configimporthostname,certificate,local_host,portfromdata.passwordsimportbot_tokenfromdavtelepot.botimportBotmy_bot=Bot(token=bot_token,hostname=hostname,certificate=certificate)# ...Bot.run(local_host=local_host,port=port)
Package: davteutil
davteutilThis project provides convenient general-purpose functions, used byDavtein his projects.Please note that you need Python3.5+ to run async codeProject foldersUsageimport asyncio

from davteutil.utilities import async_get, async_post

async def main():
  url = 'http://www.google.com'
  result = await async_get(url, mode='html')
  print(result)

loop = asyncio.get_event_loop()
loop.run_until_complete(main())
Package: dawa-sdk
dawa-sdk===================Python - Dawa APIdawa-sdkis a simple client for dawa api. It uses [Dawa Web API](https://dawadocs.dataforsyningen.dk/dok/api. It is mainly designed for data replication, but will at later stages include search.Installationpip install dawa-sdkUsingfromdawaimportAPIapi=API()Replicationdefreplicate():# Due to the amount of data on some endpoint, this returns a generatordeftxid():# Returns an integerUsage# Get current txid and store somewheretxid=api.txid()# Get initial replicationvejstykke=api.replicate('vejstykke')# Get latest txid and check if it is greater than previoustxid=api.txid()# if yes get all the changes between last and current txidvejstykke=api.replicate('vejstykke',txidfra='3340338',txidtil='3340338')# It is also possible to get data from a single txidvejstykke=api.replicate('vejstykke',txid='3340338')SearchNotimplementedyetContributinghttps://github.com/Fredehagelund92/dawa-pythonDawa Web APIDawa Web API Doc
Package: dawatoma
DAWATOMAstands forDigitalAudioWorkstationAuTOMAtion.dawatoma allows the acceleration of creative tasks that often take place in a
DAW. It allows the generation of derived melodies given a 'fingerprint' melody
upon which the derived ones are based. The way my creative process often works
when producing music is that I have one main melody, and I build the song
around that, and a lot of that involves composing additional melodies that go
well with the main one. A portion of this is algorithmic and can be outsourced
to computational algorithms. There is, of course, already software out
there like arpeggiators and such that can do such things, but I wanted to
build a package that is built entirely around the idea of deriving melodies
from base melodies, with an easily expandable list of derivation protocols
that other developers can contribute to. The derived note sequences, as well
as the original, can be written to MIDI (.mid) format.This package utilizes the plain text ".dawa" format to represent note
sequences. .dawa format looks as follows and contains all relevant information
about a note sequence:\n
tempo_in_BPM # Commment\n
note1 time duration\n
note2 time duration\n
...\n
noteN time duration\nWhere time and duration are in beats, and time is the point in time in the
sequence that a note begins, and duration is how long the note lives. The
initial strings "not1e1", "note2", etc are strings like "C5" which will be
interpreted with the NoteDict, also included in this package.This package depends on MIDIUtil.
Package: dAwebAPI
Fork the code ongithubInstallationdAwebAPIis listed in the Python Package Index. You can install it typing:pip install dAwebAPIUsageAccess dA-compatible webAPIs in the same way you’d access a local api:fromdAwebAPI.WebAPIimportWebAPIS=WebAPI(<ADDRESS>)print(dir(S))# print all available functionsprint(S.aFunction.__doc__)#print a doctstringprint(S.api_md())#print api in makdown formatprint(S.aFunction(arg1,arg2,kwarg1=1,kwarg2='aa',kwargs=True))Function output is formated depending on the functions signature.v0.1, <15/03/2018> – Initial release.Karl Bedrich 2018 -
Package: dawiq
DaWiQ - Dataclass Widget with QtDaWiQ is a Python package to generate Qt widget from dataclass.It provides:Dynamic construction of widget from dataclassCustomizing widget for user-defined typeDelegate and mapper for dataclass widgetThe following Qt bindings are supported:PySide6PySide2PyQt6PyQt5UsageHere is a simple dataclass:fromdataclassesimportdataclass@dataclassclassDataClass:a:intb:boolDaWiQ can build a widget from this dataclass. For PySide6 example,fromPySide6.QtWidgetsimportQApplicationfromdawiqimportdataclass2Widgetimportsysapp=QApplication(sys.argv)dataWidget=dataclass2Widget(DataClass)dataWidget.show()app.exec()app.quit()This widget can be mapped to item model for storing the data.
More examples are provided in the documentation.InstallationDaWiQ can be installed fromPyPI.$ pip install dawiqTo install from GitHub source, clone the repository withgitand install withpip.$ git clone https://github.com/JSS95/dawiq.git
$ cd dawiq
$ pip install .DaWiQ does not specify the Qt binding requirement, therefore you must manually install one.DocumentationDaWiQ is documented withSphinx. Documentation can be found on Read the Docs:https://dawiq.readthedocs.io/If you want to build the document yourself, get the source code and install with[doc]option.
Then go todocdirectory and build the document.$ pip install .[doc]
$ cd doc
$ make htmlDocument will be generated inbuild/htmldirectory. Openindex.htmlto see the central page.
Package: dawnote
knowldege_baseThe minimalist note editor for your terminal.Createnotes...Editnotes...Savenotes...knowledgebase is a python implementation of a minimalist note editor for your terminal.
It facilitates creating, editing and managing notes asmarkdownfiles.As such, it provides a CLI with the followng sintax:kb<command><note_name(optional)><tag(optional)>Thecommandsinclude:lorlistto list all notesshow <note_name>to render a single note in the terminale/edit <note_name>to edit an existing noterm/remove <note_name>to delete a noten/new <note_name>to create a new note with a given Namet/tag <note_name> <tag>to add a new tag to an existing noteuntag <note_name> <tag>to remove a tag to an existing noteEditing a note opens the markdown file usingnano, other editors can be used to edit the.mdfiles externally.Installationpip install knowledgebaseDisclaimer:knowledgebaseis a personal project, as such the path to where the notes are saved on my machine are hardcoded. If you want to useknowledgebaselet me know and we can improve this (or you can fork this repository and alter the paths).Built withrichandpyinspect
Package: daWUAP
The data assimilation Water Use and Agricultural Productivity model (daWUAP) is a hydro-economic model that couples an economic model of agricultural production calibrated using positive mathematical programming (PMP) and a semidistributed rainfall-runoff-routing model that simulates water available to producers.Features:Calibration of economic component can use standard the mathematical programming method or a new recursive stochastic filter.Stochastic calibration permits to obtain simulation results of agricultural outputs (land and water allocation, etc) as probability distributions that reflect the quality of the calibration.Recursive stochastic filter permits calibration of economic model with noisy but frequent remote sensing observations of agricultural activity.Model permits to trace the effect of producer choices on the hydrologic system and on other users.Contributions and comments are welcome at Github.
Package: dawupxlrgo
Dawupxlrgo=================This API SDK was automatically generated by [APIMATIC Code Generator](https://apimatic.io/).This SDK uses the Requests library and will work for Python ```2 >=2.7.9``` and Python ```3 >=3.4```.How to configure:=================The generated code might need to be configured with your API credentials.To do that, open the file "Configuration.py" and edit its contents.How to resolve dependencies:===========================The generated code uses Python packages named requests, jsonpickle and dateutil.You can resolve these dependencies using pip ( https://pip.pypa.io/en/stable/ ).1. From terminal/cmd navigate to the root directory of the SDK.2. Invoke ```pip install -r requirements.txt```Note: You will need internet access for this step.How  to test:=============You can test the generated SDK and the server with automatically generated testcases. unittest is used as the testing framework and nose is used as the testrunner. You can run the tests as follows:1. From terminal/cmd navigate to the root directory of the SDK.2. Invoke ```pip install -r test-requirements.txt```3. Invoke ```nosetests```How to use:===========After having resolved the dependencies, you can easily use the SDK following these steps.1. Create a "dawupxlrgo_test.py" file in the root directory.2. Use any controller as follows:```pythonfrom __future__ import print_functionfrom dawupxlrgo.dawupxlrgo_client import DawupxlrgoClientapi_client = DawupxlrgoClient()controller = api_client.clientresponse = controller.get_basic_auth_test(<required parameters if any>)print(response)```
Package: dax
DAX, is a python package developed at Vanderbilt University, Nashville, TN,
USA. It’s available on github at:https://github.com/VUIIS/dax.XNAT provides a flexible imaging informatics software platform to
organize and manage imaging data.DAX, an open-source initiative under the umbrella of Vanderbilt University
Institute of Imaging Science (VUIIS), is a Python project that provides a
uniform interface to run pipelines on a cluster by grabbing data from a XNAT
database via RESTApi Calls.DAXallows you to:extract information from XNAT via scripts (bin/Xnat_tools/Xnat…)create pipelines (spiders/processors) to run pipelines on your databuild a project on XNAT with pipelines (assessors)launch pipelines on your cluster and upload results back to xnatinteract with XNAT via python using commands in XnatUtils.
Package: daxmod
Daxmoddaxmod is a Python module for text classificationInstallationDependenciesdaxmod requires:Python (>=3.8)joblib (>=1.1.0)numpy (>=1.21.4)pandas (>=1.3.4)scikit-learn (>=1.0.1)dependencies for pretrained models:tensorflow (>=2.7.0)tensorflow_hub (>=0.12.0)tensorflow_text (>=2.7.3)User installationInstallation without pretrained dependenciespipinstall-UdaxmodInstallation with pretrained dependenciespipinstall-Udaxmod[pretrained]Source codegitclonehttps://github.com/Authentic10/daxmod.git
Package: da-xn-island
Da-xn Island UtilsDa-xn Island Utils is a simple utility library for quick access to the Da-xn Island API.
You can for example:Get info about a specific user such as their username, id, rank (Member, Admin, Da-xn Island Premium etc) or how many Da-xn Island Bux they have!Get a list of all users currently signed upGame information and how many people are currently playing (Soon!)Website status of Da-xn IslandAnd much much more!How to use this package:Da-xn Island Package Import: .. code-block:: python import da_xn_islandThere are many simple functions that you can use to get the API Information.
Here are all of the current functions available:get_user(userID)  // This returns all the information that is publicly listed on the user’s profile.get_all_users()     // This returns basic information such as all of the usernames and the id’s of them.websiteStatus()     // This returns the status of the Da-xn Island website so you can keep track of it easily!user_auth()         // This will return a console app that returns how users can verify their accounts. This will return their username and other information.NOTE:If you need any assistance of how to use this package or if you would like to request new features you can do some of the following:Email me:dan@da-xn.comOr join theDa-xn Island Discord ServerWe will be updating this package frequently as well as making this package available in different programming languages (Such as C#, C++, Java, etc.)
Package: daxparser
DAX Parser (actually a Lexer only :) )Utility to parse dax. Very minimal API yet, currently exposes aget_columns_or_measuresto get all columns/measures used by a dax statementBased on TabularEditor2's Dax Lexer:https://raw.githubusercontent.com/TabularEditor/TabularEditor/master/AntlrGrammars/DAXLexer.g4