Saravanan666/pypi-org huggingface dataset:
Package: doxypypyplantuml
DoxypypyPlantUMLTLDR; if you are fed up with doxypypy screwing up your inlined PlantUML
diagrams then this is probably what you are looking for.PlantUML is great for incorporating UML diagrams in your software documentation.
If you have hybrid projects (containing for example both C and Python) you might
rely on Doxygen for generating some nice documentation. Typically, you can do
this by installing doxypypy, which transforms your Python docstrings into
Doxygen tagged documentation.So far so good.Unfortunately, doxypypy performs some transformations when it
sees things like colons (it thinks it's an argument?); these are typically used
in docstrings for documenting for example function arguments. This can become
problematic when you are inlining PlantUML diagram code.For an example refer
to "Bug Example" below.One way to fix this is to fix it in doxypypy. Unfortunately the code is really
hard to understand and unmaintained.
This package, doxypypyplantuml, implements a simple and effective solution.How It WorksYou simply provide it with the original file and the output
of doxypypy. Doxypypyplantuml will look for the@startumland@endumltags
(or \startuml and \enduml).
Everything in between these tags is part of the PlantUML Doxygen block.
It will replace everything in the doxypypy output between these tags by exactly
the same thing that was in the original file, only prefixing it with a#and
a correct amount of indentation.InstallationTo install it simply use pip as usual, e.g.:python3-mpipinstalldoxypypyplantumlUsing it in your projectThe steps are almost identical to the steps forsetting up doxypypy.
Just follow the steps there, but there is one difference: You need to pipe the
output of doxypypy to doxypypyplantuml and provide the original input.The py_filter file (for Unix-like operating systems) should therefore become:#!/bin/bashdoxypypy-a-c$1|doxypypyplantuml$1Development notesBefore committing always first run./run.pyand check the output.I've followed the instructions onhttps://packaging.python.org/en/latest/tutorials/packaging-projects/to create this package.To build and upload the package simply run./run.py --upload.Bug exampleThe following input, containing a PlantUML diagram in the class docstring, results in the
incorrect doxypypy output that's below it (it's invalid PlantUML syntax).classSomeStateMachine:"""The state machine for bla bla.It comprehends the following state machine:@startumlState_A: On Entry / Transmit somethingState_A: During / Retry every secondState_B: On Entry / Transmit GET_CCP_VERSION CROState_B: During / Retry every second[*] -d-> State_AState_A -d-> State_B: connect()@enduml"""def__init__(self,msg_handler:CcpMessageHandler):pass## @brief The state machine for bla bla.##    It comprehends the following state machine:##    @startuml# 	State_A	On Entry / Transmit something# 	State_A	During / Retry every second## 	State_B	On Entry / Transmit GET_CCP_VERSION CRO# 	State_B	During / Retry every second##    [*] -d-> State_A#    State_A -d-> State_B: connect()##    @enduml#classSomeStateMachine:def__init__(self,msg_handler:CcpMessageHandler):pass
Package: doxyqml
GoalsDoxyqml lets you use Doxygen to document your QML classes.It integrates as a Doxygen input filter to turn .qml files into pseudo-C++
which Doxygen can then use to generate documentation.InstallingDoxyqml uses the standard Python setup tools, so you can install it with pip:pip3 install doxyqmlor manually with:python3 setup.py installTelling Doxygen to use DoxyqmlTo tell Doxygen about Doxyqml you must make a few changes to your Doxygen
configuration file.Add the .qml extension to theFILTER_PATTERNSkey:FILTER_PATTERNS = *.qml=doxyqmlNote: on Windows Doxyqml installs itself in theScriptsfolder of your
Python installation. If this folder is not in the PATH, either add it or use
the full path to Doxyqml here (but that is less portable across machines)Add the .qml extension toFILE_PATTERNS:FILE_PATTERNS = *.qmlSince Doxygen 1.8.8, you must also add the .qml extension toEXTENSION_MAPPING:EXTENSION_MAPPING = qml=C++Documenting typesQML is partially-typed: functions are untyped, properties and signals are.
Doxyqml provides a way to define types when they are missing or not precise
enough.FunctionsFunctions in QML are untyped, but you can define types in the documentation
like this:/*** Create a user* @param type:string firstname User firstname* @param type:string lastname User lastname* @param type:int User age* @return type:User The User object*/functioncreateUser(firstname,lastname,age);PropertiesQML properties are typed, so Doxyqml uses them by default. You can nevertheless
overwrite the type using the sametype:<name>syntax. This is useful to
document property aliases:/** type:string The user lastname */propertyaliaslastname:someObject.textSignalsQML signals are typed, so there is no need to use thetype:<name>syntax to
document their parameters. Usingtype:<name>syntax in signal documentation
will not work: Doxyqml won't strip it out and Doxygen will confuse it with the
parameter name./*** User just logged in* @param user The user which logged in*/signalloggedIn(Useruser)Extracting internal elementsQML elements with an id are exported as private member variables. If you
set theEXTRACT_ALLandEXTRACT_PRIVATEDoxygen keys toYES, then
these elements will be visible in the generated documentation.
Package: doxysphinx
Doxysphinx is aDoxygenandSphinxintegration tool.It is an easy-to-use cli tool and typically runs right after Doxygen generation.
It reuses the Doxygen generated HTML output and integrates it into Sphinx document generation.
With this, Doxysphinx supports all known Doxygen features and at the same time integrates well with the Sphinx output (for example, Sphinx-Themes, search etc.).
Doxysphinx, also supportsrestructured text (rST) annotationswithin C++ files.Internally, Doxysphinx creates an rST file for each (Doxygen) HTML file and includes the HTML using.. raw:: htmldirective.
Later Sphinx picks up these rST files and creates an integrated documentation.Check out Doxysphinx alternativeshere.Links📚Doxysphinx Overview🚀Getting Started💻Developer Quickstart🤖Releases
Package: doyle
DescriptionDoyle is project to build the automation tool for date exploration and data preprocessing as a python package. 
Doyle is in initial process so the package and documents are not complete for now.InstallationIn current version, Doyle only support for python 3.7.. code-block:: bash
pip install doyle
# then, install sherlock package with the following command
pip install -e git+https://github.com/mitmedialab/sherlock-project.git#egg=sherlockDocumentsthe documents are not available for nowUsage.. code-block:: bash
>>> import doyle
>>> explorer = doyle.DataExplorer.explore_files("./data")
Package: dp2rathena
dp2rathenaConvert Divine-Pride API data to rAthena text database formatsdp2rathena is an open-source command-line tool, helping developers save time updating their rAthena database data.✨ Featuresitem_db.ymlmob_db.ymlmob_skill_db.txtmob_db.txt(planned)skill_db.yml(planned)🏁 Getting StartedRequirementsPython 3.6+Installationpip install dp2rathena💻 UsageAdivine-pride.netAPI key is required, create an account and generate a key if you don't have one yet.# Store API keydp2rathenaconfig# Convert items with ids 501 and 1101dp2rathenaitem5011101# Convert mob with id 20355dp2rathenamob20355# Convert mob skills from mob ids in a newline separated filedp2rathenamobskill-fmy_mobs.txt# Print out help textdp2rathena-h🛠️ LimitationsAll fields are mapped except the ones listed below:item_db.ymlPartially Mapped"Type"- when the item type is "Consumable" on DP and subtype "Special", we output a few possible options for user to choose the correct one (Healing, Usable, DelayConsume or Cash)"SubType"- when the item type is "Ammo" on DP, we output all rathena ammo subtypes for user to choose correct option as DP doesn't map all rathena ammo subtypesNot Mapped(insufficient data)"Script"/"EquipScript"/"UnEquipScript"- script to execute when some action is performed with the item"Class"- upper class types that can equip item"Flags"- item flags such as"BuyingStore","DeadBranch","BindOnEquip", etc..."Delay"- item use delay"Stack"- item stack amount"NoUse"- conditions when the item is unusable"AliasName"- another item's AegisName to be sent to client instead of this AegisNamemob_db.ymlNot Mapped(insufficient data)MvpExp- MVP experience gainedRaceGroups- list of secondary groups the monster may be part ofModes- list of unique behavior not defined by AI, Class, or AttributeJapaneseName- name in JapaneseDrops > RandomOptionGroup- the Random Option Group applied to item on dropDrops > Index- index used for overwriting itemNotesAi- not always defined on DP and needs manual input (refer torathena docs)Drops > Item- relies on an internal db yaml file (updated every dp2rathena release) to determine output aegis name🙌 ContributingThis project usespoetryto manage the development environment.Setup a local development environment withpoetry installRun tests withpoetry run tox(orpytestfor current python version)Run live API tests withpoetry run pytest --apiUpdate internal db yamls withpoetry run python tools/generate_item_db.py(ortools/generate_skill_db.py)Execute script withpoetry run dp2rathena📰 ChangelogSeeCHANGELOG.md📝 LicenseSeeLICENSE
Package: dp-accounting
Differential Privacy AccountingThis directory contains tools for tracking differential privacy budgets,
available as part of theGoogle differential privacy library.The set of DpEvent classes allow you to describe complex differentially private
mechanisms such as Laplace and Gaussian, subsampling mechanisms, and their
compositions. The PrivacyAccountant classes can ingest DpEvents and return the
ε, δ of the composite mechanism. Privacy Loss Distributions (PLDs) and RDP
accounting are currently supported.More detailed definitions and references about PLDs can be foundin our supplementary pdf document.Our library only support Python version >= 3.9. We test this library on Linux
with Python version 3.9. If you experience any problems, please file an issue on
GitHub, also for other platforms or Python versions.
Package: dpac-datetimepicker
This package uses Bootstrap v3 datetimepicker widget version 2 provided by the following project:https://github.com/Eonasdan/bootstrap-datetimepickerThe correct formatting options for dates can be found here:http://momentjs.com/docs/It works only with Bootstrap3. If you are using Bootstrap2 in your
Django project, check out this:https://github.com/zokis/django-bootstrap-datetimepickerInstallRunpip installdjango-bootstrap3-datetimepickerAdd'bootstrap3_datetime'to yourINSTALLED_APPSExampleforms.pyfrom bootstrap3_datetime.widgets import DateTimePicker
from django import forms

