Saravanan666/pypi-org huggingface dataset:
Package: dotini
dotini======Summary-------This package is a simple layer on top of the built-in configparser module.The advantage of dotini is the option of using dot notation to accesssettings in a configuration file, provided the settings and section names arevalid variable names. This is aesthetically pleasing.Usage-----With the dotini module imported, use the read() function to parse a config-uration file. This is done using configparser, for more details regardingfile format and rules, see the official documentation for configparser.Once the configuration file has been read, it’s settings can be accessed withdot notation for settings with valid variable names. Settings without validvariable names can still be accessed with square brackets.import dotinisettings = dotini.read(‘settings.ini’)_login(user=settings.user.name,pass=settings.user[‘pass’])Notes-----As mentioned previously, to be able to use the dot notation access, settingsshould be made with variable safe names.Setting values are read in as strings, and there is no automatic type conversionwhen they are stored or accessed. Type conversion is up to you!Example Configuration File—-------------------------[user]name = ‘thomas’pass = ‘samoht’[performance]speed = 10cores = 4
Package: dotjs
dotjs is a Google Chrome extension that executes JavaScript files in~/.jsbased on their filename.If you navigate tohttp://www.google.com/, dotjs will execute~/.js/google.com.js.This makes it super easy to spruce up your favorite pages using
JavaScript.On subdomains such ashttp://gist.github.comdotjs will try to load~/.js/gist.github.com.jsas well as~/.js/github.com.jsand~/.js/com.js.Bonus: files in~/.jshave jQuery 1.9 loaded, regardless of whether
the site you’re hacking uses jQuery.Double bonus:~/.js/default.jsis loaded on every request, meaning
you can stick plugins or helper functions in it.GreaseMonkey user scripts are great, but you need to publish them
somewhere and re-publish after making modifications. With dotjs, just
add or edit files in~/.js.Example$ cat ~/.js/github.com.js
// swap github logo with trollface
$('a[class^=header-logo-]').html(
$('<img>')
    .attr('src', '//bit.ly/ghD24e')
    .css({'width': 'auto', 'height': '22px'})
);How It WorksChrome extensions can’t access the local filesystem, so dotjs runs a
tiny web server on port 3131 that serves files out of ~/.js.The dotjs Chrome extension then makes ajax requests tohttp://localhost:3131/convore.com.jsany time you hit a page on
convore.com, for example, and executes the returned JavaScript.RequiresPython >= 2.6Google ChromeInstall itgit clone http://github.com/hackedd/python-dotjs
cd python-dotjs
python setup.py installOS X:Openhttps://localhost:3131in Google ChromeClick the “X” Padlock icon in the address barClick “Certificate Information”Drag the large cert icon to your desktopOpen it with KeychainConfigure itsTrustsection as shown:http://cl.ly/PdnyWindows:Export the certificate as a “.cer” file:dotjs --print-cert > %TEMP%\dotjs.cerRight-click the exported “.cer” file, click “Install Certificate”Complete the Wizard to import the certificate to the Windows
Certificate store. Make sure to selectTrusted Root Certification Authoritiesas the destination store when asked.Ubuntu:Usecertutilto import the certificate to your NSS database:dotjs --print-cert | certutil -d sql:$HOME/.pki/nssdb -A \
    -t "P,," -n localhost-dotjsYou might need to restart Chrome before it sees the certificate as trusted.
