Saravanan666/pypi-org huggingface dataset:
Package: dials-data
DIALS Regression Data ManagerA python package providing data files used for regression tests inDIALS,dxtbx,xia2and related packages.If you want to know more about whatdials-datais you can
have a read through thebackground information.For everything elsethe main documentationis probably the best start.InstallationTo install this package in a normal Python environment, run:pip install dials-dataand then you can use it with:dials.dataIf you are in a conda environment you can instead run:conda install -c conda-forge dials-dataFor more details please take a look at theinstallation and usage page.History2.5 (????-??-??)Fix permission generation when extracting tar archives. Files extracted will be created with
default permissions, instead of what has been packed in with the archive. This solves the issue
of shared data stores becoming inaccessible to some users.DataFetcher: new parameter verify=True to verify download hashinfo by default.2.4 (2022-03-07)dials_data no longer usespy.pathinternally.dials_data now includes type checking with mypy.We started using therequestslibrary for faster downloads.Downloads now happen in parallel.2.3 (2022-01-11)Drop Python 3.6 compatibilityDatasetSSX_CuNiR_processedhas been renamed tocunir_serial_processedfor consistency
withcunir_serial2.2 (2021-06-18)Deprecate the use ofpy.pathas test fixture return type.
You can either silence the warning by specifyingdials_data("dataset",pathlib=False)or move to the newpathlib.Pathreturn objects by settingpathlib=True.
This deprecation is planned to be in place for a considerable amount of time.
In the next major release (3.0) the default return type will becomepathlib.Path,
withpy.pathstill available ifpathlib=Falseis specified. At this point
thepathlib=argument will be deprecated.
In the following minor release (3.1) all support forpy.pathwill be dropped.2.1 (2020-06-11)Drops Python 2.7 compatibilityUses importlib.resources to access resource files (requires Python 3.9 or installed package importlib_resources)2.0 (2019-04-15)Convert dials_data to a pytest plugin1.0 (2019-02-16)Add functions for forward-compatibilityEnable new release process including automatic deployment of updates0.6 (2019-02-15)Added datasets blend_tutorial, thaumatin_i040.5 (2019-01-24)Added documentationAdded datasets fumarase, vmxi_thaumatin0.4 (2019-01-11)Beta releaseAdded datasets insulin, pychefAutomated generation of hashinfo files via Travis0.3 (2019-01-09)Dataset download mechanismAdded dataset x4wide0.2 (2019-01-08)Alpha releaseBasic command line interfacepytest fixture0.1 (2018-11-02)First automatic deployment and release on PyPI
Package: diamant
diamantDocumentation:https://MarkusShepherd.github.io/diamantSource Code:https://github.com/MarkusShepherd/diamantPyPI:https://pypi.org/project/diamant/A Python implementation of the board game Diamant 💎InstallationpipinstalldiamantDevelopmentClone this repositoryRequirements:PoetryPython 3.7+Create a virtual environment and install the dependenciespoetryinstallActivate the virtual environmentpoetryshellTestingpytestDocumentationThe documentation is automatically generated from the content of thedocs directoryand from the docstrings
of the public signatures of the source code. The documentation is updated and published as aGithub project pageautomatically as part each release.ReleasingTrigger theDraft release workflow(pressRun workflow). This will update the changelog & version and create a GitHub release which is inDraftstate.Find the draft release from theGitHub releasesand publish it. When
a release is published, it'll triggerreleaseworkflow which creates PyPI
release and deploys updated documentation.Pre-commitPre-commit hooks run all the auto-formatters (e.g.black,isort), linters (e.g.mypy,flake8), and other quality
checks to make sure the changeset is in good shape before a commit/push happens.You can install the hooks with (runs for each commit):pre-commitinstallOr if you want them to run only for each push:pre-commitinstall-tpre-pushOr if you want e.g. want to run all checks manually for all files:pre-commitrun--all-filesThis project was generated using thewolt-python-package-cookiecuttertemplate.
Package: diambra
diambra CLIQuickstartRun 'diambra agent init' to create a example agent.Run 'diambra run ./agent.py' to bring up DIAMBRA arena and run agent.pyUsageUsage:
  diambra [command]

