Saravanan666/pypi-org huggingface dataset:
Package: dokusan
Sudoku generator and solver with a step-by-step guidanceInstallationpipinstalldokusanQuickstartSudoku SolversStep-by-step solverThis solver tries to solve sudoku using human-like strategies.
Currently following techniques are supported:Naked/Hidden singlesNaked Pairs/TripletsLocked CandidateXY-WingUnique RectangleFor example to see all techniques that sudoku has:fromdokusanimportsolversfromdokusan.boardsimportBoxSize,Sudokusudoku=Sudoku.from_list([[0,0,0,0,9,0,1,0,0],[0,0,0,0,0,2,3,0,0],[0,0,7,0,0,1,8,2,5],[6,0,4,0,3,8,9,0,0],[8,1,0,0,0,0,0,0,0],[0,0,9,0,0,0,0,0,8],[1,7,0,0,0,0,6,0,0],[9,0,0,0,1,0,7,4,3],[4,0,3,0,6,0,0,0,1],],box_size=BoxSize(3,3),){step.combination.nameforstepinsolvers.steps(sudoku)}Backtracking-based solverThis solver is based on backtracking algorithm,
however slightly modified to work fastfromdokusanimportsolvers,renderersfromdokusan.boardsimportBoxSize,Sudokusudoku=Sudoku.from_list([[0,0,0,0,0,0,0,0,0],[0,0,0,0,0,3,0,8,5],[0,0,1,0,2,0,0,0,0],[0,0,0,5,0,7,0,0,0],[0,0,4,0,0,0,1,0,0],[0,9,0,0,0,0,0,0,0],[5,0,0,0,0,0,0,7,3],[0,0,2,0,1,0,0,0,0],[0,0,0,0,4,0,0,0,9],],box_size=BoxSize(3,3),)solution=solvers.backtrack(sudoku)print(renderers.colorful(solution))Sudoku GeneratorGenerator algorithm is mainly based onarticleby Daniel Beer.
The average time to generate Sudoku with rank of 150 is 700ms.To generate a new sudoku:fromdokusanimportgenerators,rendererssudoku=generators.random_sudoku(avg_rank=150)print(renderers.colorful(sudoku))Ranking and Sudoku difficultyavg_rankoption roughly defines the difficulty of the sudoku.
Sudoku with rank lower than 100 contains only naked/hidden singles.
Sudoku with rank greater than 150 contains
Naked Subsets/Locked Candidate/XY Wing/etc…,
however this is not always guaranteed.For higher ranks it is also not guaranteed that generated Sudoku rank
will be higher than providedavg_rank,
so to ensure sudoku has desired rank one can do the following:fromdokusanimportgenerators,statsavg_rank=450whilestats.rank(sudoku:=generators.random_sudoku(avg_rank))<avg_rank:continue
Package: dokuwiki
This python module aims to manageDokuWikiwikis by using the providedXML-RPC API.
This module is compatible with python2.7 and python3+.API is describedhere.Release notes1.3.3 (2022-06-28)Allow slash character in passwords (#26)1.3.2 (2021-12-03)Correct a bug when using some special characters in the password (c891eb8)1.3.1 (2021-08-30)Set default empty value forsummarytostructs.get_data()Addminorparameter tostructs.get_data()1.2.1 (2019-07-24)Removelogincall
in the constructor as it seems to fail on some cases (98ed799).1.2.0 (2019-06-25)Support of HTTPS for cookie based authentication.1.1.0 (2018-03-22)Support authentication by cookie (thanks toluminisward).1.0.1 (2017-04-06)Correct a typo with an exception call.1.0 (2017-04-06)Prevent username and password to be passed as GET parameters (e4cbb5d).0.5 (2016-08-19)Correct a bug when retrieving/uploading medias (a1f56b6).0.4 (2016-02-07)Allow media to be get/set as bytes (44c6dcf,1621291)Force login after XML-RPC initialization for ensuring the connection is working (55ffff8)Fix minor bugs (d5b7163,9b164ea)Add sphinx documentation based on docstrings (74968dc,c8e1503)0.3 (2015-08-16)The xmlrpc parameteruse_datetimeis no longer forced toTrueby default (bec3447).This may break things!0.2 (2014-01-29)Manage dataentries (this is a plugin for managing metadatas).0.1 (2014-01-29)Implement DokuWiki XML-RPC commands.Compatible with both python 2 and 3.
Package: dokuwiki-fuse
FUSE DokuWiki将 DokuWiki 的 wiki 使用 fuse 挂载到本地，然后可以使用本地编辑器编辑。dokuwiki 必须启用了 markdown 插件，并且启用了 xmlrpc 功能。用法dokuwiki-fuse -s http://dokuwiki.com:80 -u abc -p '' ./mount-dir/当指定了-p ''时，会询问密码。
Package: dokuwikixmlrpc
dokuwikixmlrpcis a python module which implementsDokuWiki’s XML-RPC
interface.Installation:pip install dokuwikixmlrpcIt can be used to send/retrieve data from remote DokuWiki instances:import dokuwikixmlrpc
dw = DokuWikiClient('https://mywikiurl.com', 'wikiuser', 'wikipassword')
print(dw.dokuwiki_version)
print(dw.pagelist(':'))The module can be executed as a standalone script (this is mainly for testing
purposes). Callpython -m dokuwikixmlrpc --helpfor more information.Copyright 2009 by Michael Klier <chi@chimeric.de>.SeeLICENSE.txtfor license info.
Package: doky
Doky ToolA intuitive CLI tool and Python Library for manage your Docker-In-Docker instancesfromPlay With DockerAny questions? Open an issue!Usage$ doky

Usage: doky [OPTIONS] COMMAND [ARGS]...

  Doky is a intuitive library and CLI tool for manage your Docker-In-Docker
  instances from Play With Docker Lab

Options:
  -h, --help  Show this message and exit.

Commands:
  version  Show current app version.

  User authentication management:
    auth me                       Show your authentication user informations.
    auth oauth [--provider NAME]  Request for an OAuth URL to authenticate with a provider.
    auth providers                List available OAuth providers to request an OAuth URL.
    auth token <TOKEN>            Set the authentication session ID.InstallationWill you only use the CLI? Then install withpipx:$pipxinstalldokyWill you use both? Then you can install withpip/poetry/etc:$pipinstalldoky
$poetryadddoky
Package: dolaru-swagger-client
A Python library for Klaviyo's APIInstallationYou can install this library using thepiptool.Depending on your system configuration, you will need to run the following shell command:pip install klaviyo-sdkORpip3 install klaviyo-sdkImportTo import this package, run the following Python command:import klaviyo_sdkUsing this LibraryDocumentation specific to this library can be foundhereUsing the Klaviyo APIDocumentation for Klaviyo's API can be foundhereNOTE: sample API calls featured in the API docs do NOT use this library or others; rather, they make outright HTTP calls.Setting up a Klaviyo AccountSign up for a free Klaviyo accounthere
Package: do-latency
Digital Ocean latency checker helps to find fastest DO region from your location.INSTALLATIONpip install do-latencyUSAGE-h, –help- show help–ping-count- count of ICMP requests for latency check (default: 10)–file-size {10mb, 100mb}- size of downloaded file (default: 10mb).–udp- use UDP not ICMP.In some linux systems UDP testing does not work, so you should use true ICMP and run `do-latency` from root:sudo do-latencyTODO[x]  latency check with ICMP[x]  download speed measurement[x]  python 3 supportLICENSEMIT
Package: dolfen
dolfen: Downsampling Likelihood Function Estimationdolfen: Downsampling Estimation of the Likelihood function for Time-domain signalsdolfenis an algorithm for Bayesian analysis that infers the likelihood function by downsampling. It is designed in particular for use with simulated, long duration, slowly evolving signals consisting of very many datapoints, where the Bayesian likelihood is expensive.Installationdolfencan be installed usingpip:pip install dolfenUsingbilbySee the examples included withdolfenfor how to rundolfenviabilby.DocumentationDocumentation is available at:dolfen.readthedocs.io
Package: dolfin-adjoint
The algorithmic differentation tool pyadjoint and add-onsThe full documentation is availablehereInstallationFirst installFEniCSThen install the pyadjoint with:
python3 -m pip install git+https://github.com/dolfin-adjoint/dolfin-adjoint.git@mainReporting bugsIf you found a bug, create anissue.ContributingWe love pull requests from everyone.Fork, then clone the repository:git clone https://github.com/dolfin-adjoint/dolfin-adjoint.gitMake sure the tests pass:python3 -m pytest testsMake your change. Add tests for your change. Make the tests pass:python3 -m pytest testsPush to your fork andsubmit a pull request.At this point you're waiting on us. We may suggest
some changes or improvements or alternatives.Some things that will increase the chance that your pull request is accepted:Write tests.Add Python docstrings that follow theGoogle Style.Write good commit and pull request message.LicenseThis software is licensed under theGNU LGPL v3.
Package: dolfin-mech
dolfin_mechA set of FEniCS-based python tools for Computational Mechanics.The library has notably been used in:[Genet (2019). A relaxed growth modeling framework for controlling growth-induced residual stresses. Clinical Biomechanics.][Álvarez-Barrientos, Hurtado & Genet (2021). Pressure-driven micro-poro-mechanics: A variational framework for modeling the response of porous materials. International Journal of Engineering Science.][Patte, Genet & Chapelle (2022). A quasi-static poromechanical model of the lungs. Biomechanics and Modeling in Mechanobiology.][Patte, Brillet, Fetita, Gille, Bernaudin, Nunes, Chapelle & Genet (2022). Estimation of regional pulmonary compliance in idiopathic pulmonary fibrosis based on personalized lung poromechanical modeling. Journal of Biomechanical Engineering.][Tueni, Allain & Genet (2023). On the structural origin of the anisotropy in the myocardium: Multiscale modeling and analysis. Journal of the Mechanical Behavior of Biomedical Materials.][Laville, Fetita, Gille, Brillet, Nunes, Bernaudin & Genet (2023). Comparison of optimization parametrizations for regional lung compliance estimation using personalized pulmonary poromechanical modeling. Biomechanics and Modeling in Mechanobiology.]InstallationA working installation ofFEniCS(version 2019.1.0) is required to rundolfin_mech.
To setup a system, the simplest is to useconda: first installminiconda(note that for Microsoft Windows machines you first need to install WSL, theWindows Subsystem for Linux, and then install miniconda for linux inside the WSL; for Apple MacOS machines with Apple Silicon CPUs, you still need to install the MacOS Intel x86_64 version of miniconda), and then install the necessary packages:conda create -y -c conda-forge -n dolfin_mech fenics=2019.1.0 meshio=5.3 mpi4py=3.1.3 pip python=3.10
conda activate dolfin_mech
pip install dolfin_mech numpy==1.24
Package: dolfin-navier-scipy
dolfin_navier_scipyThis python modulednsprovides an interface between the FEM toolboxFEniCSandSciPyin view of simulation and control of incompressible flows. Basically,FEniCSis used to discretize theincompressible Navier-Stokes equationsin space. Thendnsmakes the discretized operators available inSciPyfor use in model reduction, simulation, or control and optimization.dnsalso contains a solver for the steady state and time dependent problems.Quick StartTo get started, create the needed subdirectories and run one of thetests/time_dep_nse_.pyfiles, e.g.pip install sadptprj_riclyap_adi
cd tests
mkdir data
mkdir results
# export PYTHONPATH="$PYTHONPATH:path/to/repo/"  # add the repo to the path
# pip install dolfin_navier_scipy                # or install the module using pip
python3 time_dep_nse_expnonl.pyThen, to examine the results, launchparaview results/vel_TH__timestep.pvdTest Cases and ExamplesA selection:tests/mini_setup.py: a minimal setup for a steady-state simulationtests/steadystate_schaefer-turek_2D-1.py: the 2D steady-state cylinder wake benchmark bySchäfer/Turektests/steadystate_rotcyl.py: the 2D cylinder wake with a freely rotating cylinder as benchmarked inRichter et al.tests/time_dep_nse_.py: time integration with Picard and Newton linearizationtests/time_dep_nse_expnonl.py: time integration with explicit treatment of the nonlinearitytests/time_dep_nse_bcrob.py: time integration of the cylinder wake with boundary controlstests/time_dep_nse_krylov.py: time integration with iterative solves of the state equations viakrypytests/time_dep_nse_double_rotcyl_bcrob.py: rotating double cylinder via
Robin boundary conditionsDependenciesdolfin interface toFEniCS-- tested withv2019.2.0,v2018.1.0,v2017.2sadptprj_riclyap_adiThe latter is my home-brew module that includes the submodulelin_alg_utilswith routines for solving the saddle point problem as it arises in the(v,p)formulation of the NSE.Note: the branchlau-includedalready contains the modulesadptprj_riclyap_adiDocumentationDocumentation of the code goeshere.Installation as Modulepip install dolfin_navier_scipyChangelogv1.1.3catch the case that thedatapointsdo not extend to the full time rangeenforce explicit specification of the FEM scheme inproblem_setups.gen_bccont_fems
Package: dolg
DOLG in torch and tensorflow (TF2)Re-implementation (Non Official) of the paper DOLG: Single-Stage Image Retrieval with Deep Orthogonal Fusion of Local and Global Features accepted at ICCV 2021.paperThe pytorch checkpoint has been converted into tensorflow format (.h5) from this repository :https://github.com/feymanpriv/DOLG(Official)PipelineInstallationpip install opencv-python==4.5.5.64pip install huggingface-hubto install dolg :pip install dolg
OR
pip install -e .InferenceTo do some inference on single sample, you can use python script in examples/ folder or use as follows:import dolg
import numpy as np
from dolg.utils.extraction import process_data

depth = 50

# for pytorch

import torch
from dolg.dolg_model_pt import DOLG
from dolg.resnet_pt import ResNet

backbone = ResNet(depth=depth, num_groups=1, width_per_group=64, bn_eps=1e-5, 
             bn_mom=0.1, trans_fun="bottleneck_transform")
model = DOLG(backbone, s4_dim=2048, s3_dim=1024, s2_dim=512, head_reduction_dim=512,
             with_ma=False, num_classes=None, pretrained=f"r{depth}")
img = process_data("image.jpg", "", mode="pt").unsqueeze(0)

with torch.no_grad():
    output = model(img)
print(output)

# for tensorflow

import tensorflow as tf
from dolg.dolg_model_tf2 import DOLG
from dolg.resnet_tf2 import ResNet


backbone = ResNet(depth=depth, num_groups=1, width_per_group=64, bn_eps=1e-5, 
             bn_mom=0.1, trans_fun="bottleneck_transform", name="globalmodel")
model = DOLG(backbone, s4_dim=2048, s3_dim=1024, s2_dim=512, head_reduction_dim=512,
             with_ma=False, num_classes=None, pretrained=f"r{depth}")
img = process_data("image.jpg", "", mode="tf")
img = np.expand_dims(img, axis=0)
output = model.predict(img)
print(output)DataThe model has been trained on google landmark v2. You can find the dataset on the official repository :https://github.com/cvdfoundation/google-landmark.Citation :@misc{yang2021dolg,title={DOLG: Single-Stage Image Retrieval with Deep Orthogonal Fusion of Local and Global Features},author={Min Yang and Dongliang He and Miao Fan and Baorong Shi and Xuetong Xue and Fu Li and Errui Ding and Jizhou Huang},year={2021},eprint={2108.02927},archivePrefix={arXiv},primaryClass={cs.CV}}@misc{https://doi.org/10.48550/arxiv.2004.01804,doi={10.48550/ARXIV.2004.01804},url={https://arxiv.org/abs/2004.01804},author={Weyand, Tobias and Araujo, Andre and Cao, Bingyi and Sim, Jack},keywords={Computer Vision and Pattern Recognition (cs.CV), FOS: Computer and information sciences, FOS: Computer and information sciences},title={Google Landmarks Dataset v2 -- A Large-Scale Benchmark for Instance-Level Recognition and Retrieval},
Package: dolib
Python Digital Ocean LibraryDescriptionDOLib is a fully featured python 3.6+ library for Digital Ocean, which provides sync and async APIs. This library supports all Digital Ocean API methods and simple in use. Enjoy!DocumentationComming soon.RequirementsPython 3.6+DOLib uses these awesome libraries:HTTPXfor async network.Pydanticfor the data parts.InstallationpipinstalldolibExampleSync clientfromdolibimportClientclient=Client(token="60c13d47f17dbed9f7293cf8c82d18fece3439a54f88e6c52c2df07f87bd8dd9")droplets=client.droplets.all()volume=client.volumes.get("53cf7120-9d5b-11ea-aed1-0a58ac14d008")client.volumes.attach(volume,droplet_id=droplets[0].id)Async clientfromdolibimportAsyncClientfromdolib.modelsimportDropletasyncwithClient(token="60c13d47f17dbed9f7293cf8c82d18fece3439a54f88e6c52c2df07f87bd8dd9")asclient:droplet=Droplet(name="dolib-droplet",region="fra1",size="s-1vcpu-1gb",image="ubuntu-18-04-x64")droplet=awaitclient.droplets.create(droplet)ContributingTo run the tests:tox-pallVersioningThis project followsSemantic Versioning 2.0.0.LicenseThis project is licensed under the terms of the MIT license.
Package: dolittle-timeseries-runtime-contracts
TimeSeries Runtime ContractsThis repository holds theProtobufandgRPCAPI contracts for what is exposed from our TimeSeries Runtime.It is language agnostic and supports generated code (proxies) for multiple languages.CloningThis repository has sub modules, clone it with:$ git clone --recursive <repository url>If you've already cloned it, you can get the submodules by doing the following:$ git submodule update --init --recursive<>
Package: dollarN
dollarNPython implementation of $N, the 2D multistrokes recognizerhttp://depts.washington.edu/acelab/proj/dollar/ndollar.htmlThe $N Multistroke Recognizer is a 2-D multistroke recognizer designed
for rapid prototyping of gesture-based user interfaces. $N is built upon
the $1 Unistroke Recognizer. $N automatically generalizes examples of
multistrokes to encompass all possible stroke orders and directions,
meaning you can make and define multistrokes using any stroke order and
direction you wish, provided you begin at either endpoint of each
component stroke, and $N will generalize so as to recognize other ways
to articulate that same multistroke. A version of $N utilizing
Protractor, optional here, improves $N's speed.FeaturesPython 3NumpyExample of use:import dollarN as dN

r = dN.recognizer()
#By default, a recognizer gives a positive result when gestures have
#the same number of strokes only. This can be turned off:
#r.set_same_nb_strokes(False)

#Rotation invariance can also be turned off:
#r.set_rotation_invariance(False)

#Adding gestures: multistrokes with names
r.add_gesture('U', [   [[0.,5.], [0.,0.], [5.,0.], [5.,5.]]    ]) # one stroke
r.add_gesture('X', [   [[0.,0.], [5.,5.]], [[0.,5.], [5.,0.]]  ]) # two strokes
r.add_gesture('T', [   [[0.,5.], [5.,5.]], [[2.5,0.], [2.5,5.]]]) # two strokes

#Launching a recognition
test = [[[0, 5.2], [5.,5.]], [[2.5, 0.], [2.5,5.]]]
print( r.recognize(test) ){'name': 'T', 'value': 0.9484976300936439, 'time': 0.006083965301513672}DemoA demo is available with tkDollarN.pyhere
Package: dollarpy
dollarpyis a python implementation of the$P Point-Cloud
Recognizer.From the website:The $P Point-Cloud Recognizer is a 2-D gesture recognizer designed
for rapid prototyping of gesture-based user interfaces. In machine
learning terms, $P is an instance-based nearest-neighbor classifier
with a Euclidean scoring function, i.e., a geometric template
matcher.$P is the latest in the dollar family of recognizers that includes
$1 for unistrokes and $N for multistrokes. Although about half of
$P’s code is from $1, unlike both $1 and $N, $P does not represent
gestures as ordered series of points (i.e., strokes), but as
unordered point-clouds. By representing gestures as point-clouds, $P
can handle both unistrokes and multistrokes equivalently and without
the combinatoric overhead of $N. When comparing two point-clouds, $P
solves the classic assignment problem between two bipartite graphs
using an approximation of the Hungarian algorithm.Vatavu, R. D., Anthony, L., & Wobbrock, J. O.,“Gestures as Point
Clouds: A $P Recognizer for User Interface
Prototypes”,
in:Proceedings of the 14th ACM International Conference on Multimodal
Interaction (ICMI), Santa Monica, LA, USA, 2012, pp. 273-280.Installationdollarpycan be installed using pip:pip install dollarpyUsagedollarpyis used in 3 steps:fromdollarpyimportRecognizer,Template,Point# Define 'Template' gestures, each consisting of a name and a list of 'Point' elements.# These 'Point' elements have 'x' and 'y' coordinates and optionally the stroke index a point belongs to.tmpl_1=Template('X',[Point(0,0,1),Point(1,1,1),Point(0,1,2),Point(1,0,2)])tmpl_2=Template('line',[Point(0,0),Point(1,0)])# Create a 'Recognizer' object and pass the created 'Template' objects as a list.recognizer=Recognizer([tmpl_1,tmpl_2])# Call 'recognize(...)' to match a list of 'Point' elements to the previously defined templates.result=recognizer.recognize([Point(31,141,1),Point(109,222,1),Point(22,219,2),Point(113,146,2)])print(result)# Output: ('X', 0.733770116545184)
Package: dollars
Converts amounts of any (a lot!) currency to dollars.This will usehttps://openexchangerates.org/as a backend. It will cache
the rates for you and pull in the new values hourly so your data will
never be older than almost 2 hours in the worst case. For that, you will
be able to use the free plan.This is how you use it:$ pip install dollars
$ export OXR_APP_ID=...  # Your freely achieved app id
$ ipython

In [1]: from dollars import dollar

In [2]: dollar('EUR', 5)
Out[2]: 5.271147845154761Stop worrying, start converting!
Package: dollar-templates
Pandoc style dollar templates for pythonA slim reimplementation of pandoc's templating engine
in python. This allows you to use pandoc-style templates
(cf.https://pandoc.org/MANUAL.html#template-syntax) in any python
project, even if you do not want to use pandoc itself.While this project aims to follow the template syntax described in
the pandoc documentation, it is a completely separate project and may
therefore behave differently than pandoc in certain situations. Especially
edge cases are not particularly well tested (yet). Also note that, as
of now, not all features found in pandoc's templating engine have been
implemented (see below). If you notice differences between pandoc anddollar_templatesconcerning features that have been implemented,
feel free to submit a bug report or even a pull request.InstallingThis repository uses python setuptools and can be installed with pip.
To install dollar_templates into the current user's home directory, for
instance, you can simply invokepip install --user .. Also note that
a stable version of this python module is available at pypi. To install
the stable version, simply runpip install --user dollar-templates.UsageThe easiest way to expand a template with some data is to use theapply_templatefunction:fromdollar_templatesimportapply_templatetemplate="$for(var)$- $var$\n$endfor$"metadata={"var":[1,2,3]}print(apply_template(template,metadata))To parse the template once and apply it multiple times to different
data, use theparse_templatefunction that returns an object of
typedollar_templates.Template.fromdollar_templatesimportparse_templatetemplate="$for(var)$- $var$\n$endfor$"metadata_a={"var":[1,2,3]}metadata_b={"var":[11,12,13]}t=parse_template(template)print(t.apply(metadata_a))print(t.apply(metadata_b))Unit testsUnit tests are implemented intest_all.pyand can be executed withpytest. Simply install pytest and then execute
thepytestcommand in this directory without arguments.Implementation statePandoc lists the following features of its templating engine
(cf.https://pandoc.org/MANUAL.html#template-syntax):CommentsDelimitersInterpolated variablesConditionalsFor loopsPartialsNestingBreakable spacesPipesThe list above shows which ones have been implemented in dollar_templates.
The missing ones might or might not follow in the future.LicenseAll files in this repository are made available under the terms of the
GNU General Purpose License, version 3 or later. A copy of that license
is included in the repository aslicense.txt.
Package: dollop
DollopA python package for splitting up iterables into smaller portions 🥣.UsageSupports:Sequences:list,tuple,str,range,bytes,bytearrayor any other sequence-like object.Pandas objects:DataFrame,Series.Files:either as a file path or handle.Example usage (automatically checks object type):from dollop import serve

dollops = serve(items, serving_size=10)

for dollop in dollops:
    do_something(dollop)Theserving_sizeparameter defines how many items/lines/characters/etc. you want in each dollop!To use type-specificdollop:Sequences:from dollop.sequence import serve.Pandas:from dollop.pandas import serveFiles:from dollop.file import serve.Fordollop.fileyou can specifymode=linesormode=charsto read the file line-by-line or character-by-character.See alsoThemore_itertoolsand later (Python 3.12+)itertoolspackages have something similar:from more_itertools import chunked

chunks = chunked(iterable, n))andfrom itertools import batched

batches = batched(iterable, n))These both have the disadvantage that typing is not preserved.