Saravanan666/pypi-org huggingface dataset:
Package: doopl
Welcome to the IBM® OPL connector for Python.
Licensed under the Apache License v2.0.With this library, you can quickly and easily add the power of optimization to
your Python application. You can model your problems by using the OPL language and IDE, and integrate it in Python via Python/pandas/sql alchemy inputs/outputs.Solving with CPLEX requires that IBM® ILOG CPLEX Optimization Studio V12.8.0 and up is installed on your machine.Install the librarypip install dooplGet the examplesExamples.Get your IBM® ILOG CPLEX Optimization Studio editionYou can get a freeCommunity Editionof CPLEX Optimization Studio, with limited solving capabilities in term of problem size.Faculty members, research professionals at accredited institutions can get access to an unlimited version of CPLEX through theIBM® Academic Initiative.LicenseThis library is delivered under the  Apache License Version 2.0, January 2004 (see LICENSE.txt).Starting pointThe API is very compact and simple.
You must have the OPL binaries in your PATH/LD_LIBRARY_PATH or
DYLD_LIBRARY_PATH, depending on your platform. They are located in<cplex_studio_dir>/opl/bin/<platform>where:cplex_studio_diris the installation directory of CPLEX 12.8platformis your plaform (OPL nomenclature, that isx64_win64,x86-64_linuxorx86-64_osx)Here is small sumup of the capabilities:Inputs can be tuple lists, panda’s dataframe, sql alchemy fetch statements.Generate, solve and get output tuplesets as panda’s dataframeGet the CPLEX problem statistics and quality metrics for the solutionConvert all integer variables to floating point variables and vice-versa.Run the conflict/relaxation mechanism.Call the ‘RunSeed’ diagnosis for CPLEX/CPO based problems.Each of these features are demonstrated with simple examples.Here is a small example to start working with the API:from doopl.factory import *

# Create an OPL model from a .mod file
with create_opl_model(model="file.mod") as opl:
    # tuple can be a list of tuples, a pandas dataframe...
    opl.set_input("TupleSet1", tuples)

    # Generate the problem and solve it.
    opl.run()

    # Get the names of post processing tables
    print("Table names are: "+ str(opl.output_table_names))

    # Get all the post processing tables as dataframes.
    for name, table in iteritems(opl.report):
        print("Table : " + name)
        for t in table.itertuples(index=False):
            print(t)