Available Commands:
  agent       Agent commands
  arena       Arena commands
  completion  Generate the autocompletion script for the specified shell
  help        Help about any command
  run         Runs a command with DIAMBRA arena started

Flags:
  -h, --help                help for diambra
  -d, --log.debug           Enable debug logging
      --log.format string   Set logging output format (logfmt, json, fancy) (default "fancy")
  -v, --version             version for diambra

Use "diambra [command] --help" for more information about a command.
Package: diambra-engine
DIAMBRA™ Arena Engine API ClientThis packages provides a low level API client for the DIAMBRA™ Arena Engine API.Most users will want to use the higher leveldiambra-arenapackage instead.Usageimportdiambra.engineclient=diambra.engine.Client("127.0.0.1:49154")client.Shutdown(diambra.engine.model.Empty())
Package: diameter-codec
Diameter codec - encoder & decodercodec is based on RFChttps://datatracker.ietf.org/doc/html/rfc6733no third party py libs dependenciesvery simple and straightforward to usepython support: >= 3.6How to setup dev envapt install python3.6apt install python3.6-venvsource venv/bin/activatepip install -r requirements.txtpylint src/main/python/codec/diameter/ --ignored-classes=_socketobject *.pyHow to build projectpyb -vpyb -QHow to upload project to test.pypi with twinepython -m twine upload --repository-urlhttps://test.pypi.org/legacy/target/dist/diameter-codec-<x.y.z>/dist/*How to upload project to pypi with twine (production)python -m twine upload target/dist/diameter-codec-<x.y.z>/dist/*How to push git taggit push origin v<x.y.z>How to encode and decode Capabilities-Exchange messageimport os  
import typing    
from codec.diameter.diameter import DiameterHeader, Diameter, Avp  
from codec.diameter.dictionary import DictionaryLayout, DefaultDictionaryLayout	
cer_request: typing.Tuple = (  
  Avp("Product-Name", "hello"),  
  Avp("Origin-Realm", "zte.com.cn"),  
  Avp("Origin-Host", "dmtsrv001.zte.com.cn"),  
  Avp("Host-IP-Address", "192.168.0.1"),  
  Avp("Vendor-Id", 10415),  
  Avp("Product-Name", "dummy-product"),  
  Avp("Inband-Security-Id", 1),  
  Avp("Vendor-Specific-Application-Id", (  
     Avp("Vendor-Id", 10415),  
     Avp("Acct-Application-Id", 1),  
     Avp("Auth-Application-Id", 1),  
  )),  
  Avp("Vendor-Specific-Application-Id", (  
     Avp("Auth-Application-Id", 2),  
     Avp("Acct-Application-Id", 2),  
     Avp("Vendor-Id", 10415),  
  )),  
)
header: DiameterHeader = DiameterHeader(application_id=0, command_code=257, avp_set=cer_request)
xml_dict_path: str = <path to diameter xml file>  
dictionary_layout: DictionaryLayout = DefaultDictionaryLayout(xml_dict_path)  
diameter: Diameter = Diameter(dictionary_layout)
encoded_header: bytes = self.diameter.encode(header) #	send to TCP server     
decoded_header: DiameterHeader = diameter.decode(encoded_header) # decoded on TCP server
Package: diameter-synthesis
Diameter synthesisThis code aims at generating synthetic diameters for neurons, with parameters learned from a set of biological neurons.InstallationUse pip:pipinstalldiameter-synthesisMain usageStep 1: Building modelsIn folderexample, you first have to modifycreate_jsons.pyto suit your needs.You have the following important parameters for the dictextract_models_params:morph_path: path to morphology filesmtypes_sort: how to learn distributions:allto use all together,mtypesto use by mtypes ,super_mtypesto use home made cells types (seediameter_typesbelow)models: to create several models (for now they are all the same, just different realisation of random numbers)neurite_types: types of neurite to learn parameters forextra_params: dict of additional model parametersStep 2: Building diametersThen simply run./run_models.shto create the models (saved in a json file).Increate_jsons.py, the dictgenerate_diameters_paramsneeds to be updated, too, with entries matching the previous dict.
The path innew_morph_pathwill be where the new morphologies will be saved.Then run./run_diamters.shto generate diameters.Additional scriptsSeveral additional scripts in folderscripts:diameter-checks: run the diameter-check code (bluepymm) on the biological and sampled cellsdiameter_types: cluster mtypes using distributions of surface areas (uses two privates repositories a the moment)extract_morphometrics: from bio and sample cells, extracts and plot distribution of surface area and diameter as a function of branch order and path lengthsextract_morphologies: from a cell release, find the ones that can be run through diameter-checkplot_morphologies: plot all morphologies in mtype foldersExamplesTheexamplesfolder contains a simple example that will fetch morphologies fromneuromorpho.org, learn a diameter model, rediametrize these morphologies, and perform some analysis of the results to compare original and diametrized morphologies.
This example can simply be run using the following command:./run.shFunding & AcknowledgmentThe development of this software was supported by funding to the Blue Brain Project, a research center of the École polytechnique fédérale de Lausanne (EPFL), from the Swiss government’s ETH Board of the Swiss Federal Institutes of Technology.For license and authors, seeLICENSE.txtandAUTHORS.mdrespectively.Copyright © 2021-2022 Blue Brain Project/EPFL
Package: diamond4py
diamond4pyThis is python binding fordiamond--a sequence alignment BLAST software implements in C++.
Current base version isdiamond v2.1.0.installfrom source codegitclonehttps://github.com/GCS-ZHN/diamond4py.gitcddiamond4py
condacreate-ndiamond4pypython=3.8# zlib is required by diamond.condainstall-canacondazlib
pipinstall-v.from pypipip install diamond4pyUsagefromdiamond4pyimportDiamond# create a objectdiamond=Diamond(database="database.dmnd",n_threads=4)# make db if you don't create it or just download one from websitesdiamond.makedb("database.fasta")print(diamond.version)# print database statistic infodiamond.dbinfo()# run blast for proteinsdiamond.blastp(query="test_proteins.fasta",out="test_output")Advanced usage.Some parameter options are not implemented in current release,
You could directly use it like this.diamond.blastp(query="test_proteins.fasta",out="test_blastp_output",outfmt=OutFormat.BLAST_TABULAR,sensitivity=Sensitivity.DEFAULT,top=5# `--top` option is not directly definedblock_size=2.0# `--block-size` is not directly defined)and you can global change the tabular output with customed title byOutFormat.BLAST_TABULAR.with_extra_option("qseqid","qstart","qend","qlen","sseqid")# it will change it globally# call this will reset to defaultOutFormat.BLAST_TABULAR.reset()In fact, you can call the original C++ main method like this:from.libdiamondimportmainargs=['bastp','--query','data.fasta','--db','db.dmnd']main(*args)But it is not recommended because the original C++ api lacks necessary
interface encapsulation and parameter checking. At the same time,
it is not pythonic enough, and there is no parameter reminder during programming
unless you read the original parameter document.How to contribThe core of python wrap is to use custom python methods andDiamond._build_optionsto
call thelibdiamond.mainmethod More convenient packaging.
Therefore, anyone can make customized extensions through the
above ideas. I maintains this project after work,
so I cannot make it in time Keep up to date with all
diamond developments. Everyone is welcome to submit PRs.
Package: diamond-art
Diamond ArtWhat is diamond art?Diamond art is a way of creating textured images by attaching small plastic gems to a
canvas. The gems are facetted such that they reflect light, giving the finished product
a glitzy look.Kits are typically sold with a pre-printed canvas covered by a grid of symbols under a
layer of double-stick tape. The symbols indicate which color diamond to adhere. Large
artworks may require adhering thousands of diamonds in dozens of colors.InstallationThe tool can be installed from pypi. It requires python 3.7 or newer.pip install diamond-artAlternately, source can be downloaded fromgithuband installed withpython setup.py installUsageFirst create your image. My 6 year old son created this image of a house using a pixel
editor (scaled up for visibility).This can be converted to a diamond painting using the command line tool:diamond_art examples/house_6yo.png examples/house_6yo_canvas.pngwhich produces this:When printed at 100% scale (approximately 300 dpi by default) the resulting canvas will
fit 2.5mm gems perfectly.LicenseDiamond-art is released under the BSD license.CreditsCreated by Spencer BlivenChangelog0.1.0 (2021-11-21)First release on PyPI.
Package: diamond_ci_exam
Exam Continuous Integration EPSI DevOps 3AAuthors :- Thibault Scorielle 
- Antoine Letailleur
- Dimitri Perreauxpackage on pypi.orgPurpose :The objective of this project is to generate a diamond pattern using letters. The script takes a letter as a parameter and displays a diamond, starting with 'A', where the provided letter marks the widest point of the diamond.Exemple :diamond('A')Adiamond('B')A
B B
 Adiamond('C')A
 B B
C   C
 B B
  AWant to use this project?FORK / CLONErun the project$cddiamond_ci_exam
$pydiamond_ci_exam.py'<your_letter>'#ex : $ py diamond_ci_exam.py 'J'(default parameter : 'F')CREATE and ACTIVATE a VIRTUAL ENVIRONMENTto use poetryInstall venv$py-mpipinstall--uservirtualenvCreate virtual env$pyvenvenvActivate virtual env$.\env\Scripts\activateInstall pipx$python-mpipinstallpipx
$python-mpipxensurepathREADME.md repo pipxInstall poetry$pipxinstallpoetryPOETRY documentationInstall poetry dependencies$poetryinstallRun Linters locally with poetry$poetryrunflake8./diamond_ci_exam/diamond_ci_exam.py
$poetryrunisort./diamond_ci_exam/diamond_ci_exam.py
$poetryrunbandit./diamond_ci_exam/diamond_ci_exam.pyFLAKE8: check PEP8ISORT: check importsBANDIT: find common security issues in Python codeTESTSUnit Tests locallywitout poetry$python-munittestdiscover-stestwith poetry$poetryrunpython-munittestdiscover-stestunittest discover argumentsPUBLISH PACKAGE$poetrypublish--build--username__token__--password<pypiAPItoken>poetry publish arguments/!\ Don't forget to change the version of the package in pyproject.toml when you want to push and to update the package /!\** Project is written with python 3.11 and tested on 3.9, 3.10, 3.11 **
Package: diamond-miner
Diamond-Miner 💎D-Miner is the first Internet-scale system that captures a multipath view of the topology.
By combining and adapting state-of-the-art multipath detection and high speed randomized topology discovery techniques,
D-Miner permits discovery of the Internet’s multipath topology in 2.5 days[^1] when probing at 100kpps.[^2]🚀 Quickstartdiamond-mineris a Python library to build large-scale Internet topology surveys.
It implements the Diamond-Miner algorithm to map load-balanced paths,
but it can also be used to implement other kind of measurements such asYarrp-style traceroutes.To get started, install Diamond-Miner and head over to thedocumentation:# Requires Python 3.10+pipinstalldiamond-minerPublicationDiamond-Miner has been presented and published atNSDI 2020.
Since then, the code has been refactored and separated in thediamond-minerandcaracalrepositories.
The code as it was at the time of the publication is available in thediamond-miner-cppanddiamond-miner-wrapperrepositories.If you use Diamond-Miner, please cite the following paper:@inproceedings{DiamondMiner2020,author={Kevin Vermeulen and Justin P. Rohrer and Robert Beverly and Olivier Fourmaux and Timur Friedman},title={Diamond-Miner: Comprehensive Discovery of the Internet{\textquoteright}s Topology Diamonds },booktitle={17th {USENIX} Symposium on Networked Systems Design and Implementation ({NSDI} 20)},year={2020},isbn={978-1-939133-13-7},address={Santa Clara, CA},pages={479--493},url={https://www.usenix.org/conference/nsdi20/presentation/vermeulen},publisher={{USENIX} Association},month=feb,}AuthorsDiamond-Miner is developed and maintained by theDioptra groupatSorbonne Universitéin Paris, France.
The initial version has been written byKévin Vermeulen, with subsequents refactoring and improvements byMaxime MouchetandMatthieu Gouel.License & DependenciesThis software is released under theMIT license, in accordance with the license of its dependencies.NameLicenseUsagepych-clientMITQuerying the databasepygfcMITGenerating random permutationspython-zstandard3-clause BSDCompression[^1]: As of v0.1.0, diamond-miner can discover the multipath topology in less than a day when probing at 100k pps.
[^2]: Vermeulen, Kevin, et al."Diamond-Miner: Comprehensive Discovery of the Internet's Topology Diamonds."17th USENIX Symposium on Networked Systems Design and Implementation (NSDI 20). 2020.
Package: diamondpack
DiamondPackA simple packager for creating distributable Python applicationsUsed to create distributable applications in the simplest way possible.
Enables Python applications to easily run on systems that don't have Python installed, and without the need for users to know what Python even is.Features:Build Windows and Linux applicationsMinimal configuration neededFast execution, no waiting for libraries to unzipInstall:Default install:pip install diamondpackIf you don't already have a version of CMake installed, in order to use the "app" mode,
install the optional cmake packagepip install diamondpack[app]orpip install cmakeUsage:1. Configure DiamondPack via yourpyproject.toml[project.scripts]# Each script named here will generate a new executablemyScript="examplePackage.myScript:main"[tool.diamondpack]mode="app"Mode can beapporscript:appwill generate a compiled executable (requires CMake and a compiler installed)scriptwill generate a bash (Linux) or batch (Windows) script2. Build your application into a wheelpython -m build --wheelCheck out thetestfolder for an example package and itspyproject.tomlconfiguration3. Run diamondpackpython -m diamondpackor, with a venv activated, simply rundiamondpack4. ProfitYour package will be placed indist/[package-name]-[version]/FAQQ) Do DiamondPack applications work cross-platform?A) While DiamondPack itself is cross-platform, packaged applications are only usable in the OS they were packaged onQ) What is that cool snake doin in that there box?A) His name is Henry and he protects your packages
Package: diamond-patterns
Diamond-Patternsare scaffolds for knowledge work.  Use patterns to go faster.UsageThepatterncommand will apply a pattern to the current directory.The following example applies thearticlepattern:mkdir article
cd article
diamond pattern articleList all available patterns:diamond listRead aboutall the available patterns.View documentation forarticlepattern:diamond docs articleCommand line help:diamond --help
diamond pattern --helpInstallationInstall Diamond-Patterns with Python pip.pip install diamond-patternsInstallation documentationis available online.Online ResourcesDocumentationGitHub Project PagePython Project on PyPi
Package: diamondpy
Diamond.PY (python addon)Diamond is a work-in-progressprogramming languageadd-on/modmade with (and for) Python3. It changes some of the syntax of Python and adds more bulitins and fun features. Here's the basics about it:display()a renamed print() functionprompt()a renamed input() functionstop()a renamed exit() functiondialog()[NEW]like in games and stuffs, you can display text in a dialog-like way (delayed/slowly printed for character by character) using the dialog functiondialog("Hello, World!")nor()[NEW]the nor gate (negated or) gives an output of 1, if both inputs are 0, it gives 1 otherwisenor(a, b)getObjectByENV[NEW]you can set a environment variable (sneaky sneaky!) with this new little thingy. basically equal toos.getenv.the function syntaxstarting simple enough, every function you make, add this little decorator:@function('')be sure to note that you can add a custom name to itthen continue on the next line and add the def statement for your function like you would do normallya basic function may look like this:@function('myfunction')
def something():
  display("hello world!")display colorsthere is a special color system in diamond calleddcolors, which stands for diamond colors or display colors.here is the list of them thus far:HEADER
OKBLUE
OKCYAN
OKGREEN
WARNING
FAIL
ENDC
BOLD
UNDERLINEto use them, add one of your choice in the start of a f""/f'' string like so:lets use the HEADER color, which is like a purple color, as an exampledisplay(f"{dcolors.HEADER}Hello World!{dcolors.ENDC}")be sure to add{dcolors.ENDC}at the end, otherwise you may encounter an error or unwanted resultslogic.[enter logic var here]...an optional way of using the local logic variables (display, prompt, stop, dime/true, nodime/false) is addinglogic.at the start of them. here's an example:logic.display("Hello, World!")
# This will print out 'Hello, World'!not sure why i added this but lets just go with it lolfinal notesome features will be secret, find them out for yourself ;)thanks!this was made by ethan b :)
(founder of a epicwebsite)bugs? errors?there's a reason this is a really small version of the project, of course at the moment, we'll sadly have bugs in the code. later, we will try to fix any funky stuff. sorry about that. :/