You can verify if the certificate is correctly installed by openinghttps://localhost:3131in Chrome.Finally install the Google Chrome extension:http://bit.ly/dotjsCreditsOriginal version:https://github.com/defunkt/dotjsIcon:http://raphaeljs.com/icons/jQuery:http://jquery.com/Ryan Tomayko for:“I almost wish you could just stick JavaScript in ~/.js. Do you know
what I’m saying?”Other BrowsersFirefox Add-onSafari ExtensionFluid UserScript
Package: dotjson
python-dotjsonInstallationSample usage:pip install dotjsonIntroductionIf you want your application to derive configuration using a json file, To help you with that, you can add python-dotjson to your application to make it load the configuration from a settings.json file when it is present (e.g. in development) while remaining configurable via the environment variables.Sample usage:fromdotjsonimportload_dotjson()load_dotjson()FeaturesSets config vars to env varsSupport for multiple settings.json filesLets you deserialize settings.json file to a Pydantic Model or DictionaryAuto picks the settings.json file from root directoryAbility to load settings from streamload_dotjsonThis method lets you flatten and load the settings.json file to env vars.Load Env Vars from default settings.jsonload_dotjson()Load Env Vars using json path overrideload_dotjson(json_path="settings/settings.dev.json")Load Env Vars using streamsettings_content='{"apple":1,"mango":5,"fruit":{"units":["kg","pound"]}}'load_dotjson(stream=StringIO(settings_content))Load Env Vars using multiple json pathssettings_paths=["settings.json","settings.dev.json"]load_dotjson(json_paths_list=settings_paths)dict_dotjsonThis method lets you load a dictionary using the settings.json file.Load dictionary from default settings.jsondict_output=dict_dotjson()Load dictionary using json path overridedict_output=dict_dotjson(json_path="settings/settings.dev.json")Load dictionary using streamsettings_content='{"apple":1,"mango":5,"fruit":{"units":["kg","pound"]}}'dict_output=dict_dotjson(stream=StringIO(settings_content))Load dictionary using multiple json pathssettings_paths=["settings.json","settings.dev.json"]dict_output=dict_dotjson(json_paths_list=settings_paths)model_dotjsonThis method lets you load a pydantic model using the settings.json file.Load dictionary from default settings.jsonclassfruit_model(BaseModel):units:List[str]classsettings_model(BaseModel):apple:intmango:intfruit:fruit_modelmodel_output=model_dotjson(settings_model)Load dictionary using json path overrideclassfruit_model(BaseModel):units:List[str]classsettings_model(BaseModel):apple:intmango:intfruit:fruit_modelmodel_output=model_dotjson(settings_model,json_path="settings/settings.dev.json")Load dictionary using streamclassfruit_model(BaseModel):units:List[str]classsettings_model(BaseModel):apple:intmango:intfruit:fruit_modelsettings_content='{"apple":1,"mango":5,"fruit":{"units":["kg","pound"]}}'model_output=model_dotjson(settings_model,stream=StringIO(settings_content))Load dictionary using multiple json pathsclassfruit_model(BaseModel):units:List[str]classsettings_model(BaseModel):apple:intmango:intfruit:fruit_modelsettings_paths=["settings.json","settings.dev.json"]model_output=model_dotjson(settings_model,json_paths_list=settings_paths)Inspired bypython-dotjson:https://github.com/theskumar/python-dotenvReferencespoetry:https://github.com/python-poetry/poetrygitversion:https://github.com/GitTools/GitVersionPydantic:https://github.com/samuelcolvin/pydantic
Package: dot-js-py
doT.pyA python implementation of the famous js template engine. doT.js.http://olado.github.io/doT/index.html.
It do excetly the same thing as doT.js except written in python. Thus, it can be used in python web framework.doT.py compile the template to a pure javascript function in server side; therefore client side can evaluate the template later without any dependency. Which means it saves the time for client to load template engine and to load template file. In short, doT.py allows using client side template tech without include a template engine in client side.Installationpip install doT-js-pyHere is an example:Use client side template<html><!-- load template engine --><scripttype="text/javascript"src="doT.js"></script><divid="container"><scripttype="text/javascript">// Compile template functionvartempFn=doT.template("<h1>Here is a sample template {{=it.foo}}</h1>");varresultText=tempFn({foo:'with doT'});document.getElementById('container').innerHtml=resultText;</script></html>Use doT.py, you write:<html><!-- without loading template engine --><divid="container"><scripttype="text/javascript">// Compile template functionvartempFn={{js_template('<h1>Here is a sample template {{=it.foo}}</h1>')}};varresultText=tempFn({foo:'with doT'});document.getElementById('container').innerHtml=resultText;</script></html>it will automatically compiled to<html><!-- without loading template engine --><divid="container"><scripttype="text/javascript">// Compile template functionvartempFn=functionanonymous(it){varout='"<h1>Here is a sample template '+(it.foo)+'</h1>"';returnout;};varresultText=tempFn({foo:'with doT'});document.getElementById('container').innerHtml=resultText;</script></html>Django Support:Jinja2 Support:Commandline Support:
Package: dot-kernel
Dot KernelThe dot kernel for jupyter!There is an awesome dot language tutorial in Chinese:learn-dot.InstallYou should have graphviz first.Install by brew:brew install graphviz.orsudo apt-get inatall graphvizfor ubuntuThen,pip install dot_kernelAdd kernel to your jupyter:install-dot-kernelALL DONE! 🎉🎉🎉Run using:jupyter notebookSelect new -> dotand try run this:// The graph name and the semicolons are optional
 graph graphname {
     a -- b -- c;
     b -- d;
 }You will see:TODOupdatethis.add more render tools not justdotadd more filetype support not justpngauto indent