Package: doopla
doopla===============================H(ad)oopla!A Python script to fetch the output of failed Python Hadoop streaming jobs. It scrapsthe hadoop web interface and gets a random failed mapper and reducer task. It outputs it withcode highlighting for easy reading.doopla -hUsage:doopla [<jobid>]doopla -h | --helpdoopla --versionOptions:-h --help       Show this screen.--version       Show version.Features--------* Automatically get the last failed job for a user* Code highlighting via `Pygments`.Install------Two options for installing:*Via Pip::*pip install doopla*git clone and setup.py*:git clone git@github.com:trustyou/doopla.gitcd dooplapython setup.py installUsage-----Before using `doopla` please create a file in your home directory called `.doopla` and addthe follwoing:[main]hadoop_version: <HADOOP_VERSION> # either 1 or 2 - defaults to 2hadoop_user: <HADOOP_USER>hadoop_url: <HADOOP_URL> # For Hadoop 2.x use the Job history URLhttp_user: <USER>http_password: <THE_PASSWORD>Replace `HADOOP_URL` for the HTTP URL of your the Hadoop Web interface. Replace `HADOOP_USER` for your hadoop user (or the one you want to check) and the  `HTTP_PASSWORD` for the http password you normally use to log into the web interface.The is simple a mather of executing$ dooplaIt will search for the most recently failed job and get the output.Or$ doopla JOB_IDIf you want to get the output of a specific job.You can also add `2>/dev/null` if you want to shut down the HTTPS certificate warnings.Screenshot----------![alt text](https://www.dropbox.com/s/at10xpaut2xz2iw/sample.png?raw=1)Development-----------This is a 4 hours hack while skipping lunch and waiting for a job to finish so it is in alphastage and it is full of bugs. So feel free to create pull requests if you see somethingthat can be improved.Requirements------------- Python >= 2.6 or >= 3.3- Colorama- BeautifulSoup- Requests- PygmentsLicense-------MIT licensed. See the bundled `LICENSE <https://github.com/mfcabrera/doopla/blob/master/LICENSE>`_ file for more details.
Package: door
Door is a comprehensive python library for synchronization proxies. Door’s
reliability has been established through static type checking, extensive
doctests, and unit tests, achieving 93% code coverage.FeaturesShare objects across processes without queues or pipes.Synchronization proxies to enforce sound synchronous data access.Supported scenarios:Threading;Multiprocessing;Asynchronous programming.Shared lock (Readers-writer lock) implementations.Shared condition variable (Readers-writer condition variables)
implementations.InstallationpipinstalldoorUsageBelow shows a sample usage of Door.>>>fromdataclassesimportdataclass>>>frommultiprocessingimportProcess>>>fromdoor.multiprocessing2importHandle,SAcquirableDoor>>>@dataclass...classResource:...key:str='value'...>>>handle=Handle(Resource())>>>handle.get()Resource(key='value')>>>door=SAcquirableDoor(handle)>>>deffunc(door):...withdoor.write()asproxy:...proxy.key='VALUE'...>>>process=Process(target=func,args=(door,))>>>process.start()>>>process.join()>>>handle.get()Resource(key='VALUE')>>>handle.unlink()Testing and ValidationDoor has extensive test coverage, passes mypy static type checking with
strict parameter, and has been validated through extensive use in real-life
scenarios.ContributingContributions are welcome! Please read our Contributing Guide for more
information.LicenseDoor is distributed under the MIT license.
Package: doorda-sdk
Doorda Python SDKRequirementsPython 3.6/3.7DoordaHost AccountInstallationPyPi$pipinstalldoorda-sdkUsageDoordaHostConnect to databasefromdoorda_sdk.hostimportclientconn=client.connect(username="username",password="password",catalog="catalog_name",schema="schema_name")cursor=conn.cursor()Execute Queriescursor.execute("SELECT * FROM table_name")# Returns generator of results# Does not put result into memory. Iterates through rows in a streaming fashion.# DEPRECATEDforrowincursor.iter_result():# Do something with row# Use:forrowincursor:# Do something with row# Fetch all resultsrows=cursor.fetchall()# Fetch one resultsrows=cursor.fetchone()# Fetch multiple resultsrows=cursor.fetchmany(size=10)# Get list of column namescursor.col_names# Get column names mapped to data typescursor.col_typesSimplified Functions# List Permissions## Permissions are shown as a hierarchical tree structure### Level 1 = Catalog, Level 2 = Schemas, Level 3 = Table Namespermissions=cursor.permissions()print(permissions)# Check database connectionresults=cursor.is_connected()# List all catalogsrows=cursor.show_catalogs()# List all schemasrows=cursor.show_schemas("catalog_name")# List all tablesrows=cursor.show_tables("catalog_name","schema_name")# Get number of rowsrows=cursor.table_stats(catalog="catalog_name",schema="schema_name",table="table_name")Find out moreTo find out more about DoordaHost, head over tohttps://github.com/Doorda/Getting-Started
Package: doorloop
DoorLoop PythonThis library provides a pure python interface to interact with the DoorLoop APITO-DOGeneralPaginationFilterSortingTestsAccountsUsersPropertiesUnitsLeasesTenantsLease PaymentsLease Returned PaymentsLease ChargesLease CreditsPortfoliosTasksOwnersVendorsExpensesVendor BillsVendor CreditsReportsCommunicationsNotesFilesRun TestsSet the environment variableDOORLOOP_API_KEYto a valid api key.
Package: doorpost-detector
Doorpost DetectorThis package contains a pointcloud processing pipeline to estimate the poses of doorposts.Quick startpip install -r requirements.txtpip install -e .To obtain doorpost poses from cropped pointcloudimportdoorpost_detector.apiasdpdresponse=dpd.doorpost_pose_from_cropped_pointcloud_usecase(points)To obtain doorpost poses from pointcloudimportdoorpost_detector.apiasdpdresponse=dpd.doorpost_pose_from_pointcloud_and_door_location_estimate_usecase(points,door_location)Response format@dataclassclassResponse:success:boolposes:tuple[float,float,float,float]# x1,y1,x2,y2certainty:tuple[float,float]
Package: doorstop
OverviewDoorstop is arequirements managementtool that facilitates the storage of textual requirements alongside source code in version control.When a project leverages this tool, each linkable item (requirement, test case, etc.) is stored as a YAML file in a designated directory. The items in each directory form a document. The relationship between documents forms a tree hierarchy. Doorstop provides mechanisms for modifying this tree, validating item traceability, and publishing documents in several formats.Doorstop is under active development and we welcome contributions.
The project is licensed asLGPLv3.
To report a problem or a security vulnerability pleaseraise an issue.
Additional references:publication:JSEA Papertalks:GRDevDay,BarCampsample:Generated HTMLSetupRequirementsPython 3.5+A version control system for requirements storageInstallationInstall Doorstop with pip:$pipinstalldoorstopor add it to yourPoetryproject:$poetryadddoorstopAfter installation, Doorstop is available on the command-line:$doorstop--helpAnd the package is available under the name 'doorstop':$python
>>>importdoorstop
>>>doorstop.__version__UsageSwitch to an existing version control working directory, or create one:$gitinit.Create documentsCreate a new parent requirements document:$doorstopcreateSRD./reqs/srdAdd a few items to that document:$doorstopaddSRD
$doorstopaddSRD
$doorstopaddSRDLink itemsCreate a child document to link to the parent:$doorstopcreateHLTC./tests/hl--parentSRD
$doorstopaddHLTCLink items between documents:$doorstoplinkHLTC001SRD002Publish reportsRun integrity checks on the document tree:$doorstopPublish the documents as HTML:$doorstoppublishall./public
Package: doorstop-edit
Doorstop EditA cross-platform GUI editor forDoorstoppowered by PySide6 (Qt).The goal of this GUI is to provide all the tools needed to efficiently work with a larger set of
requirements within the editor and at the same time have full control of what is happening. The
editor use the doorstop API whenever possible to behave the same way as doorstop.Features:Resizable and movable modern viewsfor custom layout.Dark theme.Item tree withstatus colorsandsearch functionfor good overview and fast location.Live markdown-HTMLrendering.Section or single modereading.Reviewandclear suspect links.Edit additional attributes withbooleanandstringtypes.Built-initem diff toolto review changes made on disk.Markdown formatting toolpowered bymdformatfor the text attribute.Pin featurefor easy access to work-in-progress items.And more...TODO list:Add and remove document.Validating documents and items in a user-friendly manner.File watcher for syncing/refreshing when changes made on disk.Ability to change project root.InstallAutomatic install with pip:pipinstalldoorstop-editFor source installation seeContributingsection.Demo/TestingThere is a python script that generates a document tree which can be useful when testing this
application.python3tools/gen_sample_tree.py# Output will be located in the dist/ folder.Other doorstop GUI'sThere exists at least two well known GUI's for doorstop editing,doorholeand the build-in GUI in doorstop.Since both are pretty basic and have missing features when working with a large and complex set of
requrements, this new GUI was created to fill in some gaps.ContributingSeeCONTRIBUTING.md.
Package: doorstoph
OverviewDoorstop is arequirements managementtool that facilitates the storage of textual requirements alongside source code in version control.When a project leverages this tool, each linkable item (requirement, test case, etc.) is stored as a YAML file in a designated directory. The items in each directory form a document. The relationship between documents forms a tree hierarchy. Doorstop provides mechanisms for modifying this tree, validating item traceability, and publishing documents in several formats.Doorstop is under active development and we welcome contributions.
The project is licensed asLGPLv3.
To report a problem or a security vulnerability pleaseraise an issue.
Additional references:publication:JSEA Papertalks:GRDevDay,BarCampsample:Generated HTMLSetupRequirementsPython 3.5+A version control system for requirements storageInstallationInstall Doorstop with pip:$pipinstalldoorstopor add it to yourPoetryproject:$poetryadddoorstopAfter installation, Doorstop is available on the command-line:$doorstop--helpAnd the package is available under the name 'doorstop':$python
>>>importdoorstop
>>>doorstop.__version__UsageSwitch to an existing version control working directory, or create one:$gitinit.Create documentsCreate a new parent requirements document:$doorstopcreateSRD./reqs/srdAdd a few items to that document:$doorstopaddSRD
$doorstopaddSRD
$doorstopaddSRDLink itemsCreate a child document to link to the parent:$doorstopcreateHLTC./tests/hl--parentSRD
$doorstopaddHLTCLink items between documents:$doorstoplinkHLTC001SRD002Publish reportsRun integrity checks on the document tree:$doorstopPublish the documents as HTML:$doorstoppublishall./public
Package: doorway
🚪 DoorwayEssential utilities for working with filesContributionsare welcome!Table Of ContentsOverviewFeaturesOverviewDoorway is a common library for interacting with files.Get started withdoorwayby installing it with $pip install doorwayor cloning this repository.FeaturesDoorway includes the following features:Partial "fast" hashing of filesStale file detectionDownloading with a progress barAtomic file writing and overwriting via a seperate temporary file that is moved into placeFile renaming without affecting the extensionFile renaming to replace the extensionComing SoonDocsExamples
Package: dooti
Manage default handlers for files and URI schemes on MacOS 12.0+.FeaturesManage handlers by specifying file extension, UTI or URI scheme.Specify handlers by name, bundle ID or absolute path.Check your associations into a dotfiles repository and ensure an idempotent state by simply runningdooti apply.InstallationI recommend installing withpipx, although pip will work fine as well:pipxinstalldootiQuickstartdooticurrently supports three specific subcommands (ext,scheme,uti) and a broad one (apply).Lookup handlersSimply pass a list of one specific type to the appropriate command. Example:$dootiexthtmlxmlhtml: /Applications/Firefox.app
xml: /Applications/Sublime Text.app$dooti--formatjsonschemehttphttpsftp|jq{
  "http": "/Applications/Firefox.app",
  "https": "/Applications/Firefox.app",
  "ftp": "/System/Library/CoreServices/Finder.app"
}$dootiutipublic.htmlpublic.html: /Applications/Firefox.appSet handlersChanging the default handler can be requested by adding-x<handler_ref>to the lookup command. The handler reference can be a name, bundle ID or absolute filesystem path. Example:$dootiextcsvxml-x"Sublime Text"The following extensions are set to be changed:
csv: /Applications/Numbers.app -> /Applications/Sublime Text.app
xml: /Applications/Firefox.app -> /Applications/Sublime Text.app$dootischemeftp-x/Applications/Firefox.appThe following scheme is set to be changed:
ftp: /System/Library/CoreServices/Finder.app -> /Applications/Firefox.app$dooti-tfjsonutipublic.c-source-xcom.sublimetext.4{"changes": {"utis": {"public.c-source": {"from": "/Applications/Notes.app", "to": "/Applications/Sublime Text.app"}}}, "errors": []}Ensure statedootican ingest and apply a YAML configuration like this:ext:jpeg:Previewscheme:http:Firefoxmailto:Mailuti:public.c‑source:Sublime Textapp:Sublime Text:ext:-py-rst-yml-yamluti:-public.fortran‑sourceBrave Browser:scheme:-ipfsBy default, it looks at$XDG_CONFIG_HOME/dooti/config.yaml(and others, seedocs/usage.rst).LimitationsThe designated handler has to be installed before running the command.Setting some URI scheme handlers (especially for http) might cause a prompt.Setting some file extension handlers might be restricted (especially html seems to fail silently).Why?Most existing tools useLSSetDefaultRoleHandlerForContentTypeandLSSetDefaultHandlerForURLScheme, which are deprecated in macOS 12.0.dootiuses a more recent API and should work on Monterey (12.0) and above.Similar toolsdutiopenwithdefaultbrowserSwiftDefaultApps
Package: doozerify
Are you aHensonuser? Are you looking to take advantage of unreleased
features? Have you discoveredDoozerand are curious to try it but are
concerned about missing extensions or the work involved in updating your
imports?If you’ve answered “yes” to these questions thendoozerifyis for you.doozerifyis a module that you can install that will makeimportlook
for Doozer equivalents for all of your Henson imports, falling back to the
Henson version if no equivalent is found.Installation$ pip3 install doozerifyUsagePlace the following code at the beginning of the entry point to your
application:import doozerify
doozerify.install()Exampleimport doozerify
doozerify.install()

