Saravanan666/pypi-org huggingface dataset:
Package: dosbox-screen
– Screen positioning and colors in the dos shell (and unix too)Installationpip install doscmd-screenChangesVersion 1.1.0 introducesScreen.color("txt",fg='white',bg='blue')which
returns a string that can later be printed.Version 1.0.3 introduces thread safe window areas through the Window class.Changes in version 1.0 include support for non-dos platforms, a visual
test script, and zero-based indexing of screen positions. Since the last
one is a backwards incompatible change I have upped the major version
number. I don’t forsee any further backwards incompatible changes in
this module.DocumentationThe documentation lives athttp://doscmd-screen.readthedocs.org/UsageStraight forward positioning and terminal colors in the terminal:import screen  # screen probably needs to be your first import.
scr = Screen()
scr.centerxy(scr.center, scr.middle, '((.))')

scr.writexy(scr.left, scr.bottom,
            'left bottom',
                    color='black', on='red')Works for both Windows....and unix-like terminals:
Package: dosca
AboutJust parses ini-style file and return dict with values. Really simple.FeaturesKnows str, int, list, boolean and None typesSupports sections and subsectionsSupports custom convertersEasy to use – one function!APIparsefunction takes any iterable (fileobj, for example), which produces strings and returns filleddictor raisesParseError.parse_filehelper function takes path to file, opens it and passes fileobj toparsefunctino.FAQQ1: Does ‘dosca’ have validation capabilities?A1: No, it’s not. If you want validate your config, use library designed for this task.Contract,Procrustesor, perhaps,Damn Simple Validation Library?Q2: Does it support interpolation or some complex types?A2: No, it’s not. When I say ‘simple’, I mean really simple. Dosca only support basic things, essential for parsing config files.
If you want advanced features, useConfigObjorConfigParser. Or xml and dtd?Q3: How to use this library?
A3: Just pass fileobj to dosca.parse or see test_dosca.py for details.Install~/yourvirtualenv/python setup.py installpip install doscaLicenseThe MIT License, in LICENSE file.
Package: dosdp
Dead simple owl design pattern (DOS-DP) exchange formatFor details please see:Dead Simple OWL Design PatternsDavid Osumi-Sutherland, Melanie Courtot, James P. Balhoff and Christopher Mungall
Journal of Biomedical Semantics 2017 8:18 DOI:10.1186/s13326-017-0126-0MotivationThe job of editing the GO and many other OBOish OWL ontologies increasingly involves specifying OWL design patterns.  We need a simple, light-weight standard for specifying these design patterns that can then be used for generating documentation, generating new terms and retrofitting old ones. The solution must be readable and editable by anyone with a basic knowledge of OWL and the ability to read manchester syntax.  It must also be easy to use programatically without the need for custom parsers - i.e. it should follow some existing data exchange standard.Human readability and editability requires that Manchester syntax be written using labels, but sustainability and consistency checking requires that the pattern record IDs.ApproachPatterns are specified in the subset of YAML that can be converted to JSON.JSON format is the ideal exchange format for programatic consumption: It is already javascript; Standard libraries are available to convert it into datastructures in many languages;Developers are typically experienced at consuming it.ButYAML is much easier than JSON for humans to edit (it can be difficult for human editors to keep curly braces and quotes balanced and to add commas correctly in JSON). YAML also has the great advantage over JSON of allowing comments to be embedded.Conversion between YAML and JSON is trivialAll patterns contain dictionaries (hash lookups) that can be used to lookup up OWL shortform IDs from labels.  OWL ShortFormIDs are assumed to be sufficient for entity resolution during usage of the pattern.  Labels are assumed to be sufficient for entity resolutionwithina pattern.Variable interpolation into Manchester syntax and text is specified usingprintf format strings.  Variable names are stored in associated lists.Variables are specified in a dictionary with variable name as key and value as range specified as a Manchester syntax expresssion.DOSDP Specification:JSON schema specification in YAML.The same specificationrendered in mardown, with references resolved. This is generated from the original spec using thedosdp documentcommand (see below for details).Setuppip install dosdpSeehttps://pypi.org/project/dosdp/Validator specSeevalidator documentationDocumentation generation specSeedocumentation_generationImplementationThe aim of this project is to specify a simple design pattern system that can easily be consumed, whatever your code base.
This repository includes a simple Python validator (src/simple_pattern_tester.py).For implementation, we recommenddosdp-tools.UsesENVO: envopatterns/OBA: obapatterns/draft environmental conditions ontology: ectopatterns/Uberon: uberonpatterns/uPhenoMondo
Package: dosei
Dosei Python SDKdoseiis the official Dosei SDK for PythonGetting StartedRequirementsPython 3.11.2InstallYou can install and configuredoseiusing this command:pipinstall-UdoseiConfigurefromfastapiimportFastAPIimportdosei.integrations.fastapiasdosei_fastapi_integrationapp=FastAPI()dosei_fastapi_integration.init(app)
Package: dosei-sdk
Dosei Python SDKdosei-sdkis the official Dosei SDK for PythonGetting StartedRequirementsPython 3.11.2InstallYou can install and configuredosei-sdkusing this command:pipinstall-Udosei-sdkConfigurefromdosei_sdkimportDoseidosei=Dosei()@dosei.cron_job("* * * * *")defcron_job():print("hello world!")
Package: dose-response
DRCThe script uses the formula for the 4PL-Dose-Response-Curve for fitting:Y = Bottom + (Top - Bottom) / (1 + 10 ** (HillSlope * (lg EC50 - lg X)))CAVE: Default unit is µM and confidence level is 0.05 (to change: use the python class manually)Input:A csv file with doses and its corresponding responsesOutput:A logarithmic dose-response plot of the fitted curce with standard error barsA csv file with the fitted parameters, their SD and the lower and upper bounds of the CIUsageInstall DRCgit clone https://github.com/tim25651/DRC
 cd DRC/
 pip install .Provide your data results in a CSV file without headers (Mark values to exclude with an * as suffix).0.01000.96480.9071*1.13551.08460.02001.04101.29951.05211.15350.05001.09671.15541.07801.22590.01001.21171.21741.31700.99170.02001.16441.6411*1.30841.29870.05001.48811.75001.73051.34651.00002.06012.23392.26201.84932.00001.7824*2.4520*2.17122.15715.00002.78542.69342.87192.948810.00003.1894*2.46372.33802.5128Execute DRCfile: CSV file with data
 -d, --dose-col: Column index of doses: [Default: 0]
 -r, --response-cols: start and end index of response columns: [Default: every other column]
 -o, --out Output directory [Default: current working directory]

 
 drc DataFile -d DoseColumnIndex -r ResponseStartIndex ResponseEndIndex -o OutputDir
 
 drc demo/demo.csv -d 0 -r 1 4 -o demoPlot is stored in OutputDirectory/DataFileBase_plot.pngdemo/demo_plot.pngParameters are stored in OutputDirectory/DataFileBase_params.csvdemo/demo_params.csvParameterMeanSDCI_LowerCI_UpperHill Slope1.71230.39330.91012.5144Top2.65910.04942.55822.7599Bottom1.11780.08550.94331.2922EC500.78740.10280.57780.9969LogEC50-0.1038-0.2382-0.0013TestCreate test datadrc-test TestDataFileExecute DRCdrc TestDataFileAcknowledgmentsThanks to yannabraham (https://gist.github.com/yannabraham/5f210fed773785d8b638)
Package: dosertools
dosertoolsdosertools is a Python package for analyzing dripping-onto-substrate extensional rheology (DoSER) videos.The software converts an input video into a series of binary images, produces a dataset of D/D0 and time values for
each frame in the video, and generates values for the elongational relaxation time lambda_E, the diameter at critical
time (the onset of elasto-capillary behavior) D(t_c)/D0, and a guess for the quantity of
(elongational viscosity / surface tension) eta_E/sigma.AuthorsRob Learsch and Red LhotaContact:rlearsch (at) caltech (dot) eduInstallationdosertools comes bundled with a pipfile which creates the python environment it needs to run.
Use the package managerpipto install pipenv.
You will need to install
pipenv if your installation of python doesn't have it. You can do this by typingpipinstallpipenvin your terminal, followed bypipenvinstallin the terminal from your dosertools directory.See the file named "example-and-settings.md" and "example_script.py" for more information
on how to use this package.Usagedosertools is expecting experiments that contain a pair of videos - one "experimental" video that contains
the fluid transitioning from needle to substrate, and one "background" video that contains only the
needle and the literal background of the camera's view. In our testing, we found a background video
of 100 frames gives plenty of data to overcome any noise that would be found in a single frame.dosertools is written for DoSER videos of viscoelastic fluids. It can perform background
subtraction and image processing on videos of any type. However, the data processing
(calculating elongational relaxation time, elongational viscosity, etc) is done using assumptions that
are only true for fluids that exhibit elastocapillary behavior.dosertools calculates values with machine precision. It is up to the user to decide where to truncate the
data produced, based on the specifics of their own experimental setup.LicenseMIT LicenseCopyright (c) 2022 Red C. Lhota and Robert W. LearschPermission 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: dosh-core
DOSH-CORE - shell-independent task managerDOSH-COREis a common library for parsingdosh.luascript file. The official CLI ishere.CONTRIBUTIONInstall these development dependencies manually:poetrypoethepoetpre-commit$poetrypoe--help[...]CONFIGUREDTASKSlintCheckcodequalitytestRuntestsnameFiltertestsby$name
Package: dos-image-processing
desafio DIOpackage_nameDescription.
The package image_processing is used to:
Processing:
- Histogram matching
- Structural similarity
- Resize image
Utils:
- Read image
- Save image
- Plot image
- Plot result
- Plot histogramInstallationUse the package managerpipto install package_namepipinstalldos_image_processingAuthorKarinaLicenseMIT
Package: dossier.fc
`dossier.fc` is a Python package that provides an implementation of featurecollections. Abstractly, a feature collection is a map from feature name toa feature. While any type of feature can be supported, the core focus of thispackage is on *multisets* or "bags of words" (BOW). In this package, thedefault multiset implementation is a `StringCounter`, which maps Unicodestrings to counts.This package also includes utilities for serializing and deserializatingcollections of feature collections to CBOR (Concise Binary ObjectRepresentation).### Installation`dossier.fc` is on PyPI and can be installed with `pip`:```bashpip install dossier.fc```Currently, `dossier.fc` requires Python 2.7. It is not yet Python 3 compatible.### DocumentationAPI documentation with examples is available as part of the Dossier Stackdocumentation:[http://dossier-stack.readthedocs.org](http://dossier-stack.readthedocs.org#module-dossier.fc)### Examples and basic usageBy default, feature collections use `StringCounter` for feature representation:```pythonfrom dossier.fc import FeatureCollectionfc = FeatureCollection()fc['NAME']['alice'] += 1fc['NAME']['bob'] = 5print type(fc['NAME'])# output: StringCounter```As the name suggests, a `StringCounter` is a subclass of the `Counter` classfound in the Python standard library `collections` module. As such, it supportsbinary operations like addition, subtraction, equality testing, etc.The `FeatureCollection` class also provides these binary operations which areperformed on corresponding features. For example:```pythonfrom dossier.fc import FeatureCollectionfc1 = FeatureCollection({'NAME': {'alice': 1, 'bob': 1}})fc2 = FeatureCollection({'NAME': {'alice': 1}})fc3 = fc1 + fc2assert fc3 == FeatureCollection({'NAME': {'alice': 2, 'bob': 1}})```
Package: dossier.label
dossier.labelis a Python package that provides an API to store and
query labels (or “ground truth”) in a database backend via kvlayer,
which currently include support for PostgreSQL, Accumulo and Redis.Installationdossier.labelis on PyPI and can be installed withpip:pipinstalldossier.labelCurrently,dossier.labelrequires Python 2.7. It is not yet Python 3
compatible.DocumentationAPI documentation with examples is available as part of the Dossier
Stack documentation:http://dossier-stack.readthedocs.org
Package: dossier.store
`dossier.store` is a Python package that provides database storage forfeature collections in DossierStack. It is built on top of `kvlayer`, soit supports many database backends like PostgreSQL, Accumulo and Redis.`dossier.store` also provides support for defining basic indexes.### Installation`dossier.store` is on PyPI and can be installed with `pip`:```bashpip install dossier.store```Currently, `dossier.store` requires Python 2.7. It is not yet Python 3compatible.### DocumentationAPI documentation with examples is available as part of the Dossier Stackdocumentation:[http://dossier-stack.readthedocs.org](http://dossier-stack.readthedocs.org#module-dossier.store)### Basic exampleA full working example that uses local memory to store a feature collection:```pythonfrom dossier.fc import FeatureCollectionfrom dossier.store import Storeimport kvlayerimport yakonfigyaml = """kvlayer:app_name: storenamespace: dossierstorage_type: local"""with yakonfig.defaulted_config([kvlayer], yaml=yaml):store = Store(kvlayer.client())fc = FeatureCollection({u'NAME': {'Foo': 1, 'Bar': 2}})store.put([('1', fc)])print store.get('1')```### Example using indexesHere is another example that demonstrates use of indexing to enable apoor man's case insensitive search:```pythonfc = dossier.fc.FeatureCollection()fc[u'NAME'][u'foo'] += 1fc[u'NAME'][u'bar'] = 42kvl = kvlayer.client()store = dossier.store.Store(kvl)# Index transforms must be defined on every instance of `Store`.# (The index data is persisted; the transforms themselves are# ephemeral.)store.define_index(u'name_casei',create=feature_index(u'NAME'),transform=lambda s: s.lower().encode('utf-8'))store.put('{yourid}', fc)  # `put` automatically updates indexes.assert list(store.index_scan(u'name_casei', 'FoO'))[0] == '{yourid}'```
Package: dossier.web
dossier.webis a Python package that provides various web services
for DossierStack.Installationdossier.webis on PyPI and can be installed withpip:pipinstalldossier.webCurrently,dossier.webrequires Python 2.7. It is not yet Python 3
compatible.DocumentationAPI documentation with examples is available as part of the Dossier
Stack documentation:http://dossier-stack.readthedocs.org
Package: dost
DOSTproject that is a utility module for Python.
This package is a collection of utilities that you can use in your projects.Table Of ContentsClipboardConverterExcelFileFolderKeyboardMailMessageMousePdfTextUtilityVoiceWindowsQuickly find what you're looking for depending on
your use case by looking at the different pages.AcknowledgementsI would like to thank the people who have made this project possible.
My sincere thanks to all the authors of the packages that I have used in this project.
Package: dostack
DoBuild=======Docker Container Builder------------------------`dobuild` builds your project's containers specified by a compose-like yaml file.`dotempl` templates files (eg. Dockerfiles, docker-stack.yaml's) based on the environment.Installing----------git clone <this repo>pipsi install ./dostackFeatures--------- Build multiple containers with one command- Control order of builds with inter-container dependencies- Templating Dockerfiles, e.g.  so that one container can FROM another without having to edit Dockerfile each buildGetting Started---------------Create a `dobuild.yaml` file in your project root, with a structure like this:containers:pinger:context: ./docker/pingerdockerfile: ./docker/pinger/Dockerfile.thello:context: .dockerfile: ./docker/hello/Dockerfile.thello2:context: ./docker/hello2dockerfile: ./docker/hello2/Dockerfile.tdepends_on:- helloThis example defines three containers to be built, *pinger*, *hello* and *hello2*. Here we have declared that *hello2* depends on *hello*, so *hello* will always be built before *hello2*.Now to build your containers, rundobuildAnd watch it happen! `dobuild` runs `docker build` under the hood for you, so the output will be familiar.If for example, you only want to a build specific container (and it's dependencies), you can use:dobuild hello2which will build *hello2* (and *hello* as it's a dependency), but not *pinger*.Templates---------`dobuild` templates your Dockerfiles using [moustache](https://mustache.github.io/mustache.5.html) templates.For example, the Dockerfile for *hello2* above:FROM {{ containers.hello }}RUN echo "Building {{ containers.hello2 }}"ENTRYPOINT echo Hello, World, 2!You can use `{{ containers.<name> }}` to refer to the uri of any container in the project in the current build. Other available tags:- `{{ docker.registry }}` The docker registry added to container URIs, if defined.- `{{ docker.prefix }}` The prefix added to container URIs, if defined.Container URIs (Tags)---------------------After building your containers, `dobuild` will tag them with meaningful names composed of a registry, prefix and the container name.For example, running:dobuild hello \--registry registry.example.com \--prefix owner/helloworldWill build and tag the image with URI `registry.example.com/owner/helloworld/hello`.Pushing to a Registry---------------------If you add the `--push` flag, and all containers built successfully, `dobuild` will push the containers to the specified registry.Environment Variables---------------------Options can also be specified in environment variables. Note that options on the command line override the environment.DOBUILD_FILE=./dobuild.yaml           # Path to dobuild.yamlDOBUILD_REGISTRY=registry.example.com # Docker registryDOBUILD_PREFIX=owner/helloworld       # Container URI prefixDOBUILD_PUSH=True                     # Push containers after building
Package: dostoevsky
DostoevskySentiment analysis library for russian languageInstallPlease note thatDostoevskysupports only Python 3.6+ on both Linux and Windows$pipinstalldostoevskySocial network model [FastText]This model was trained onRuSentiment datasetand achieves up to ~0.71 F1 score.UsageFirst of all, you'll need to download binary model:$python-mdostoevskydownloadfasttext-social-network-modelThen you can use sentiment analyzer:fromdostoevsky.tokenizationimportRegexTokenizerfromdostoevsky.modelsimportFastTextSocialNetworkModeltokenizer=RegexTokenizer()tokens=tokenizer.split('всё очень плохо')# [('всё', None), ('очень', None), ('плохо', None)]model=FastTextSocialNetworkModel(tokenizer=tokenizer)messages=['привет','я люблю тебя!!','малолетние дебилы']results=model.predict(messages,k=2)formessage,sentimentinzip(messages,results):# привет -> {'speech': 1.0000100135803223, 'skip': 0.0020607432816177607}# люблю тебя!! -> {'positive': 0.9886782765388489, 'skip': 0.005394937004894018}# малолетние дебилы -> {'negative': 0.9525841474533081, 'neutral': 0.13661839067935944}]print(message,'->',sentiment)If you use the library in a research project, please include the following citation for the RuSentiment data:@inproceedings{rogers-etal-2018-rusentiment,
    title = "{R}u{S}entiment: An Enriched Sentiment Analysis Dataset for Social Media in {R}ussian",
    author = "Rogers, Anna  and
      Romanov, Alexey  and
      Rumshisky, Anna  and
      Volkova, Svitlana  and
      Gronas, Mikhail  and
      Gribov, Alex",
    booktitle = "Proceedings of the 27th International Conference on Computational Linguistics",
    month = aug,
    year = "2018",
    address = "Santa Fe, New Mexico, USA",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/C18-1064",
    pages = "755--763",
}
Package: dot2bgraph
dot2bgraphdot2bgraphis a CLI utility to convert graphs indotformat tobgraphformat, for visualization with tools likebgrapher.dot2bgraphsupports a subset ofdotfeatures, tailored specifically to those that convert neatly tobgraphformat. Otherdotattributes that do not correlate to attributes supported bybgraph(e.g., shapes, label positions, etc.) are ignored.InstallationFirst, ensure that you havegraphvizinstalled, since it is a dependency forpygraphvizwhich, in turn, is a dependency fordot2bgraph.For example, in Ubuntu:apt-get install graphviz graphviz-devOr in OSX:brew install graphvizFor other platforms, see pygraphviz'sINSTALL.txtThen, installdot2bgraph:pip install dot2bgraphUsageBy default an input "file.dot" is converted tobgraphJSON format, which is outputted to stdout:dot2bgraph file.dotIf you instead wish to quickly look at the output as it would appear in abgraphvisualization tool, use-f png, i.e., "PNG format". For example:dot2bgraph -f png file.dotFor creating a bgraph recursively from multiple dot files in a directory structure, use-R, e.g. for the following directory structure:dotdir
├── file1.dot
└── subdotdir
    └── file2.dotYou can run:dot2bgraph -R dotdirTo save the tool's output (in whichever format) to a file, use-o.DevelopmentInstallmkdir .venv
pipenv shell
pipenv install --dev -e .
pipenv install -r requirements-dev.txtTestPytestpython -m pytest -s --cov-report term-missing --cov=dot2bgraphMypypython -m mypy -p dot2bgraph --config-file=mypy.iniProfilepython -mcProfile -o dot2bgraph.prof dot2bgraph/__main__.py -f none <your_dot_file>
Package: dot2dict
dot2dict - JSON dot notation to Python Dictionary 🐍 / Ruby Hash ♦️ Notation ConverterVersion : 0.4.1 AlphaThe Package is still under development and considered unstable for use.
Please feel free to use it and report bugs.Installation:dot2dict is available in Python Package Index.
Install with pip with your favourite python distribution.pip3installdot2dictInstall and get started right away.FeaturesConvert JSON dot notation path to Python Dictionary path.Convert JSON dot notation path to Ruby Hash path.Rich FormattingSensible Defaults.Beautiful Output.Free and open.ScreenshotsDevelopmentCurrently in Alpha.To-DoAlpha ReleaseAdd Documentation.Convert Python f-strings to String format to support older python versions.Fix ambiguous flags.Beta ReleaseAdding Support for Other languages other than Python and Ruby.