Package: dotlab-lib
Welcome to DotLAB Library 👋DotLAB Library is a machine learning library that aims to offer methods that facilitate the data manipulation.Installpipinstalldotlab-libRun testspython3setup.pypytestAuthor👤DotLAB BrazilInstagram:@dotlabbrazilGithub:@dotlab-brazilShow your supportGive a ⭐️ if this project helped you!📝 LicenseCopyright © 2022DotLAB Brazil.This project isMITlicensed.This README was generated with ❤️ byreadme-md-generator
Package: dotlang
DOTLANGWorld's fastest diagram creator.How to useExecuteREPLmakeoutputfolder in current directory to hold the output image filesrunpython -mdotlanginput thedotlang codeto the REPLFrom other codesimport the libraryfrom dotlang import dotlanginput thedotlang codedotlang(dotlang_code, output_dir=dir_name_output, output_file=file_name_output)Quick examplesTo create directional graph from a to b to c.a.b.cChange the shape from oval to box for all nodes:[shape=box]a.b.cChange the shape from oval to box for nodebonly:a.b[shape=box].cRequirementspip install yulibrary
Package: dotlas
Dotlas Python ClientThe Dotlas REST API enables you to:Integrate data & insights with your own web or mobile apps 📲Consume information that supplements in-house data analysis and visualization 📊Enhance the functionality of your tech stack 🖥Leverage alternative data in your data pipeline 🏗Website•API Documentation•Email•LinkedInSetupPipTo install Dotlas fromPyPirun the following command:$pipinstalldotlasLocalTo setup dotlas from GitHub:UsageBasic Callsimportdotlasdot=dotlas.App(api_key="<YOUR API KEY>")cities=dot.list_cities()houston_city_stats=dot.city_stats(city="Houston")restaurants_near_empire_state_bldg=dot.nearby_competition(latitude=40.74861114520377,longitude=-73.98560002111566,city="New York",commercial_type="Restaurant",)esb_insights=restaurants_near_empire_state_bldg.response.insightsesb_data=restaurants_near_empire_state_bldg.response.dataMappingpip install foliumif you don't have it already.MAPBOX_ACCESS_TOKENcan be obtained frommapbox.comimportfoliumMAPBOX_MAP:str="https://api.mapbox.com/styles/v1/mapbox/light-v10/tiles/{z}/{x}/{y}?access_token={MAPBOX_ACCESS_TOKEN}"empire_state_building_profile=dot.sales_territory(latitude=40.74861114520377,longitude=-73.98560002111566,city="New York",time_minutes=10,mode_of_mobility="driving")folMap:folium.Map=folium.Map(location=[empire_state_building_stats.request.latitude,empire_state_building_stats.request.longitude,],tiles=MAPBOX_MAP,attr='mapbox',zoom_start=12)folium.GeoJson(empire_state_building_stats.response.geometry.dict()).add_to(folMap)
Package: dotli
DotliYet another library for flattening structuresInstallationpipinstalldotliUsageflattenfromdotliimportDotlidata={'a':{'c':'val1','d':'val2',},'b':{'c':2,'d':{'key3':'val3','key4':'val4'},}}d=Dotli()# create an obj with a default configurationflat=d.flatten(data)# flattenorig=d.unflatten(flat)# unflattenassertdata==origprint(flat){'a.c':'val1','a.d':'val2','b.c':2,'b.d.key3':'val3','b.d.key4':'val4',}The separator can be configureddata={'a':{'c':'d'},'b':{'e':'f'}}d=Dotli(separator='-')print(d.flatten(data)){'a-c':'d','b-e':'f',}It is also possible to flatten lists and a mixture of lists and dictsdata={'a':{'c':[1,2,3],'d':['e1','e2','e3'],},'b':'h'}d=Dotli()print(d.flatten(data)){'a.c.0':1,'a.c.1':2,'a.c.2':3,'a.d.0':'e1','a.d.1':'e2','a.d.2':'e3','b':'h',}List indices can be wrapped in square brackets to allow numerical strings in dicts as keysdata={'a':{'1':[1,2,3],'2':['e1','e2','e3'],},'b':'h'}d=Dotli(list_brackets=True)flat=d.flatten(data)orig=d.unflatten(flat)assertdata==origprint(flat){'a.1.[0]':1,'a.1.[1]':2,'a.1.[2]':3,'a.2.[0]':'e1','a.2.[1]':'e2','a.2.[2]':'e3','b':'h',}There will be a nice error message if the dict can not be flattened including the path to the invalid element.fromdotli.errorsimportSeparatorInKeyErrordata={'a':{'b.b':1,},'b':'h'}try:Dotli().flatten(data)exceptSeparatorInKeyErrorase:print(e)Separator "." is in key "b.b"! @ root.aunflattenWhen elements are missing in a list Dotli will throw an errorfromdotli.errorsimportIncompleteListErrordata={'a.0':0,'a.2':2,}try:d=Dotli()d.unflatten(data)exceptIncompleteListErrorase:print(e)No entry for index "1" in list! @ aHowever it is possible to specify a fill value
which will automatically be inserted into the list for missing entriesdata={'a.0':0,'a.2':2,}d=Dotli(fill_value_list=None)print(d.unflatten(data)){'a':[0,None,2],}
Package: dotlink
dotlinkAutomate deployment of dotfiles to local paths or remote hostsinstall$ pipx install dotlinkusageList your dotfiles in a simple text format named either.dotlinkordotlink:# comments are lines starting with hash

