Saravanan666/pypi-org huggingface dataset:
Package: dotpup
## dotpup manages dotfiles across platformsThis is very minimalistic and intended for my own usage, but maybe otherswill find it useful. dotpup doesn't care about the synchronization of files,it's up to you. You may use git, rsync, dropbox, nextcloud etc.## Installation```$ pip install dotpup```## Usagedotpup has three commands. All of them require setting DOTPUP_HOME. Typically,you will want to have a dotfiles directory somewhere (I have `$HOME/dotfiles`).You can start with an empty directory.### dpup store```$ dpup store <some dotfile>```This moves the dotfile into `$DOTPUP_HOME`, symlinks it back to the originallocation and records the transaction for future automated replication (see`dpup update`)This is my current dotpup.json:```{"operations": {"Darwin": {".config/nvim/init.vim": "$HOME/.config/nvim/init.vim",".gitconfig": "$HOME/.gitconfig",".gitignore_global": "$HOME/.gitignore_global",".tmux.conf": "$HOME/.tmux.conf",".zsh_aliases": "$HOME/.zsh_aliases",".zshrc": "$HOME/.zshrc"},"Linux": {".config/nvim/init.vim": "$HOME/.config/nvim/init.vim",".gitconfig": "$HOME/.gitconfig",".gitignore_global": "$HOME/.gitignore_global",".hosts": "$HOME/.hosts",".ssh/config": "$HOME/.ssh/config",".tmux.conf": "$HOME/.tmux.conf",".zsh_aliases": "$HOME/.zsh_aliases",".zshrc": "$HOME/.zshrc"}}}```The reason for having per-platform entries is that the paths are not always thesame. For example, vscode (which I'm yet to add) uses different paths on Linuxand macOS.### dpup link```$ dpup link <some stored dotfile> <target location>```This creates a symlink to a stored dotfile and records the operation. This istypically useful when reusing dotfiles on a new platform.### dpup update```$ dpup update```This performs the operations for the current platform or (optionally) for adifferent platform. This is useful when you are setting up on a new machine.
Package: dot.py
dotpydotpyis a minimalist python script for managing dotfiles via symbolic links. Inspired bybashdot, it supports multiple profiles and customizable file templates with variables. No external dependencies, justpython 3.6+.Install and HelpYou can simply run directly from the repository:gitclonehttps://github.com/vincentqb/dotpy~/dotpy
~/dotpy/dotpy--helpor run as module from the repository:gitclonehttps://github.com/vincentqb/dotpy~/dotpyPYTHONPATH=~/dotpy/python-mdot--helpor build and install from source:pipinstallgit+https://github.com/vincentqb/dotpy
dotpy--helpor install with pip from pypi:pipinstalldot.py
dotpy--helpand just make sure to use the corresponding command below.Quick StartCreate your initial profile. For example, we create a directory calleddefault.mkdirdefaultAdd any files you would like linked into your home when this profile is linked.echo'set -o vi'>default/envLink the profile. When you link, dotpy prepends a dot, in front of the original file name, to the linked file. Below,default/envwill be linked to~/.env.~/dotpy/dotpylinkdefaultContinue adding your dotfiles to the default profile.mv~/.bashrcdefault/bashrcYou can safely re-run the link command to link newly added files. Store this profile in a cloud drive or source control. Repeat for additional profiles.TemplatesValues which need to be set in a file when dotpy is run can be placed in a template.Append.templateto any files which should be rendered. For example, assume you have a filedefault/env.templatecontaining:exportSECRET_KEY=$ENV_SECRET_KEYThe rendered files will be created in the same directory, and have.templatereplaced with.rendered. In the example, you can run the following to set the valueENV_SECRET_KEYwhen linking the default profile:envENV_SECRET_KEY=test1234~/dotpy/dotpylinkdefaultThe rendered file will be linked into the home with the.renderedsuffix removed and a dot prepended. In the example, this will result in the rendered filedefault/env.renderedbeing created and linked to~/.envwith the below contents.exportSECRET_KEY=test1234Be sure to include**/*.renderedin.gitignoreif you put your dotfiles into a git repository.DevelopmentFor linting, building and testing, see theworkflow.
Package: dotrc
dotrcSimple .rc file loading for your Python projects. Looks for config files
passed via --config as well as typical locations based on your app name:Files provided via --config option (see below).apprc~/.config/appFiles are loaded such that files earlier in the above list override settings
in later ones. The content of each file is parsed as YAML, falling back to
JSON if that fails.Usageimportdotrc# Loads .apprc, ~/.config/app, etc.config=dotrc.load('app')--configAdditional configuration files may be provided via the --config commandline
option. This parsessys.argvdirectly, so load your configs before doing
anything that might modify it. Files are loaded in order, so options in later files override options set in
earlier ones.$ python app.py --config .extrarc .lastrc
$ python app.py --config=.extrarc
$ python app.py --config=.1rc --config=.2rcA list of files will be populated from the commandline arguments until a
switch or option is detected. You need to be mindful if you for some reason
have config files starting with dashes, so you don't signal the end of your
file list.$ python app.py --config .1rc --config=--.weirdrc
$ python app.py --config=--.1rc --config=--.2rc
$ python app.py --config ./-.1rc ./-.2rc
Package: dotrun
A tool for developing Node.js and Python projectsdotrunmakes use of aDocker imageto provide a predictable sandbox for running Node and Python projects.Features:Make use of standardpackage.jsonscript entrypoints:dotrunrunsyarn run startwithin the Docker containerdotrun foorunsyarn run foowithin the Docker containerDetect changes inpackage.jsonand only runyarn installwhen neededDetect changes inrequirements.txtand only runpip3 installwhen neededRun scripts using environment variables from.envand.env.localfilesKeep python dependencies in.venvin the project folder for easy accessUsage$dotrun# Install dependencies and run the `start` script from package.json$dotrunserve# Run the python app only$dotrunclean# Delete `node_modules`, `.venv`, `.dotrun.json`, and run `yarn run clean`$dotruninstall# Force install node and python dependencies$dotrunexec# Start a shell inside the dotrun environment$dotrunexec{command}# Run {command} inside the dotrun environment$dotrun{script-name}# Install dependencies and run `yarn run {script-name}`$dotrun-s{script}# Run {script} but skip installing dependencies$dotrun--envFOO=bar{script}# Run {script} with FOO environment variable$dotrun-m"/path/to/mount":"localname"# Mount additional directory and run `dotrun`$dotrunserve-m"/path/to/mount":"localname"# Mount additional directory and run `dotrun serve`InstallationDockerFirst, install Docker (Get Docker).Linux users may also need to follow thepost install instructionsto be able to run Docker as a non-root user.LinuxTo install dotrun run:sudo apt install python3-pip
sudo pip3 install dotrunMacTo install dotrun on a mac you will needHomebrew(follow
the install
instructions on that page).Then run:brew install python3
sudo pip3 install dotrunRequirementsLinux / macOSDocker (Get Docker)Python > 3.6 and PIPmacOS performanceFor optimal performance on Docker we recommend enabling a new experimental file sharing implementation called virtiofs. Virtiofs is only available to users of the following macOS versions:macOS 12.2 and above (for Apple Silicon)macOS 12.3 and above (for Intel)How to enable virtiofsAdd dotrun on new projectsTo fully support dotrun in a new project you should do the following:For Python projects, ensureTaliskeris at0.16.0or greater inrequirements.txtAdd.dotrun.jsonand.venvto.gitignoreCreate astartscript inpackage.jsonto do everything needed to set up local development. E.g.:"start": "concurrently --raw 'yarn run watch' 'yarn run serve'"The above command makes use ofconcurrently- you might want to consider thisOlder versions of Gunicornare incompatible withstrict confinement so we need Gunicorn >= 20The updatelanded in Taliskerbut at the time of writing hasn't made it into a new versionIf there's no new version of Talisker, simply addgunicorn==20.0.4to the bottom ofrequirements.txtHowever, once you're ready to completely switch over todotrun, simply go ahead and remove therunscript.Automated tests of pull requestsThe "PR" actionbuilds the Python package and runs a project with dotrun. This will run against every pull request.PublishAll the changes made to the main branch will be automatically published as a new version on PyPI.
Package: dotrunner
All rights reserved.Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Description: UNKNOWN
Platform: UNKNOWN
Package: dotscli
dotsCLIA command-line tool to automate deployment and containerization of your applications.Supported enviroments: NodeInstallationInstall the package globallypip install dotsCLIRun the entry command to show the full range of functions:dtsMake a config file in a new folder named '.dts' in the root directory of your system, configuring the values respectively.Note:FRONTEND_DIR_PATHandFRONTEND_DIST_PATHmust not contain a trailing slash.[aws]AWS_USER=ubuntu[main]FRONTEND_DIR_PATH=<path_to_dir>FRONTEND_DIST_PATH=<path_to_dir>SSH_KEY_PATH=<path_to_dir>/ssh-key.pemFunctionsEasily deploy your frontend SPAs to remote linux serversHassle-free deploymentAutomatic configuration of nginx request routingDockerize your NodeJS applicationAllows you to define the base image versionEasily define all dockerfile configurationsAutomatically setup a new docker network with custom nameCustomize docker-compose configurationsAttaches the newly created docker network to the containerFuture ScopeAdd support for more environments (like python, java etc)More flexibility towards docker network configurationsAllow users to define the type of network created
Package: dots-code-generator
dots-code-generatorUsageAdd path with config_txt.py and path to "dots" python module to PYTHONPATH.Call dcg.py:
cd examples
mkdir -p out
../bin/dcg.py -T templates -C config_txt -o out some_types.dots -vGenerated files will be places in directory "out".Update DOTS grammarDOTS grammer is defined in "dots.lark". If the grammar is updated, a new
parser has to be generated with the "lark" python module:python -m lark.tools.standalone dots.lark > dots/dots_parser.py
Package: dots-editor
A six-key brailler emulator written in python.Tired of being on a mac and having no viable options for a six-key brailler emulator?
Tired of not being able to fix bugs or request features with existing emulators?Me too!I was sick of there not being an emulator that is free, easy to use, and easy to install on any operating system.This is in Pre-Alpha. Expect bugs, and missing features.Installationpip installdots-editorUsagedots_editor filename.brlThis will open a file for editing. When you quit (I know, scary), it will save.dots_editor--unicodefilename.txtThis will save a file using the unicode braille glyphs. (U+2800 to U+2840)Pre-Alpha features to addEdit an existing file (I know, big oversight)Start standaloneMenu to make a new file or open an existing oneSave without exitBinaries for common operating systemsCursorAlpha features to addresizable windowchange font sizechange marginfigure out brf formatLogoDocumentation (and documentation tests)automatic line breaks8-dot modeBeta features to addIntegration with liblouiscontraction helphighlighting text to edit or movefind/replacesave in all common filetypesprint (to printer or embosser)spellcheck?Want to contribute?Wow, cool. I don’t currently have any guidelines, but contact me using github,
and we’ll talk. It’s much more likely to be a successful talk if you have a pull
request and a good summary of what you’re trying to accomplish.
Package: dotshow
dotshowWe generate image to text on terminal
It is made for terminal (CLI) to show image.
When we want to see image on python  linux server, 
we have to save image or use jupyter notebook.
To overcome those problem, I made this package.

To see thumnail of the image, we can use cv2.imshow in local environment.
However, it is impossible for server ssh terminal.
It is simple thumnail printer using python.ExampleWe can print images like down below.원본 이미지dotshowcolorshowHow to useGit cloning on your repositorypip install dotshowimport package on pythonDraw image on terminal by putting pathfromdotshowimportloadshowloadshow(<img-path>)# run the code (drawing a color image, default=color)loadshow(<img-path>,color=False)# run the code (drawing a gray image)Draw image on terminal by OpenCV2 arrayimportcv2fromdotshowimportdotshow,colorshowimg=cv2.imread(<img-path>)dotshow(img)# run the code (drawing a gray image)colorshow(img)# run the code (drawing a color image)Draw image on terminal by PIL ImageimportnumpyasnpfromPILimportImagefromdotshowimportdotshow,colorshowimg=np.array(Image.open(<img-path>))dotshow(img)# run the code (drawing a gray image)colorshow(img)# run the code (drawing a color image)Parametersloadshow(
    gray = True[default / bool]
    size = 7 [default / 0 ~ 10]
)
dotshow(
    gray = True[default]
    size = 7 [default / 0 ~ 10]
)
colorshow(
    size = 7 [default / 0 ~ 10]
)

gray - if your image is not interpretable, give gray parater False
size - if your image is too big in your terminal, reduce size using this parameterIf you use low size parameter, image will undersampled too much and it will decrease image quality.If you use big size parameter, the terminal cannot describe image because the terminal is too small.
Package: dots-linux
Dots…(Connect the dots!)Coming SoonManage dot-config files. (backup, restore, publish)Compose as many desktop environments as you need (work, games,
projects, etc.)Install a list of applications via the package manager of your
choice.Install AUR-applications.Install system fonts, services, and other dependencies.Getting StartedRequirementsPython 3.5+xdotoolwmctrlInstallationInstall Dots with pip:$ pip install dots-linuxor directly from the source code:$ git clone https://github.com/hoytnix/dots.git
$ cd dots
$ python setup.py installBasic UsageAfter installation, the package can be initiated from your terminal.$ dotsDocumentationDocumentation isn’t currently available in HTML-format online, however you can
compile it:$ git clone https://github.com/hoytnix/dots.git
$ cd dots
$ make doc
$ cd docs/_build/html
$ xdg-open index.htmlChangesThis is the changelog for Dots…!This documents attempts to conform toKeep a CHANGELOG.[0.0.1] (2016-07-22)AddedAbility to dump the characteristics (position, desktop, title, etc.) of the
windows open in your desktop-environment.Ability to modify the dimensions and positions of windows on your desktop.Includes a simple demo.
Package: dotsplit
dotsplitTransform dot-delimited strings to array of python strings.>>>importdotsplit>>>dotsplit('group.0.section.a.seat.3')['group','0','section','a','seat','3']Installationdotsplit is available on PyPI:poetry❯ poetry install dotsplitpip❯ python -m pip install dotsplitTestingto run the unit test suite, cd to the root directory and run:❯ poetry install
❯ poetry run pytestLicenses
Package: dots-python
Dots SDK for PythonThe Dots Python library provides convenient access to the Dots API from applications written in the Python language.More InfoDocumentationSee theAPI docs.InstallationTo install the package run:pip install --upgrade dots-pythonInstall from source with:python setup.py installUsageThe library needs to be configured with yourclient_idandapi_keywhich can be found in theDeveloper Dashboardimport dots
dots.client_id = 'pk_dev_...'
dots.api_key = 'sk_dev_...'

invoice = dots.Invoice.create(...)
Package: dotstree
Dotfiles manager based on directory treesDotstree is a dotfiles manager. "Another one??" I know, right. Here's the highlights:The dotfiles are replaced with symlinksEvery program's deployment spec is stored in its own folderInstall commands can be part of the deploymentYou can cherrypick which programs to deploy based on which directory trees you pass to dotstree (hence the name)This can be used to handle alternate platforms and dependenciesYou can check and sync programs against their specWritten in Python, released to PypiUsageYou can install it withpip install dotstree. To see basic usage info, trydots --help. I can provide atldrpage if there's interest - just open an issue. Your dotfiles specs are expected to be in some kind of directory tree that you pass to dotstree. Normally this would be a git repo - but dotstree doesn't care.TestsRunpytest .in the repo root.Further readingDetailsProgram-specific tipsWhy not GNU Stow?
Package: dotstrings
dotstringsThis is a Python toolkit for interacting with the localization files for iOS and macOS.ExamplesRead in a .strings file and print the entries:importdotstringsentries=dotstrings.load("/path/to/file.strings")forentryinentries:print("Key: "+entry.key)print("Value: "+entry.value)print("Comments: "+"\n".join(entry.comments))ContributingThis project welcomes contributions and suggestions.  Most contributions require you to agree to a
Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
the rights to use your contribution. For details, visithttps://cla.opensource.microsoft.com.When you submit a pull request, a CLA bot will automatically determine whether you need to provide
a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions
provided by the bot. You will only need to do this once across all repos using our CLA.This project has adopted theMicrosoft Open Source Code of Conduct.
For more information see theCode of Conduct FAQor
contactopencode@microsoft.comwith any additional questions or comments.
Package: dot-sync
Dot SyncA tool for syncing dotfiles between linux machinesFree software: MIT licenseDocumentation:https://dot-sync.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2017-08-05)First release on PyPI.
Package: dott
dott is a simple scheduling package written in Python 3.7.InstallWith pip;>pipinstalldottWith git;>pipinstallgit+https://github.com/alexmacniven/dott.git#egg=dottUsageUse dott in your code to schedule invoking a function at a given time(s) or
periodically.dott has just two functions;hourlyanddaily.Here's some examples:importdottdefsay_hello():"""Displays 'hello world'."""print("hello world")# Invoke `say_hello` every 2 hours.dott.hourly(say_hello,2)# Invoke 'say_hello` daily at 14:00 and 21:00.dott.daily(say_hello,["14:00","21:00"])
Package: dotted
dottedA Python library that provides a method of accessing lists and dicts with a
dotted path notation. It is useful to access a deep path inside a complex
object composed of lists and dicts.Quick & Dirty:fromdotted.collectionimportDottedCollection,DottedDict,DottedListobj=DottedCollection.factory(dict_or_list)obj=DottedCollection.load_json(json_value)obj=DottedDict(a_dict)obj=DottedList(a_list)fromdotted.utilsimportdot,dot_jsonobj=dot(dict_or_list)obj=dot_json(json_value)DottedDictandDottedListhave the same accessors asdictandlistso you can iterate them as usual. Both type of objects support access via a
dotted path key.ExamplesExample #1: DottedListobj=DottedList([0,1,2,3,[4,5,6],7,8,[9,10]])All of these are true:obj[0]==0obj['1']==1obj['4.0']==4obj['4.2']==6obj[5]==7obj['7.1']==10If you want to append you can do:obj.append(12)or:obj[8]=11but the latter only works ifindex == len(obj). In other case you will get a
very pretty exception.Example #2: DottedDictobj=DottedDict({'hello':{'world':{'wide':'web'}}})All of these are true:obj['hello']=={'world':{'wide':'web'}}obj['hello.world']=={'wide':'web'}obj['hello.world.wide']=='web'obj.hello=={'world':{'wide':'web'}}obj.hello.world=={'wide':'web'}obj.hello.world.wide=='web'Example #3: Both working togetherobj=DottedCollection.factory({'hello':[{'world':{'wide':['web','web','web']}}]})You can access:obj['hello'][0]['world']['wide'][0]obj.hello[0].world.wide[0]obj.hello[0].world['wide'][0]obj.hello[0].world['wide.0']obj.hello['0.world'].wide[0]...obj['hello.0.world.wide.0']Example #4: When new values are dicts or listsobj=DottedCollection.factory(some_obj)obj['some.path']={'hello':'world'}# will be converted to a DottedDictobj['another.path']=['hello']# will be converted to a DottedListExample #5: Shortcutsfromdotted.utilsimportdot,dot_jsonobj=dot({'hello':'world'})obj=dot_json('{"hello": "world"}')Example #6: Keys with dots inside!Well, you can actually use escaped keys, but it’s better to avoid them:fromdotted.utilsimportdot,dot_jsonobj=dot({"hello\.world":"Hello!"})obj=dot_json('{"hello\\\\.world": "Hello!"}')value=obj["hello\.world"]# Hello!That’s all!TestsRun in the terminal from the parent directory:python -m dotted.test.test_collectionSpecial ThanksMarc Abramowitz(@msabramo)Ryan Witt(@ryanwitt)
Package: dotted-dict
A light weight extension of the default python dict object. This allows for the use of key names as
object attributes.Simple usageIn [1]: from dotted_dict import DottedDict

In [2]: example = DottedDict()

In [3]: example['foo'] = 1

In [4]: example.foo
Out[4]: 1

In [5]: example.bar = 2

In [6]: example
Out[6]: DottedDict({'bar': 2, 'foo': 1})

In [7]: del example['foo']

In [8]: del example.bar

In [9]: example
Out[9]: DottedDict({})Also allows passing in of values in same manner as normal dict objects.In [10]: example = DottedDict({'foo': 1, 'bar': 2})

In [11]: example
Out[11]: DottedDict({'bar': 2, 'foo': 1})Issues with invalid characters. A valid key name in the scope of this library must conform to the
following regex[a-zA-Z_][a-zA-Z0-9_]*$. In the case where your key name does not conform,
the library will mutate your key to a safe format. Spaces and invalid characters are replaced with
_. In the case of the key beginning with an int, a leading _ is added.In [12]: DottedDict({'My fun key': 1, 'John\'s': 1, 'Mr. Man': 1})
Out[12]: DottedDict({'John_s': 1, 'Mr__Man': 1, 'My_fun_key': 1})

In [13]: DottedDict({1: 2})
Out[13]: DottedDict({'_1': 2})
Package: dotted-ml
🈷️ Dotted Markup LanguageTranslate text to and from DML with ease.📥 InstallationExecutepip install dotted-ml.Addimport dmlto the top of your project.♿ Usage🚮 Encodingimportdmlmycode="""myvar = "Hello, world!"print(myvar)"""dml.encode(mycode,out="mycode.dml")mycode.dml:܁٠܁٠۰܁܁٠܁܁٠܁۰܁܁܁܁٠٠܁۰܁܁܁٠܁܁٠۰܁܁٠٠٠٠܁۰܁܁܁٠٠܁٠۰܁٠٠٠٠٠۰܁܁܁܁٠܁۰܁٠٠٠٠٠۰܁٠٠٠܁٠۰܁٠٠܁٠٠٠۰܁܁٠٠܁٠܁۰܁܁٠܁܁٠٠۰܁܁٠܁܁٠٠۰܁܁٠܁܁܁܁۰܁٠܁܁٠٠۰܁٠٠٠٠٠۰܁܁܁٠܁܁܁۰܁܁٠܁܁܁܁۰܁܁܁٠٠܁٠۰܁܁٠܁܁٠٠۰܁܁٠٠܁٠٠۰܁٠٠٠٠܁۰܁٠٠٠܁٠۰܁٠܁٠۰܁܁܁٠٠٠٠۰܁܁܁٠٠܁٠۰܁܁٠܁٠٠܁۰܁܁٠܁܁܁٠۰܁܁܁٠܁٠٠۰܁٠܁٠٠٠۰܁܁٠܁܁٠܁۰܁܁܁܁٠٠܁۰܁܁܁٠܁܁٠۰܁܁٠٠٠٠܁۰܁܁܁٠٠܁٠۰܁٠܁٠٠܁۰܁٠܁٠۰♻️ Decodingimportdmldml.decode_file("mycode.dml",out="mycode.py")mycode.py:myvar="Hello, world!"print(myvar)