from henson import Application


class Consumer(object):
    async def read(self):
        return {}


async def callback(app, message):
    return message

app = Application('doozerified', callback=callback, consumer=consumer)
app.run()But wait, there’s more!What if you already useDoozerbut want to use an extension that’s only
available forHenson?doozerifylets you do that, too!import doozerify
doozerify.install()
doozerify.install_fallback()

from doozer import Application
from doozer_henson_only import Extension
Package: dop
DOP is a MIT licensed Python wrapper for Digital Ocean’s API.FeaturesFull support for all methods listedhereexcept (they have weird behaviour):reset_root_passwordrestore_dropletdestroy_imageInstallationTo install dop, simply:$ pip install dopExampleIt is pretty easy to use:fromdop.clientimportClientclient=Client('client_id','api_key')# Print regions.regions=client.regions()forregioninregions:print(region.to_json())# Create a 512Mb droplet (Debian 7.0 x32) in the Amsterdam region.client.create_droplet(name='test',size_id=66,image_id=303619,region_id=2)ContributePull requests and improvements are welcome.Version 0.1.6Python 3 compatibility thanks to Sambodson (https://github.com/samdobson)Version 0.1.5Updated APIVersion 0.1.4Added virtio parameter to create_droplet methodMinor fixes in all_ssh_keys methodReadme region example now uses to_json() methodVersion 0.1.3Added ssh_keys support to Droplet object (thanks to Derek:http://github.com/covertgeek)Version 0.1.2Added ip_address to Droplet object (thanks to Derek:http://github.com/covertgeek)Version 0.1.1Added support for requests 1.x (thanks to Luke:http://github.com/clone1018)Version 0.1.0Initial release
Package: do-pack
A simple and quick command line tool to create python packages.Install$ pip installdo-packUsageThe config command$ do configUse it to fill common fields once (if executed twice it
will overwrite the previous configuration).Create a default python project$ do create<project-name>Create a project using one of the available templates$ do create<project-name>-t<template>-tis the short for–template.Available templates:flaskdjangopymin(minimal python project)To use your own template you need to store it in a.jsonfile in your current
directory, e.g.:my_template.jsonAnd use it by:$ do create my_project-tmy_templateA step by step setup for new projects$ do assistantThis command help you fill:setup.pyAUTHORS.rstLICENSE.gitignorewith rules forLinux,MacOs,Windows,Python,Visual Studio,VS Code,Sublime TextandPycharm(made withhttps://www.gitignore.io/).Default Folder Structure and TemplatesThis is the folder structure created when usingdo create <my_project>anddo assistant.project_folder
â”œâ”€â”€ project
â”‚   â”œâ”€â”€ __init__.py
â”‚   â””â”€â”€ project.py
â”œâ”€â”€ docs
â”‚   â””â”€â”€ index.rst
â”œâ”€â”€ tests
â”‚   â”œâ”€â”€ __init__.py
â”‚   â””â”€â”€ project_test.py
â”œâ”€â”€ .gitignore
â”œâ”€â”€ LICENSE
â”œâ”€â”€ README.rst
â”œâ”€â”€ AUTHORS.rst
â”œâ”€â”€ setup.py
â”œâ”€â”€ requirements.txt
â””â”€â”€ test-requirements.txtThe template system use a.jsonfile in wich the keys are
folders and the values are files.Every time a folder is created, the program will automatically enter
it. If you need to exit that folder so the next one is placed in the
same directory, place a<--in the files (values) as many times needed.Folders (keys)baseandbinare replaced with the project name.project.pyis replaced with the project name (e.g.my_project.py).Intest_projet.py,projectis replaced with the project name
(e.g.test_my_project.py)This is the template for the default folder structure:{
    "base": [
        "LICENSE",
        "setup.py",
        "README.rst",
        "AUTHORS.rst",
        ".gitignore",
        "requirements.txt",
        "test-requirements.txt",
        "MANIFEST.in"
    ],
    "bin": [
        "project.py",
        "__init__.py",
        "<--"
    ],
    "docs": [
        "index.rst",
        "<--"
    ],
    "tests": [
        "__init__.py",
        "test_project.py",
        "<--"
    ]
}TODOsImplement--templatefor  theassistantcommand (75%).Add github username to theconfigcommand for the project
url.Generate the documentation (sphinx).
Package: dopameme
dopamemeprovides you with that quick hit of cute dopamine that you know you crave! It’s a simple command line tool
for those dark days where you just need to see something adorable to get through the day. Usage is simple! Simply run
the command from a terminal and a cute image will open in your default browser. For example:$ dopameme
INFO: Welcome to Dopameme!
  |\__/,|   (`\
_.|o o  |_   ) )
---(((---(((---------
INFO: Search Terms: cute birdyAn image of a cute birdy will appear in your web browser. Run it again for a totally different hit:$ dopameme
INFO: Welcome to Dopameme!
      |\__/,|   (`\
    _.|o o  |_   ) )