# simple file listing
.vimrc
.zshrc

# map files to different names/paths (destination = source)
.config/htop/htoprc = htoprc

# include configs from submodules or other directories
@submodule/See example repo/config athttps://github.com/amyreese/dotfilesTell dotlink where your dotfile repo is, and where it should put things.
Defaults to the current directory and your home directory, respectively:$ dotlink [<source>] [<destination>]Use--planto see what dotlink will do before doing it:$ dotlink --plan [...]The source can be a cloneable git repo:$ dotlink https://github.com/amyreese/dotfiles.gitThe destination can be a remote, ssh-able location:$ dotlink <source> [<user>@]host:/path/to/destinationlegaldotlink is copyrightAmethyst Reese.dotlink is licensed under the MIT license.
See theLICENSEfile for more details.
Package: dotlinker
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: # dotlinkertbdPlatform: UNKNOWN
Package: dotloop-python
dotloop-pythonPython wrapper around the dotloop API.Quick StartAuthenticateStart by getting access and refresh tokens.fromdotloopimportAuthenticateauth=Authenticate('dotloop-client-id','dotloop-client-secret')url=auth.url_for_authentication('https://example.com/redirect/')...# code is receivedwithauth:response=auth.acquire_access_and_refresh_tokens(code,'https://example.com/redirect/')# response is a dictionary:# {#   "access_token": "...",#   "token_type": "Bearer",#   "refresh_token": "...",#   "expires_in": ...,#   "scope": "..."# }ClientThen use the access token acquired to create aClientobject.access_token=response['access_token']client=Client(access_token)From theClientobject, you can now access dotloop data.For example, get data about all profilesclient.profile.get()# -> Dictor get data about a specific profileclient.profile(<profile_id>).get()or get all loops associated with a profileclient.profile(<profile_id>).loop.get()or get all folders in a specific loopclient.profile(<profile_id>).loop(<loop_id>).folder.get()or update a participant on a specific loopclient.profile(<profile_id>).loop(<loop_id>).participant(<participant_id>).patch(email='newemail@example.com')Design PhilosophyAll items accessible in the dotloop API follow a hierarchical structure (i.e. profiles have loops which have folders which have documents) as represented like this:AccountContactLoopItProfileLoopTemplateLoopActivityParticipantDetailTaskListTaskFolderDocumentThe design of this wrapper was intended to emulate that while providing idiomatic ways of quickly accessing data. Endpoints and their HTTP methods are easily translated to python code.AccessingPATCH /profile/1/loop/1/folder/1with data{
  "name": "Disclosures (renamed)"
}translates seamlessly toclient.profile(1).loop(1).folder(1).patch(name='Disclosures (renamed)')Note: if data keys ever have spaces then those keys can be included by unpacking a dictionary
e.g.client.profile(1).loop(1).detail.patch(**{'Property Information':{...}})Inspiration was taken fromdotloop-rubyandsendgrid-python.Linksdotloop API documentationTo-DoAccount.getActivity.getContact.delete.get.patch.postDetail.get.patchDocument.get.postFolder.get.patch.postLoop.get.patch.postLoopIt.postLoopTemplate.getParticipant.delete.get.patch.postProfile.get.patch.postTask.getTaskList.getBetter typingBetter passing of parametersAsyncBetter handling of request sessionsBetter exception handlingBetter documentationUnit testsimportasyncioimportaiohttpimportdotloopasyncdefmain():asyncwithaiohttp.ClientSession()ass:asyncwiths.post()if__name__=='__main__':main()DisclaimerI do not work for dotloop nor for Zillow.
Package: dotmap
DotMapInstallpip3 install dotmapUpgradeGet updates for current installationpip3 install --upgrade dotmapFeaturesDotMapis a dot-accessdictsubclass thathas dynamic hierarchy creation (autovivification)can be initialized with keyseasily initializes fromdicteasily converts todictis ordered by insertionThe key feature is exactly what you want: dot-accessfromdotmapimportDotMapm=DotMap()m.name='Joe'print('Hello '+m.name)# Hello JoeHowever,DotMapis adictand you can treat it like adictas neededprint(m['name'])# Joem.name+=' Smith'm['name']+=' Jr'print(m.name)# Joe Smith JrIt also has fast, automatic hierarchy (which can be deactivated by initializing withDotMap(_dynamic=False))m=DotMap()m.people.steve.age=31And key initializationm=DotMap(a=1,b=2)You can initialize it fromdictand convert it todictd={'a':1,'b':2}m=DotMap(d)print(m)# DotMap(a=1, b=2)print(m.toDict())# {'a': 1, 'b': 2}And it has iteration that is ordered by insertionm=DotMap()m.people.john.age=32m.people.john.job='programmer'm.people.mary.age=24m.people.mary.job='designer'm.people.dave.age=55m.people.dave.job='manager'fork,vinm.people.items():print(k,v)print# john DotMap(age=32, job='programmer')# mary DotMap(age=24, job='designer')# dave DotMap(age=55, job='manager')It also has automatic counter initializationm=DotMap()foriinrange(7):m.counter+=1print(m.counter)# 7And automatic addition initializations of any other typem=DotMap()m.quote+='lions'm.quote+=' and tigers'm.quote+=' and bears'm.quote+=', oh my'print(m.quote)# lions and tigers and bears, oh myThere is also built-inpprintasdictorjsonfor debugging a largeDotMapm.pprint()# {'people': {'dave': {'age': 55, 'job': 'manager'},#             'john': {'age': 32, 'job': 'programmer'},#             'mary': {'age': 24, 'job': 'designer'}}}m.pprint(pformat='json')# {#     "people": {#         "dave": {#	      "age": 55,#	      "job": "manager"# 	  },# 	  "john": {#	      "age": 32,#	      "job": "programmer"# 	  },# 	  "mary": {#	      "age": 24,#	      "job": "designer"# 	  }#     }# }And many other features involving dots and dictionaries that will be immediately intuitive when used.
Package: dotmotif
d o t m o t i fFind graph motifs using intuitive notationDotMotif is a library that identifies subgraphs or motifs in a large graph. It looks like this:# Look for all motifs of the form,# Neuron A synapses on Neuron B:A->B# ...and B inhibits C:B->C[type="inhibitory"]ExamplesNotebookDescriptionLooking for motifs in the IARPA MICrONS Pinky100 DatasetMotif search in a custom graphSubgraph search in the Janelia Hemibrain datasetGet StartedIf you haveDotMotif, a NetworkX graph, and a curious mind, you already have everything you need to start using DotMotif:fromdotmotifimportMotif,GrandIsoExecutorexecutor=GrandIsoExecutor(graph=my_networkx_graph)triangle=Motif("""A -> BB -> CC -> A""")results=executor.find(triangle)ParametersYou can also pass optional parameters into the constructor for thedotmotifobject. Those arguments are:ArgumentType, DefaultBehaviorignore_directionbool:FalseWhether to disregard direction when generating the database querylimitint:NoneA limit (if any) to impose on the query resultsenforce_inequalitybool:FalseWhether to enforce inequality; in other words, whether two nodes should be permitted to be aliases for the same node. For example, inA->B->C; ifA!=C, then set toTrueexclude_automorphismsbool:FalseWhether to return only a single example for each detected automorphism. See more inthe documentationFor more details on how to write a query, seeGetting Started.CitingIf this tool is helpful to your research, please consider citing it with:# https://doi.org/10.1038/s41598-021-91025-5@article{Matelsky_Motifs_2021,title={{DotMotif: an open-source tool for connectome subgraph isomorphism search and graph queries}},volume={11},ISSN={2045-2322},url={http://dx.doi.org/10.1038/s41598-021-91025-5},DOI={10.1038/s41598-021-91025-5},number={1},journal={Scientific Reports},publisher={Springer Science and Business Media LLC},author={Matelsky, Jordan K. and Reilly, Elizabeth P. and Johnson, Erik C. and Stiso, Jennifer and Bassett, Danielle S. and Wester, Brock A. and Gray-Roncal, William},year={2021},month={Jun}}
Package: dotnet
Allows seamless integration of .NET (e.g. C#) code with Python (CPython, Anaconda).It runs as hybrid native code and CLR code. The CLR instance is created once
you import dotnet module into your Python code. Then you can load assemblies
and import namespaces and types directly into Python code, and use as Python
objects. This all runs within Python process, and no IPC is used to accomplish
this. Boost.Python has been used to write C++ layer, which glues Python and
Managed (.NET/CLR/C#) code.
Package: dotnetcore2
This wheel contains.NET Core, an open-source, general-purpose development platform maintained by Microsoft and the .NET community onGitHub. It's cross-platform (supporting Windows, macOS, and Linux) and can be used to build device, cloud, and IoT applications.SeeAbout .NET Coreto learn more about .NET Core, including its characteristics, supported languages and frameworks, and key APIs.This wheel is not intended for general use. This wheel is published to support Azure Machine Learning SDK.The major and minor versions of this wheel match the version of the .NET Core it contains. The revision number is not related to the .NET Core version (where version format is: {major}.{minor}.{revision}).