class ToDoForm(forms.Form):
    todo = forms.CharField(
        widget=forms.TextInput(attrs={"class": "form-control"}))
    date = forms.DateField(
        widget=DateTimePicker(options={"format": "YYYY-MM-DD",
                                       "pickTime": False}))
    reminder = forms.DateTimeField(
        required=False,
        widget=DateTimePicker(options={"format": "YYYY-MM-DD HH:mm",
                                       "pickSeconds": False}))Theoptionswill be passed to the JavaScript datetimepicker
instance. Availableoptionsare explained in the following
documents:http://eonasdan.github.io/bootstrap-datetimepicker/You don’t need to set thelanguageoption, because it will be set
the current language of the thread automatically.template.html<!DOCTYPE html>
<html>
    <head>
        <link rel="stylesheet"
              href="//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap.css">
        <link rel="stylesheet"
              href="//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap-theme.css">
        <script src="//ajax.googleapis.com/ajax/libs/jquery/1.9.0/jquery.js">
        </script>
        <script src="//netdna.bootstrapcdn.com/bootstrap/3.0.0/js/bootstrap.js">
        </script>
        {{ form.media }}
    </head>
    <body>
        <form method="post" role="form">
            {% for field in form.visible_fields %}
            <div id="div_{{ field.html_name }}"
                 class="form-group{% if field.errors %} has-error{% endif %}">
                {{ field.label_tag }}
                {{ field }}
                <div class="text-muted pull-right">
                    <small>{{ field.help_text }}</small>
                </div>
                <div class="help-block">
                    {{ field.errors }}
                </div>
            </div>
            {% endfor %}
            {% for hidden in form.hidden_fields %}
                {{ hidden }}
            {% endfor %}
            {% csrf_token %}
            <div class="form-group">
                <input type="submit" value="Submit" class="btn btn-primary" />
            </div>
        </form>
    </body>
