Saravanan666/pypi-org huggingface dataset:
Package: dk-test-py2
importcollpaycollpay_obj=collpay.Collpay("0810545410c0dd7822cdd7c7caa336b2",collpay.ENV_SANDBOX,collpay.V1)response=collpay_obj.get_exchange_rate("USD","BTC")print(response)response=collpay_obj.create_transaction({'payment_currency':'BTC','order_currency':'USD','order_amount':'10','payer_name':'Xxx','payer_email':'xxx@gmail.com','payer_phone':'xxxxxxxx','payer_address':'Bangladesh 1216','ipn_url':'https://webhook.site/3b3ed4bf-8adb-4aec-b360-1d0c1c394766','ipn_secret':'Cf9mx4nAvRuy5vwBY2FCtaKr',#Any random secret string of your's, It can be empty.'success_url':'https://www.success.io/success.html','cancel_url':'https://www.failure.io/cancel.html','cart':'{"item_name":"t-shirt","item_number":"23","invoice":"SDF-453672-PMT"}',#Send any data format like json'webhook_data':'{"order_id":"ABC12345-12"}'#Send any data format like json})print(response)response=collpay_obj.get_transaction("xxxxxxxxxxx")print(response)
Package: dktoeasysqlite3
Ce module sert à simplifier les appels à la base de donnéeDocumentationOn-linehttp://discord-catho.frama.io/easy_sqlite3RebuiltUse SphinxVersion du setup : setup.cfg pour python3.9 car version par defaut dans Debian11 (maintenue jusque courant 2025)pip3 install --upgrade --force-reinstall .
Package: dktoparserhtml
DescriptionTransformer de l'utf8 en HTML et de l'HTML en Markdown principalement.
Utile pour plusieurs projets, donc création d'un repo séparé, qui sera ensuite appelé en tant que sous-module.InstallationModule bs4 à installer :$ python -m venv env_module
$ source env_module/bin/activate
$ pip3 install -r requirements.txtUtilisationVia pip$ pip install dktoparserhtmlComme submodule$ cd /path/superprojet
$ mkdir -p scripts/external && cd scripts/external
$ git submodule add git@framagit.org:discord-catho/parserhtml.git
$ git submodule update --recursive --init
$ git submodule update --recursive --remoteDocumentationVersion en ligne :http://discord-catho.frama.io/parserhtmlInstallation localeIl faut les librairies Python :sphinx,sphinx-rtd-themeetmyst-parserCompris dans le fichier requirements.txt (voir la section Installation)Liens :git :https://framagit.org/discord-catho/parserhtmlPypi :https://pypi.org/project/dktoparserhtmlLicenceGNU AGPL 3
Package: dktorecuperedb
Installer ce module en local (après$ git clone ...):$ cd /path/module_recupere_db
$ pip install -e .[doc]Variables d'environnement :OfficesRECUPEREDB_OFFICE_PATH : (default: ./datas/office.db)RECUPEREDB_OFFICE_JSONPATH : (default:  {RECUPEREDB_OFFICE_PATH}/../office/{self.office}.json)RECUPEREDB_OFFICE_INFO_NAME :  (default: office_info)RECUPEREDB_OFFICE_ELEMENT_NAME : (default: office_element)RECUPEREDB_OFFICE_HUNFOLDING_NAME : (default: office_deroule)RECUPEREDB_OFFICE_ADDITIONNAL_NAME : (default : office_addition)CompendiumRECUPEREDB_COMPENDIUM_PATH : (default:./datas/compendium.db)RECUPEREDB_COMPENDIUM_CONTENT_NAME : (default: content)RECUPEREDB_COMPENDIUM_SEQUENCE_NAME : (default: sequence)RECUPEREDB_COMPENDIUM_COLLECTION_NAME : (default: content_collection)BibleRECUPEREDB_BIBLE_PATH : (default: ./datas/bible.db)RECUPEREDB_BIBLE_NAME : (default: verses)1 anRECUPEREDB_BIBLE1YEAR_PATH : (default: ./datas/bible1year.db)RECUPEREDB_BIBLE1YEAR_NAME : (default: bible_references)TODO :Unifier les bases de données avec différentes tablesRemarques :Je mets à jour pip23.1.2N'ont pas fonctionnés dans le fichier setup.cfgparserhtml==1.0.0 @ git+ssh://git@framagit.org:discord-catho/module_html_parser.git@v1.0.0#egg=parserhtml
parserhtml @ git+ssh://git@framagit.org:discord-catho/module_html_parser.git@v1.0.0#egg=parserhtml
easysqlite3 @ git+ssh://git@framagit.org:discord-catho/easy_sqlite3.git#egg=easysqlite3
parserhtml @ git+ssh://git@framagit.org:discord-catho/module_html_parser.git
easysqlite3 @ git+ssh://git@framagit.org:discord-catho/easy_sqlite3.git
parserhtml @ file:///home/pierre/Documents/Projets/catho/module_html_parser
easysqlite3 @ file:///home/pierre/Documents/Projets/catho/easy_sqlite3
parserhtml @ git+https://framagit.org/discord-catho/module_html_parser.git@v1.0.0#egg=parserhtml
parserhtml @ git+https://framagit.org/discord-catho/module_html_parser.git@v1.0.0#egg=parserhtml
easysqlite3 @ git+https://framagit.org/discord-catho/easy_sqlite3.git#egg=easysqlite3
Package: dktotoolkit
Module toolkit (package name : dktotoolkit)This is a module with different tools, very usefull !For exemple, there is :Load .env classParser for datesCompatibility mode for function argumentsTransformer de l'utf8 en HTML et de l'HTML en Markdown principalement....Documentation :Please read the documentation at :https://discord-catho.frama.io/module_toolkitVoir le fichier requirements.txt pour les dépendances, puis "$ make -C docs html" à la racine du projetTag names"v" : for "version"vX.Y.Z : release (any bugs)
** release (X) : major new implementations
** macro-release (Y) : minor implementations, major improvements of features
** micro-release (Z) : bug correction, minor improvements of features (ex : add verbose)vX.Y.ZaN : alpha version (working version)
** Sync on git
** Continous integration
** Not upload on PypivX.Y.ZbN : beta release (must be fixed, or allmost)
** Sync on git
** Continous integration
** Uploaded on PypivX.Y.ZrcN : release candidate (all is fixed)
** Sync on git
** Continous integration
** NOT uploaded on PypivX.Y.ZpostN : post release (correction of doc)
** Sync on git
** Using CI
** Uploaded on PypiTo have more informations, see PEP440 :https://peps.python.org/pep-0440/InstallationInstallation en tant que module à partir des sources :Créer un environnement$ python3.9 -m venv env_module
$ source env_module/bin/activateInstaller le module avec les paquets de base$ pip3 install .Installer le module avec tous les paquets de base$ pip3 install .[doc, test]Installer uniquement les paquets$ pip3 install -r requirements.txtComme submoduleAttention : il est nécessaire d'installer les dépendances également$ cd /path/superprojet
$ mkdir -p scripts/external && cd scripts/external
$ git submodule add git@framagit.org:discord-catho/parserhtml.git
$ git submodule update --recursive --init
$ git submodule update --recursive --remoteTODOsubmodule git pour CI et setupAdd substitution inside .. literalinclude:: ../../dktotoolkit/version.py (setup.rst)Improve tests for parserhtmlload dotenv : if path : check if exists, add argument : raise if not existsTransformer les fonctions de dktotk en sous-modulesFix pipeline, coverageLicenceGNU AGPL 3 (cf LICENCE.md)
Package: dkube-cicd-controller
DKube CICD ControllerCICD controller to automate component building, pipeline deployment to DKube.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.4.7 (2021-06-06)Tekton upgrade. Tekton(v0.24.1), Triggers(v0.14.2), Dashboard(v0.17.0)0.2.4 (2020-10-15)[Dashboard] Support token parameter in query string0.2.3 (2020-10-13)Added upgrade command0.2.2 (2020-10-13)Added authentication for dashboard0.2.1 (2020-10-06)fix for _ character in git repo name0.2.0 (2020-09-28)support IAM role annotation0.1.9 (2020-09-25)fix for dcc build status -i <job id>0.1.8 (2020-09-25)Allow dkube SA to trigger CICD runs0.1.7 (2020-09-21)Added dkube jobs support0.1.5 (2020-09-07)Fix tekton install failure if storageclass annotation is missing. issue #38670.1.0 (2020-07-21)Added manifests. Tekton(v0.14.0), Triggers(0.6.1), Dashboard(0.7.1)
Package: dkv
A distributed key-value in-memory store system with table concept.Project DescriptionDistkvproject is a distributed key-value in-memory database system. Besides these features,Distkvsupports table concept which looks like tables in relational databases. It also supports a rich ecosystem, namedPine, which has many easy-to-use and out-of-the-box components for Web application and micro-service.Full document ishttps://distkv.comAwesome FeaturesRedis-like data structureTable concept based on kv storeStrong consistencyEasy to use clientsStrong ecosystem for Web application and micro-serviceQuick Started1. Install DistKVRunningscripts/install_distkv.shwill install the wholeDistKVto your machine../scripts/install_distkv.shWhen we connect to the server, we must first start the server. At present, we only have two kinds of clients. One isCommand Line Tool, another isJava Client SDK.
We can use either of them to access the Distkv server.2. Start DistKV Server[root@localhost~]# dkv-server3. Start DistKV Cli[root@localhost~]# dkv-cli4. Command Line Tooldkv-cli>str.put"k1""v1"dkv-cli>ok
dkv-cli>str.get"k1"dkv-cli>"v1"dkv-cli>list.put"k1""v1""v2""v3"dkv-cli>ok
dkv-cli>list.get"k1"dkv-cli>["v1","v2","v3"]dkv-cli>set.put"k1""v1""v2""v3"dkv-cli>ok
dkv-cli>set.get"k1"dkv-cli>{"v1","v2","v3"}dkv-cli>dict.put"dict1""k1""v1""k2""v2"dkv-cli>ok
dkv-cli>dict.get"dict1"dkv-cli>{"k1":"v1","k2":"v2"}dkv-cli>slist.put"k1""m1"4"m2"-4"m3"0dkv-cli>ok
dkv-cli>slist.top"k1"2dkv-cli>[("m1",4),("m3",0)]dkv-cli>slist.getMember"k1""m2"dkv-cli>("m2",-4),3rdJava Client SDKJava Client SDK ExampleJava Async Client SDKJava Async Client SDK ExampleGetting InvolvedThank you for your attention to theDistkvproject. If you have any questions, you can create a new issue in ourIssueslist.
We also welcome you to participate in ourDistkvproject, if you want to make contributions, you can refer the fileCONTRIBUTING.md.
Package: dl2sparql
DL2SPARQL: Description Logic Concept to SPARQL QueryInstallationcondacreate-ndl2sparqlpython=3.9--no-default-packages&&condaactivatedl2sparql
pip3installpytest
pip3installpandas
pip3installparsimonious
pip3installrdflib# To test itpytesttestsfromdl2sparqlimportDescriptionLogicConcept,SPARQLQueryce_str="∃hasChild.Male"concept=DescriptionLogicConcept(dl_str="∃hasChild.Male",namespace="http://www.benchmark.org/family#")query=SPARQLQuery(dl_concept=concept)"""SELECTDISTINCT ?x WHERE {?x a <http://www.w3.org/2002/07/owl#NamedIndividual> .?x <http://www.benchmark.org/family#hasChild> ?s_1 .?s_1 a <http://www.benchmark.org/family#Male> .}"""For any questions or wishes, please contact:caglar.demir@upb.deorcaglardemir8@gmail.com
Package: dl4dp
dl4dpdl4dpis a Python NLP library, which provides tools for morphological tagging, lemmatization and dependency parsing.
The main motivation for this library is to provide state-of-the-art tools for Slovak language, but the models can be build
for any language with training data inUniversal Dependencies.InstallationThe library supports Python 3.6 and later.pipThe dl4dp is available onPyPiand can be installed viapip. To install simply
run:pip install dl4dpTo upgrade the previous installation to the newest release, use:pip install dl4dp -UFrom sourceAlternatively, you can also install library from this git repository, which will give you more flexibility and allows
you to start contributing to the dl4dp code. For this option, run:git clone https://github.com/peterbednar/dl4dp.git
cd dl4dp
pip install -e .Getting started with dl4dpThe library provides a command-line interface which allows you to train own model, create pipeline package for production deployment, or parse data. The following command will downloadUniversal Dependenciesarchive and train morphological tagger model on English EWT treebank:python -m dl4dp train tagger -t en_ewtSimilarly, the following command will train a model for dependency parser:python -m dl4dp train parser -t en_ewtSubsequently, you can create and install a pipeline package:python -m dl4dp package install -t en_ewtAfter the installation of the pipeline, it can be used for the parsing of input data in CoNLL-U format:python -m dl4dp parse ~/.dl4dp/treebanks/en_ewt/en_ewt-ud-test.conllu output.conllu -m en_ewt-0.1.0LICENSEdl4dp is released under the MIT License. See theLICENSEfile for more details.
Package: dl4ds
Deep Learning for empirical DownScalingDL4DS(Deep Learning for empirical DownScaling) is a Python package that implements state-of-the-art and novel deep learning algorithms for empirical downscaling of gridded Earth science data.The general architecture ofDL4DSis shown on the image below. A low-resolution gridded dataset can be downscaled, with the help of (an arbitrary number of) auxiliary predictor and static variables, and a high-resolution reference dataset. The mapping between the low- and high-resolution data is learned with either a supervised or a conditional generative adversarial DL model.The training can be done from explicit pairs of high- and low-resolution samples (MOS-style, e.g., high-res observations and low-res numerical weather prediction model output) or only with a HR dataset (PerfectProg-style, e.g., high-res observations or high-res model output).A wide variety of network architectures have been implemented inDL4DS. The main modelling approaches can be combined into many different architectures:Downscaling typeTraining (loss type)Sample typeBackbone sectionUpsampling methodMOS (explicit pairs of HR and LR data)Supervised (non-adversarial)SpatialPlain convolutionalPre-upsampling via interpolationPerfectProg (implicit pairs, only HR data)Conditional AdversarialSpatio-temporalResidualPost-upsampling via sub-pixel convolutionDensePost-upsampling via resize convolutionUnet (PIN, Spatial samples)Post-upsampling via deconvolutionConvnext (Spatial samples)InDL4DS, we implement a channel attention mechanism to exploit inter-channel relationship of features by providing a weight for each channel in order to enhance those that contribute the most to the optimizaiton and learning process. Aditionally, a Localized Convolutional Block (LCB) is located in the output module of the networks inDL4DS. With the LCB we learn location-specific information via a locally connected layer with biases.DL4DSis built on top of Tensorflow/Keras and supports distributed GPU training (data parallelism) thanks to Horovod.API documentationCheck out the API documentationhere.Installationpip install dl4dsExample notebooksA first Colab notebook can be found in the notebooks folder. Click the badge at the top to open the notebook on Google Colab.
Package: dl621
dl621A simple python module and CLI utility to download e621 images with embedded XMP tags and descriptionInstallationThe module requires Exempi, which is only available for Linux and Mac. Hence, this module only works on Linux and Mac.To easily install everything via conda:conda env create-fenvironment.ymlTo manually install just the module (still needs Exempi installed seperately):pip install dl621To manually install Exempi on Debian:sudoapt-getinstall-yexempiUsageThe program can be used as a simple command line program:$ dl621 -h
usage: dl621 [-h] -i ID [-f FOLDER] [-n NAME] [-t] [-j] [-a USERNAME:API_KEY]
             [-u USERAGENT] [-m MEM_LIMIT]

Downloads e621 images with embedded XMP tags and description

optional arguments:
  -h, --help            show this help message and exit
  -i ID, --post_id ID   the ID of the e621 post
  -f FOLDER, --dl_folder FOLDER
                        the folder to download to
  -n NAME, --name_pattern NAME
                        the file name (no extention), Replacements: {m}=md5,
                        {i}=post_id
  -t, --no_tags         don't embedd tags or metadata
  -j, --save_json       saves metadata in a seperate .json file in additon to
                        other options
  -a USERNAME:API_KEY, --authorization USERNAME:API_KEY
                        your e621 username and API key
  -u USERAGENT, --user_agent USERAGENT
                        manual override of the user agent string
  -m MEM_LIMIT, --memory_limit_ratio MEM_LIMIT
                        max percentage of available memory to useIt can also be imported and used in your own scripts (default options shown):import dl621

r = dl621.download_image(post_id, output_folder=".", name_pattern="dl621_{i}_{m}", add_tags=True, save_json=False, use_messages=False, use_warnings=True, custom_json=None, auth=None, download_timeout=5, user_agent="dl621/1.0 (by nimaid on e621)", memory_limit_ratio=0.8)

if r["saved_image"]:
    print("Image downloaded! Location:", r["path_image")
else:
    print("Download failed!")Thedownload_image()function returns a dictionary with the following items:post_exists (bool)post_deleted (bool)post_missing_url (bool)saved_image (bool)saved_tags (bool)saved_json (bool)path_image (string)path_json (string)
Package: dl8.5
Authors:Gaël Aglin, Siegfried Nijssen, Pierre SchausRelevant paper:[DL852020]This project implements an algorithm for inferring optimal binary decision trees.
It is scikit-learn compatible and can be used in combination with scikit-learn.
As a scikit-learn classifier, it implements the methods “fit” and “predict”.This tool can be installed in two ways:download the source from github and install using the commandpython3 setup.py installin the root folderinstall from pip by using the commandpip install dl8.5in the consoleDisclaimer: The compilation of the project has been tested with C++ compilers on the Linux and MacOS operating systems; Windows is not yet supported.[DL852020]Aglin, G., Nijssen, S., Schaus, P. Learning optimal decision trees using caching branch-and-bound search. In AAAI. 2020.
Package: dlabs.py
dlabs.pyA fully asynchronous wrapper for the Discord Labs API.InstallationInstallingdlabs.pyis easy, just runpip install dlabs.py!UsageCurrently, as of Nov 10th 2020 the API provides 2 routes - this package makes use of them, and as soon as new ones are added, the wrapper will be updated simultaneously.Below are some simple example cogs using the API wrapper to automatically post stats to Discord Labs posting manually, and fetching bots! (note thatbotis expected to be your instance of discord.py'scommands.Botorcommands.AutoShardedBot)importdlabsfromdiscord.extimportcommandsclassDiscordLabs(commands.Cog):def__init__(self,bot):self.bot=botself.discord_labs=dlabs.Client(bot,token="YOUR DISCORD LABS TOKEN",autopost=True)defsetup(bot):bot.add_cog(DiscordLabs(bot))And that's it! It's that easy to automatically post stats withdlabs.py. However, if you don't want to autopost the statistics and call the function manually, there's a way too, here's an example -importdlabsfromdiscord.extimportcommandsclassDiscordLabs(commands.Cog):def__init__(self,bot):self.bot=botself.discord_labs=dlabs.Client(bot,token="YOUR DISCORD LABS TOKEN")@commands.command()asyncdefpost_dlabs_stats(self,ctx):awaitself.discord_labs.post_stats()awaitctx.send("Posted the stats to Discord Labs!")defsetup(bot):bot.add_cog(DiscordLabs(bot))Now, there's one more thing you can do, and that is fetching Bot information straight from Discord Labs. Here's an example on how you could do that:importdlabsfromdiscord.extimportcommandsfromdiscordimportEmbedclassDiscordLabs(commands.Cog):def__init__(self,bot):self.bot=botself.discord_labs=dlabs.Client()# Doesn't require authorization!@commands.command()asyncdefcoolbot(self,ctx,id):cool_bot=awaitself.discord_labs.get_bot(id)embed=Embed(color=0xefefef,title=f"{cool_bot.name}is a cool bot!",description=f"It's got{cool_bot.uptime}uptime!")embed.set_thumbnail(url=cool_bot.avatar_url)awaitctx.send(embed=embed)defsetup(bot):bot.add_cog(DiscordLabs(bot))ContributingThis package is opensource so anyone with adequate python experience can contribute to this project!Report IssuesIf you find any error/bug/mistake with the package or in the code feel free to create an issue and report ithere.Fix/Edit ContentIf you want to contribute to this package, fork the repository, make your changes and then simply create a Pull Request!ContactIf you want to contact me -Mail -wulf.developer@gmail.comDiscord -wulf#9716
Package: dlacc
dl_accelerationInstallationBuild from sourcegit clone https://github.com/gnomondigital/dlacc.git
DLACC_HOME = ./dlacc
PYTHONPATH=$DLACC_HOME:${PYTHONPATH}Install via pippip install dlaccPython SDKpython3.9 setup.py sdist bdist_wheel
python3.9 -m twine upload dist/* --verboseFeaturesAutomatic OptimizationBenchmark with various metrics (mean inference time, improvement compare, ..)Output optimized modelsSave tuning logUsageCommand linepython3.9main.py--pathexample1.jsonPython scriptView examples/getting_started.ipynbSupported Targets['aocl', 'hybrid', 'nvptx', 'sdaccel', 'opencl', 'metal', 'hexagon', 'aocl_sw_emu', 'rocm', 'webgpu', 'llvm', 'cuda', 'vulkan', 'ext_dev', 'c']Specifying the correct target can have a huge impact on the performance of the compiled module, as it can take advantage of hardware features available on the target. For more information, please refer to Auto-tuning a convolutional network for x86 CPU. We recommend identifying which CPU you are running, along with optional features, and set the target appropriately. For example, for some processors target = "llvm -mcpu=skylake", or target = "llvm -mcpu=skylake-avx512" for processors with the AVX-512 vector instruction set.Notes:Generally:Use 'cuda' for GPU backend;Use 'llvm' for CPU backend.specify num_measure_trials=20000 for best performance tuning for optimum.run() method call.
Package: dlai-tools
dlai_toolsA set of tools forDeepLearning.AI.UsageInstallpip install dlai_toolsAdd table of contentpython -m dlai_tools.toc Name_of_Notebook.ipynb  [patterns.json templates.json]You can change the style of your table of content by changing the default patterns and templetes. You can pass 2 json files containing the new set of patterns and templates. This will be described properly later.default_patternsdefault_patterns = {
    'section': ['^## [0-9]+ - '], # '- [Part {section_number}: {section_title}](# {section_number})'
    'subsection': ['^### [0-9]+.[0-9]+ '], 
    'exercise': ['^### Exercise [0-9]+'], 
    'toc_title': ['^# Outline']
}dafault_templatedefault_templates = {
    'section': '## {section_number} - {section_title}', 
    'subsection': '### {section_number}.{subsection_number} {subsection_title}', 
    'exercise': '### Exercise {exercise_number}', 
    'toc_title': '# Outline'
}It produces a file called Name_of_Notebook_toc.ipynbCreate learner facing versionpython -m dlai_tools.learner_generator Name_of_Notebook.ipynb [tags.json]It produces a file called Name_of_Notebook_Assignment.ipynbYou can change the style of your table of content by changing the default tags. You can pass a path to a json file containing the new set of tags.defaul_tags =  {
    'tagStartCode': "START CODE HERE",
    'tagEndCode': "END CODE HERE",
	'tagStartOmitBlock': "START OMIT BLOCK",
	'tagEndOmitBlock': "END OMIT BLOCK",
	'tagOmit': "@OMIT",
	'tagKeep': "@KEEP",
	'tagReplaceEquals': "@REPLACE EQUALS",
	'tagReplace': "@REPLACE",
}Testing utilsYou can import from your python code, a set of functions that helps in the testing process.from dlai_tool.testing_utils import *

datatype_check("abc", "csf", "Error")
...