---(((---(((---------
INFO: Search Terms: smol butterfly
Package: dopaminekit
This packages provides a class for interacting with the DopamineAPI from a python project. After you have received your API key and configured the actions and reinforcements relevant to your app on the [Dopamine Developer Dashboard](dashboard.usedopamine.com), you may use this class to place ‘tracking()’, and ‘reinforcement()’ calls from inside your app that will communicate directly with the machine learning based DopamineAPI.
Package: dope3
Double-Ratchet Over Parity Exchange(DOPE)Python3 Implementation of DOPE EncryptionInstallationFrom sourceTo install from source use the following command, make sure you havesetuptools>=50.0.0python3seutp.pyinstallFrom PyPIpip3installdope3Using the DOPE APIImport DOPEfromdope3importDOPEOnce the dope package is imported you need to create the Dope class and initialize it with the required parameters
The parameters include:Your private KeyReceiver's Public KeySession Key SizeBCH PolynomialError Correcting Code SizeRacheting mode (BLAKE0x0/BLAKEx0x)AES Mode(GCM/SIV/CBC/OFB)HMAC(SHA256/SHA384/SHA512)Key Mode(XOR-BL/AND-BL)Using the DOPE2 APIImport DOPE2fromdope3importDOPE2Once the dope package is imported you need to create the Dope class and initialize it with the required parameters
The parameters include:Your KeyBCH PolynomialError Correcting Code SizeAES Mode(GCM/SIV/CBC/OFB)NonceBlock Size