</html>Bootstrap3 and jQuery have to be included along with{{ form.media }}Release Notesv2.3Updated bootstrap-datetimepicker.js to version 3.0v2.2.3Updated bootstrap-datetimepicker.js to version 2.1.30v2.2.3Updated bootstrap-datetimepicker.js to version 2.1.30v2.0.0Includes bootstrap-datetimepicker.js version 2.1.11 with moment.jsThe format strings have changed due to using moment.jsRequirementsPython >= 2.4Django >= 1.3Bootstrap >= 3.0
Package: dpac-tcxparser
Build Statusmaster:python-tcxparser is a minimal parser for Garmin’s TCX file format. It
is not in any way exhaustive.Data extracted:latitude & longitude of start point of workouttype of workout (running, walking, etc)time of completion of workout (in ISO UTC)distance of workout (in meters)duration of workout (in seconds)calories burned during workout (as estimated by device)average, max and min heart rate during workoutaverage pace during workoutaverage altitude during workoutascent and descent of workoutmax and min altitudetime stamp of each data point (in ISO UTC)average and max cadence (cycling activities)percentage and time spent in heart rate zoneaverage and max powertotal steps (also strokes)InstallationInstall it from PyPI:pip install python-tcxparserUsageBasic usage example:>>> import tcxparser
>>> tcx = tcxparser.TCXParser('/home/vinod/Downloads/20121226-212953.tcx')
>>> # Duration of workout in seconds
... tcx.duration
1992.78
>>> # latitude/longitude at start of workout
... tcx.latitude
35.951880198
>>> tcx.longitude
-79.0931872185
>>> tcx.activity_type
'running'
>>> # ISO UTC timestamp when workout completed
... tcx.completed_at
'2012-12-26T22:03:05Z'
>>> # distance of workout in meters
... tcx.distance
4686.31103516
>>> tcx.distance_units
'meters'
>>> # calories burned (as reported by device)
... tcx.calories
379
>>> # percentage of workout spent in each user-defined heart rate zone
... tcx.hr_percent_in_zones({"Z0": (0, 99), "Z1": (100, 129), "Z2": (130, 200)})
{"Z0": 14, "Z1": 36, "Z2": 50}CompatibilityPython 3.7+, seetox.ini.LicenseBSDMaintainer InformationWe use Github Actions to lint (using pre-commit, black, isort, and flake8),
test (using tox and tox-gh-actions), and calculate coverage (using coverage).We have a local script to do these actions locally, namedmaintain.sh:$ ./maintain.shA Github Action workflow also builds and pushes a new package to PyPI whenever a new
Release is created in Github. This uses a project-specific PyPI token, as described in
thePyPI documentation here. That token has been
saved in thePYPI_PASSWORDsettings for this repo, but has not been saved anywhere
else so if it is needed for any reason, the current one should be deleted and a new one
generated.As always, be sure to bump the version insetup.pybefore creating a Release, so
that the proper version gets pushed to PyPI.ContactPlease contact me with any questions: Vinod Kurup (vinod@kurup.com)
Package: dp-ai-data-harmonization
Data Harmonization PackageThis package provides functionality for file merging and data harmonization using various algorithms and AI models.
It allows you to merge CSV files and harmonize data based on a sample-based approach using GPT-based models.InstallationYou can install the package from PyPI using pip:pip install data-harmonization-aiUsageDataHarmonizer ClassTheDataHarmonizerclass provides the capability to merge CSV files based on different options.
It supports the following merge options:ChatGPTGPT4Fuzzy WuzzyRapidfuzzJaro WinklerJW Layered with ChatGPTJW Layered with GPT4FW Layered with GPT4Recursive Data HarmonizationExample usage:from utility import DataHarmonizerCreate an instance of DataHarmonizerkey='openai-key'
harmonizer = DataHarmonizer(key,'file1.csv', 'file2.csv', 'ChatGPT')Merge the files based on the specified optionresult = harmonizer.merge_files()print(result)DataHarmonizationWithSuggestion ClassThe DataHarmonizationWithSuggestion class allows you to harmonize data using a sample-based approach.It takes a sample file and two data files as input.Example usage:
from utility import DataHarmonizationWithSuggestionCreate an instance of DataHarmonizationWithSuggestionkey = 'openai-key'
harmonizer = DataHarmonizationWithSuggestion(key, "sample_harmonized_data.csv", "file1.csv", "file2.csv")Harmonize the data based on the sampleresult = harmonizer.harmonize_data()print(result)
Package: dpamber
dpamberSome useful tools related to Amber and DP.InstallationpipinstalldpamberToolscorr: generating data for DPRc modelscorrtool generatesDeePMD-kittraining data for DPRc from AMBER sander low-level QM/MM data and high-level data. For details of DPRc, read theDPRc paper.Before using this tool, one need to prepare low-level and high-level QM/MM data:$$
E_\text{hl}(\mathbf R)=E_\text{hl,QM}(\mathbf R)+E_\text{hl,QM/MM}(\mathbf R)+E_\text{MM}(\mathbf R)
$$$$
E_\text{ll}(\mathbf R)=E_\text{ll,QM}(\mathbf R)+E_\text{ll,QM/MM}(\mathbf R)+E_\text{MM}(\mathbf R)
$$Low-level and high-level data should use the same coordinate and the same MM method, but different QM methods. So, the correction energy for training will be$$
\Delta E (\mathbf R) = E_\text{hl}(\mathbf R) - E_\text{ll}(\mathbf R) = (E_\text{hl,QM}(\mathbf R) - E_\text{ll,QM}(\mathbf R)) + (E_\text{hl,QM/MM}(\mathbf R) - E_\text{ll,QM/MM}(\mathbf R))
$$An example of the command isdpambercorr--cutoff6.--qm_region":1"--parm7_filesome_param.param7--ncsome_coord.nc--hlhigh_level--lllow_level--outdatasetwhere--cutofftakes cutoff radius of the QM/MM interaction for training.--qm_regiontakes AMBER mask format for the QM region.--parm7_fileand--nctake the PARM7 file and the trajectory (NetCDF) file, respectively.--lland--hlare the prefixes of low-level and high-level files, including the mdout file (.mdout), the mden file (.mden) and the mdfrc file (.mdfrc). The output dataset directory should be put in--out.See details fromdpamber corr -h.devi: calculate model deviationdevican be used to calculate the model deviation of a given trajectory.
You need to install DeePMD-kit usingpipinstalldpamber[dpgpu]Seedpamber devi -hfor details.
Package: dpapick
OVERVIEWDPAPIck is a python toolkit to provide a platform-independant implementationof Microsoft's cryptography subsytem called DPAPI (Data Protection API).It can be used either as a library or as a standalone tool.It is also the first open-source tool that allows decryption of DPAPIstructures in an offline way and, moreover, from another plateform thanWindows.It is provided with some application probes that includes the built-in logicto retreive the corresponding secrets that are protected.To have more information or to contact us, go to our website:http://www.dpapick.comREQUIREMENTSThis application has been developped and tested on python 2.7.M2Crypto is required to provide all the requireds algorithms. To obtain it,see: http://chandlerproject.org/bin/view/Projects/MeTooCryptoProbes and other tool may require other modules to be able to retreiveinformation such as:* python-sqlite3 for Google Chrome password database* CFPropertyList for Apple Safari keychain.plistsee https://github.com/bencochran/CFPropertyList* python-registry for low-level manipulation of hivessee https://github.com/williballenthin/python-registry* pyASN1 for the RSA key pair manipulationsee http://pyasn1.sourceforge.net/We also recommend the use of MoonSols Windows Memory Toolkit to converthibernation file to usable memory dumps and be able to extract credentialsfrom it.For more information about Moonsols products, see <http://www.moonsols.com>AUTHORDPAPIck is written by Jean-Michel Picod (jean-michel.picod@cassidian.com)with the help from Ivan Fontarensky (ivan.fontarensky@cassidian.com)who work for the Cyber Security Center of Cassidian, an EADS company,and Elie Bursztein (dpapi@elie.im)LICENSEThis program is free software: you can redistribute it and/or modifyit under the terms of the GNU General Public License as published bythe Free Software Foundation version 3 of the License.This program is distributed in the hope that it will be useful,but WITHOUT ANY WARRANTY; without even the implied warranty ofMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See theGNU General Public License for more details.You should have received a copy of the GNU General Public Licensealong with this program.  If not, see <http://www.gnu.org/licenses/>.
Package: dpapick3
DPAPIck3OVERVIEWDPAPIck3 is a python3 toolkit to provide a platform-independant implementation
of Microsoft's cryptography subsytem called DPAPI (Data Protection API).It can be used either as a library or as a standalone tool.It is also the first open-source tool that allows decryption of DPAPI
structures in an offline way and, moreover, from another plateform than
Windows.REQUIREMENTSThis application has been developped and tested on python 3.9.pycryptodome is required to provide all the requireds algorithms.
Furthermore only python-registry for some scriptspython-registrypycryptodomepyasn1AUTHORDPAPIck3 is written by Jean-Michel Picod (jean-michel.picod@cassidian.com) with the help from Ivan Fontarensky (ivan.fontarensky@cassidian.com)who work for the Cyber Security Center of Cassidian, an EADS company, and Elie Bursztein (dpapi@elie.im)And adjusted for Python3 and Windows by Photubias (info@insecurity.be)
Package: dparcel
dparcelis a very simple model of downdrafts in atmospheric convection that uses parcel theory to simulate the motion of a descending, entraining air parcel.
You may supply any atmospheric sounding and initial conditions for the calculation.It was developed by Thomas Schanzer, an undergraduate student at the University of New South Wales, as part of a research project under the supervision
of Prof. Steven Sherwood of the UNSW Climate Change Research Centre.InstallationUse the package managerpipto installdparcel.pip install dparcelDependenciesThe following packages must be installed:numpyscipymetpy>=1.2DocumentationDocumentation is available athttps://dparcel.readthedocs.io/.LicenseBSD-3-Clause License
Package: dpassgen
Author:John H. Dulaney <jdulaney@fedoraproject.org>Based on the idea fromhttps://xkcd.com/936/, uses /dev/urandom to
pick a number of words from /usr/share/dict/words or
/usr/dict/words.Installationsudo python setup.py installorpython3 setup.py installUsage:dpassgen <number>where <number> is the number of words you would like in your password.