Saravanan666/pypi-org huggingface dataset:
Package: dominion-grpc-proto
Dominon gRPC protoThegRPCprotobuf definitions for theDominionprojectThedominion.protofile specifies the Dominion service definition. The Makefile creates two Python modules that can be used by the Dominion server and clients.Build and publishThis section is for the Dominion developers.
If you just want to implement a player or a client library you can stop reading.Pre-requisitesInstallpyenvorpyenv-winInstallpoetryCreate a Python 3.8.2 environment$ pyenv install 3.8.2
$ pyenv local
$ poetry init
$ poetry env use 3.8.2
$ poetry installSave the following to ~/.pypirc[distutils]
index-servers=
    pypi
    pypitest

[pypitest]
repository = https://test.pypi.org/legacy/
username = <your user name>

[pypi]
repository = https://pypi.org/legacy/
username = <your user name>Building the gRPC generated codeJust runmakeBuilding the packageBump the version in the setup.py fileHere is the command to build the package:(🐙)/dominion-grpc-proto
$ poetry run python setup.py bdist_wheelThe result is tar-gzipped file in the dist subdirectory:(🐙)/dominion-grpc-proto
$ ls dist
dominion_grpc_proto-0.2.0-py3-none-any.whlPublish the packageNext, we can upload the package using twine to PyPI.(🐙)/dominion-grpc-proto
$ poetry run twine upload -p <redacted> dist/*.whl

Uploading distributions to https://upload.pypi.org/legacy/
Uploading dominion_grpc_proto-0.2.0-py3-none-any.whl
100%|███████████████████████████████████| 10.3k/10.3k [00:02<00:00, 3.54kB/s]

View at:
https://pypi.org/project/dominion-grpc-proto/0.2.0/
Package: dominion-object-model
Dominion object modelThis package contains two abstract base classes for implementing players
and client libraries for thedominionproject.You can implement a GUI client for humans to play the game or an AI computer
player.UsageA dominion player must implement the Player interface. The dominion game engine
will keep a reference to the player object and call its methods at the right time.class Player(metaclass=ABCMeta):
    @abstractmethod
    def play(self):
        pass

    @abstractmethod
    def respond(self, action, *args):
        pass

    @abstractmethod
    def on_game_event(self, event):
        pass

    @abstractmethod
    def on_state_change(self, state):
        passA client library will implement the GameClient interface and a reference
to it will be passed to concrete player implementations. When the concrete
player who implements the Player interface receives the play() command
from the game engine it will invoke various GameClient methods until
it finally calls done() and their turn ends.class GameClient(metaclass=ABCMeta):
    @abstractmethod
    def play_action_card(self, card_type: str):
        pass

    @abstractmethod
    def buy(self, card_type: str):
        pass

    @abstractmethod
    def done(self):
        passExamplesThe dominion project itself contains severalcomputer players.Thedominion-pygameproject is an implementation of a GUI client that lets humans play against each other and or bots.Build and publishThis section is for the Dominion developers.
If you just want to implement a player or a client library you can stop reading.Pre-requisitesInstallpyenvorpyenv-winInstallpoetryCreate a Python 3.8.2 environment$ pyenv install 3.8.2
$ pyenv local
$ poetry init
$ poetry env use 3.8.2
$ poetry installBuilding the packageHere is the command to build the package:(🐙)/dominion-object-model
$ poetry run python setup.py bdist_wheelThe result is tar-gzipped file in the dist subdirectory:(🐙)/dominion-object-model
$ ls dist
dominion_object_model-1.0.1-py3-none-any.whlSave the following to ~/.pypirc[distutils]
index-servers=
    pypi
    pypitest

[pypitest]
repository = https://test.pypi.org/legacy/
username = <your user name>

[pypi]
repository = https://pypi.org/legacy/
username = <your user name>Next, we can upload the package using twine to PyPI.(🐙)/dominion-object-model
$ poetry run twine upload -p <redacted> dist/*.whl

Uploading distributions to https://upload.pypi.org/legacy/
Uploading dominion_object_model-1.0.2-py3-none-any.whl
100%|██████████████████████████████| 10.2k/10.2k [00:01<00:00, 7.20kB/s]

View at:
https://pypi.org/project/dominion-object-model/1.0.2
Package: dominions
dominionsA Python package to check a domain against confusables, levenshtein distance, and more using a single interface.InstallingIn order to use this python pacakge you must first install it using:python3.6setup.pyinstallUsing PackageYou can use the Python package by importing it into your script:fromdominionsimportDominionsdominions=Dominions()dominions.domain='giphy.com'print(dominions.contained_in())print(dominions.confusables())print(dominions.levenshtein())print(dominions.all())dominions.domain=['giphy.com','swimlane.com','paypal.com']print(dominions.contained_in())print(dominions.confusables())print(dominions.levenshtein())print(dominions.all())Using Command Line Utilitydominionscomes with a command line utility that you can use.dominions--domain'giphy.com'allBuilt Withcarcass- Python packaging templateContributingPlease readCONTRIBUTING.mdfor details on our code of conduct, and the process for submitting pull requests to us.VersioningWe useSemVerfor versioning.AuthorsNick Tausek -Initial workJosh Rickard - Package -MSAdministratorSee also the list ofcontributorswho participated in this project.LicenseThis project is licensed under the MIT License - see theLICENSEfile for details
Package: dominius-nbk
Copyright (c) 2018 The Python Packaging AuthorityPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: domino
DominoDiscover slices of data on which your models underperform.Getting Started|What is domino?|Docs|Contributing|Paper|About⚡️ QuickstartpipinstalldominoFor more detailed installation instructions, see thedocs.importdominoTo learn more follow along in our tutorial onGoogle Colabor dive into thedocs.🍕 What is Domino?Machine learning models that achieve high overall accuracy often make systematic errors on coherent slices of validation data. Domino provides tools to help discover these slices.What is a slice?A slice is a set of data samples that share a common characteristic. As an example, in large image datasets, photos of vintage cars comprise a slice (i.e. all images in the slice share a common subject). The term slice has a number of synonyms  that you might be more familiar with (e.g. subgroup, subpopulation, stratum).Slice discovery is the task of mining unstructured input data (e.g. images, videos, audio) for semantically meaningful subgroups on which a model performs poorly. We refer to automated techniques that mine input data for semantically meaningful slices as slice discovery methods (SDM). Given a labeled validation dataset and a trained classifier, an SDM computes a set of slicing functions that partition the dataset into slices. This process is illustrated below.This repository is nameddominoin reference to the pizza chain of the same name, known for its reliable slice deliveries. It is a slice discovery hub that provides implementations of popular slice discovery methods under a common API. It also provides tools for running quantative evaluations of slice discovery methods.To see a full list of implemented methods, see thedocs.🔗 Useful Links💻GitHub📘DocsPapers:📄ICLR 2022 PaperBlogposts:🌍BlogPost✉️ AboutReach out to Sabri Eyuboglu (eyuboglu [at] stanford [dot] edu) if you would like to get involved or contribute!
Package: domino-composite
Domino is a package for analysing composites of atmospheric data.Based on xarray, Domino makes it easy to calculate lagged composites of fields and scalar indices around categorical event time series, and to compute bootstrapped confidence bounds. This is still an alpha release! While core functionality is stable, there could be some bugs!DocumentationSeehttps://github.com/joshdorrington/domino/blob/master/docbuild/domino-composite.pdfExamplesA basic introduction to using the package out of the box, with three example applications:https://github.com/joshdorrington/domino/blob/master/examples/basic_usage.ipynbA more in-depth discussion of how to customise the behaviour of the LaggedAnalyser class:https://github.com/joshdorrington/domino/blob/master/examples/advanced_usage.ipynbInstalldomino can be installed using pip:python -m pip install "domino-composite==0.14"
Package: domino-data-capture
Domino Data CaptureDomino Data capture repository which captures user provided prediction dataHow to installThis python package is hosted inpypi. Use commandpip install domino-data-captureto install.How to usePlease refer tolibrary_usage.pyfor a complete usage example🛡 LicenseThis project is licensed under the terms of theApache Software License 2.0license. SeeLICENSEfor more details.Important make rulesHere are the available make rules that will help you in easing your development workmakeinstall-poetry->Installspoetry
makepoetry-remove->Uninstallspoetry
makeinstall->Installspoetrydependencies
makepre-commit-install->Installprecommithooks
makecodestyle->Runscodestylecheckwithblackandisort
makeformatting->Runscodestyle
maketest->Runstests
makecheck-codestyle->Checkscodestyle
makecheck-safety->Checkssafetyandgeneratesfullreport
makelint->Runslintingcheckwithblack
makebuild->Buildspythonartifacts
makepublish->PublishesatrifactstopypiBuild and Release processBuild and Release happens through poetry. Refer to the below commands.poetrybuild->Buildsartefacts
poetrypublish->PublishesartefactstopypiSupport policyFor support policy please refer to thereadme.txtpresent in this repo.
Package: dominodatalab-data
Domino Data APIDomino Data API for interacting with Access Data featuresInstallationpipinstall-Udominodatalab-dataor install withPoetrypoetryadddominodatalab-dataMakefile 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,blackanddarglintlibrary4. Code securitymakecheck-safetyThis command launchesPoetryintegrity checks as well as identifies security issues withSafetyandBandit.makecheck-safety5. Type checksRunmypystatic type checkermakemypy6. TestsRunpytestmaketest7. All lintersOf course there is a command torulerun all linters in one:makelintthe same as:maketest&&makecheck-codestyle&&makemypy&&makecheck-safety8. CleanupDelete pycache filesmakepycache-removeRemove package buildmakebuild-removeOr to remove pycache and build:makeclean-all9. DocsBuild the documentationmakedocsOpen the docs index pagemakeopen-docs📈 ReleasesYou can see the list of available releases on theGitHub Releasespage.We followSemantic Versionsspecification.We useRelease Drafter. As pull requests are merged, a draft release 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.List of labels and corresponding titlesLabelTitle in Releasesenhancement,feature🚀 Featuresbug,refactoring,bugfix,fix🔧 Fixes & Refactoringbuild,ci,testing📦 Build System & CI/CDbreaking💥 Breaking Changesdocumentation📝 Documentationdependencies⬆️ Dependencies updatesYou can update it inrelease-drafter.yml.GitHub creates thebug,enhancement, anddocumentationlabels for you. Dependabot creates thedependencieslabel. Create the remaining labels on the Issues tab of your GitHub repository, when you need them.🛡 LicenseThis project is licensed under the terms of theApache Software License 2.0license. SeeLICENSEfor more details.📃 Citation@misc{dominodatalab-data,author={dominodatalab},title={Domino Data API for interacting with Access Data features},year={2021},publisher={GitHub},journal={GitHub repository},howpublished={\url{https://github.com/dominodatalab/domino-data}}}CreditsThis project was generated withpython-package-template
Package: dominos
Dominos Pizza remains today a closed system, not officially offering a public API from which to order delicious baked pizzas. However with the invent of their multiple mobile applications and their own website having been reimplemented in AngularJS it was apparent these all used some undocumented public API.This packages implements an abstract layer to the Dominos Pizza (UK) API, returning raw response objects from which JSON payloads can be read.InstallationPyPiTo install dominos, simply:$pipinstalldominosGitHubInstalling the latest version from Github:$gitclonehttps://github.com/tomasbasham/dominos$cddominos$pythonsetup.pyinstallUsageTo use this package you simply have to instantiate a Dominos object:fromdominos.apiimportClientapi=Client()response=api.get_nearest_store('AB12 000')print(response.json())This returns the nearest store to the supplied postcode. There are many other methods implemented in this package to return store menus, add items to a basket and checkout.ContributingFork it (https://github.com/tomasbasham/dominos/fork)Create your feature branch (git checkout -b my-new-feature)Commit your changes (git commit -am ‘Add some feature’)Push to the branch (git push origin my-new-feature)Create a new Pull Request
Package: dominosort
Sort sequences with respect to the similarity of consecutive items.DefinitionGiven a sequence of items\((x_i, y_i)\), where each item is represented by two values\(x, y\), the goal is to sort the sequence such that the following loss
is minimal:\begin{equation*}
L = \sum_{i=1}^{N-1} \mu(y_i, x_{i+1})
\end{equation*}where\(\mu\)denotes a suitable metric for the items’ values.ExampleGiven the items>>>items=[...(0.4,0.6),...(0.0,0.2),...(0.8,1.0),...(0.6,0.8),...(0.2,0.4),...]together with the L1 distance\(\mu: (x, y) \rightarrow |x-y|\), the current loss is>>>abs(0.6-0.0)+abs(0.2-0.8)+abs(1.0-0.6)+abs(0.8-0.2)2.2Clearly the optimal sort order which minimizes the loss is>>> optimal = [
   ...     (0.0, 0.2),
   ...     (0.2, 0.4),
   ...     (0.4, 1.6),
   ...     (0.6, 0.8),
   ...     (0.8, 1.0),
   ... ]Related topicsNote that for the special case where\(x_i = y_i\)and the\(x_i\)represent 2d-coordinates
this corresponds to the Travelling Salesman Problem without return to the origin.
Package: dominus-python-sdk
Dominus SDK for PythonDominus is an entity intelligence engine.It’s used as a tool for entity resolution, mastering, traversal, and exploration.Dominus helps unite all of your entities and express powerful queries that you always imagined.InstallationInstalling the Dominus python client takes just a few seconds:pipinstalldominus-python-sdkProtoThis package uses grpclib for streaming using asyncio, this requires proto to be generated by:python-mgrpc_tools.protoc-I./protos--python_out=.--grpc_python_out=.--grpclib_python_out=../protos/dominus/DominusService.protoExamplesExplore the examples in order to gain an understanding for how to perform entity resolution.├──examples
│└──basic.pyCopyright (C) 2020 Aristos Data, LLC
Package: dominx
dominxThedominxlibrary is a powerful high-level Python library designed specifically for game
development, leveraging the low-level APIs of operating systems like Win32, X11, Cocoa, and more.
It offers a seamless interface for game developers to harness the full potential of these
low-level APIs without getting bogged down in complex code.InstallationYou can install the library usingpip. Before installation, ensure you have Python and pip
installed on your system. The library requires Python 3.7 or later to function properly.pipinstalldominxAlternatively, you can install the latest version directly from the GitHub repository:pipinstallgit+https://github.com/zenthm/dominx.gitContributingIf you're interested in contributing to the project, please read theContributing Guidelines.
We welcome contributions from the community and appreciate your interest in making the project even
better!Code of ConductI am committed to treating everyone with respect and kindness, regardless of their background,
beliefs, or identity. As a member of the open source community, I believe it is important to create
a welcoming and inclusive environment for all.To that end, I ask that anyone who interacts with this project or contributes to it follow thisCode of Conduct.
The Code of Conduct outlines specific behaviors that are expected of contributors and community
members, as well as the consequences for violating the Code of Conduct.If I observe or experience any behavior that violates this Code of Conduct, I may take any action I
deem appropriate, including warning the offender or blocking them from further interaction with
this project.I take this Code of Conduct seriously and am committed to creating a positive and respectful
environment for everyone who interacts with this project.LicenseThis project is licensed under the MIT License - see theLICENSEfile for details.
Package: domophoenix
Domo PhoenixBuild Domo Phoenix Charts using Python.InstallationThis module uses Python 3.$python3-mpipinstalldomophoenixUsageFrom your Jupyter notebook, enter the following in a cell:data=[['Low','Corporate',8582.8875],['High','Home Office',14415.941],['Low','Consumer',1264.8215],['Medium','Small Business',21478.799],['Critical','Consumer',2621.97],['Not Specified','Consumer',2211.31],['Critical','Corporate',10087.1315],['Not Specified','Corporate',4407.138],['High','Consumer',11667.366],['High','Corporate',19503.323],['Low','Small Business',1735.3715],['Low','Home Office',10057.42],['Medium','Home Office',7691.02],['Critical','Small Business',4036.064],['Not Specified','Small Business',84.99],['High','Small Business',689.74],['Critical','Home Office',7416.828],['Not Specified','Home Office',1839.26],['Medium','Consumer',4280.034],['Medium','Corporate',7965.238]]columns=[{"type":'STRING',"name":'Order Priority',"mapping":'SERIES'},{"type":'STRING',"name":'Customer Segment',"mapping":'ITEM'},{"type":'DOUBLE',"name":'Sales',"mapping":'VALUE'}]fromdomophoeniximportDomoPhoenixPlotterplotter=DomoPhoenixPlotter()plotter.plot(data,columns,'badge_vert_bar')When you run the chart, you'll see your chart rendered!
Package: domore-api
Domore ApiDomore Apiis a quick and handy tool for http(s) api testing. Enjoy it! ✨ 🚀 ✨Design PhilosophyConvention over configurationROI mattersEmbrace open source, leveragerequests,pytest,pydantic,allure,pytest-htmlandlocust.Key FeaturesInherit all powerful features ofrequests, just have fun to handle HTTP(S) in human way.Define testcase in YAML or JSON format, run withpytestin concise and elegant manner.Record and generate testcases withHARsupport.Supportsvariables/extract/validate/hooksmechanisms to create extremely complex test scenarios.Withdebugtalk.pyplugin, any function can be used in any part of your testcase.Withjmespath, extract and validate json response has never been easier.Withpytest, hundreds of plugins are readily available.Withallureorpytest-html, test report can be pretty nice and powerful.With reuse oflocust, you can run performance test without extra work.CLI command supported, perfect combination withCI/CD.SponsorsThank you to all our sponsors! ✨🍰✨
Package: domovyk
DomovykA package to transliterate various Cyrillic alphabets to and from the Latin alphabet using the American Library Association-Library of Congress Romanization tables.Domovyk is named after household spirits from Slavic mythology.InstallationInstall using pip:pip3 install domovykOr download the GitHub repo and the install the only dependency (for sentence tokenization):pip3 install nltkUsageThe package uses the ALA-LC Romanization tables to transliterate each of the following languages:BelarusianBulgarianCarpatho-RusynChurch SlavonicMacedonianRussianSerbianUkrainianFour functions can be called for each language:transliterate(var, lang) - Transliterates a Cyrillic string or list of strings (var) from a specified language (lang) into the Latin alphabet. Returns a string.translatinate(var, lang) - Transliterates a string or list of strings in the Latin alphabet (var) to a specified Cyrillic script (lang). Returns a string.transliterateSents(var, lang) - Tokenizes a given Cyrillic (var) into a list of sentences, then transliterates those sentences from a specified language (lang) into the Latin alphabet. Returns a list.translatinateSents(var, lang) - Tokenizes a given string in the Latin alphabet (var) into a list of sentences, then transliterates those sentences  to a specified Cyrillic script (lang). Returns a list.Some usage examples are below:from domovyk import translit

belarusian_to_latin = translit.transliterate('Як справы?', 'bel')
latin_to_macedonian = translit.translatinate('Hi, how are you?', 'mac')
ukrainian_to_latin_sents = translit.transliterateSents('Єхидна, ґава, їжак ще й шиплячі плазуни бігцем форсують Янцзи.', 'ukr')
latin_to_russian_sents = translit.translatinateSents('Hello, how are you doing?', 'rus')The languages can be called in the code using the following abbreviations:Belarusian - 'bel'Bulgarian - 'bulg'Carpatho-Rusyn - 'carp'Church Slavonic - 'church'Macedonian - 'mac'Russian 'rus'Serbian - 'serb'Ukrainian - 'ukr'