Saravanan666/pypi-org huggingface dataset:
Package: plant-pathology
Plant Pathology ClassifierA neural network classifies images of leaves as healthy or diseased!Recently, I've been learning aboutFast.aiandPyTorchin my free time and wanted to apply my knowledge. I'm trying to learn how to win Kaggle competitions, so I decided to build a model for the completed KagglePlant Pathology Competition.I built this model usingNbdev, which provides anliterate programmingenvironment as originally envisioned by Donald Knuth. This means the notebooks in thenbksfolder are the library's "source code". They get converted into regular python files, a fulldocumentation site, and contain unit and functional test, all in one place.Installpip install plant-pathologyHow to useInference examplefrom plant_pathology.pretrained_models import get_model

model = get_model("resnet18_2021-04-08")
prediction = model.predict("images/leaf.jpg")
prediction('rust', tensor(2), tensor([0.0456, 0.0402, 0.8795, 0.0347]))TrainingRun training scriptpython -m plant_pathology.train -h
usage: train.py [-h] [--frz FRZ] [--pre PRE] [--re RE] [--bs BS] [--smooth] [--arch ARCH] [--dump] [--log] [--save] [--mixup MIXUP] [--tta] [--fp16] [--eval_dir EVAL_DIR] [--val_fold VAL_FOLD] [--pseudo PSEUDO] path epochs lr

positional arguments:
  path                 Path to data dir
  epochs               Number of unfrozen epochs
  lr                   Initial learning rate

optional arguments:
  -h, --help           show this help message and exit
  --frz FRZ            Number of frozen epochs (default: 1)
  --pre PRE            Image presize (default: (682, 1024))
  --re RE              Image resize (default: 256)
  --bs BS              Batch size (default: 256)
  --smooth             Label smoothing? (default: False)
  --arch ARCH          Architecture (default: resnet18)
  --dump               Don't train, just print model (default: False)
  --log                Log w/ W&B (default: False)
  --save               Save model based on RocAuc (default: False)
  --mixup MIXUP        Mixup (0.4 is good) (default: 0.0)
  --tta                Test-time augmentation (default: False)
  --fp16               Mixed-precision training (default: False)
  --eval_dir EVAL_DIR  Evaluate model and save results in dir
  --val_fold VAL_FOLD  Don't go cross-validation, just do 1 fold (or pass 9 to train on all data)
  --pseudo PSEUDO      Path to pseudo labels to train onTestingTo run all the tests in the notebooks in parallel, just runnbdev_test_nbsfrom the terminal! :)Web AppI deployed the classifier as a simpleweb appusingStreamlitandHeroku. Note, it may take a few minutes to start up.The code for the app ishere.
Package: plantpathoppi-ml
plantpathoppi_ml predicts protein-protein interaction between plant and pathogen,
based on an ensemble-based machine learning architecture.Input file:The user need to provide pairs of plant and pathogen protein as input. The first and second column should contain plant and pathogen
protein, respecticely.
An example input file can be obtained from the given linkhttps://github.com/snehaiasri/plantpathoppi/blob/main/example.csv.Usage:After installation, perform the following steps to use the packageimport the packageimport plantpathoppi_ml as pppsave the input file as dataframe. Provide the full path of the input file.df = pd.read_csv("example.csv")convert the df into numpy arrayvar = df.to_numpy()call the predict functionx = ppp.predict(var)to call the predict_proba functiony = ppp.predict_proba(var)call gen_file function to generate the output file (output.txt) in your current working directoryppp.gen_file(var)HelpTo see the documentation of each function, use help command. For example, help(plantpathoppi_ml) or help(predict).RequirmentsPython >3.9,
numpy,
pickle-mixin,
sklearn.
Package: plantpredict
# plantpredict-pythonInstalllatest stable versionvia:pip install plantpredict.
- To investigate the latest release, or previous releases:https://github.com/plantpredict/python-sdk/releasesInstalldevelopment versionvia GitHub master branch.—Documentation can be found athttps://plantpredict-python.readthedocs.ioEmailsupport@plantpredict.comto sign-up for important email updates.
Package: plantsim
Python Package for communication with Siemens Tecnomatix Plant SimulationThis package enables the communication with the simulation software product "Tecnomatix Plant Simulation" by
Siemens. It speaks to PlantSim via the COM interface from within Python and includes useful mappings for
some more complex PlantSim data types like tables.Examplefromplantsim.plantsimimportPlantsimfromplantsim.tableimportTableplantsim=Plantsim(version='15.2',license_type='Research')plantsim.load_model('model.spp')plantsim.set_path_context('.Context.In.Your.Model')table=Table(plantsim,'TableName')print(table)SetupRequirementsYou need a working version of Tecnomatix Plant Simulation installed on your system to be able to use this package.System settingsIf you have a NVIDIA 3D graphics card installed, make sure to select it as the default in the "NVIDIA Control Panel".
Otherwise when loading a model into Plant Simulation, you will get an information window that you need to manually
click every time.AcknowledgementsThis repository was created within the Public Research ProjectAlphaMESrun by theChair of Technologies and Management of Digital Transformationwithin theUniversity of Wuppertal.It was funded via a research grant by the German Federal Ministry for Economics and Energy (BMWi).MaintainersThis package is currently maintained by Tilo van Ekeris and Constantin Waubert de Puiseau.DisclaimerTecnomatix, Plant Simulation etc. are brand names of Siemens. This is NOT an official Siemens product.This software is provided "as is" without warranty of any kind. See the LICENSE file for details.Furthermore, this software is currently actively developed and used in research so that there are no guarantees
for stable interfaces etc.CopyrightCopyright (c) 2021 Tilo van Ekeris / TMDT, University of Wuppertal
Distributed under the MIT license, see the accompanying
file LICENSE or https://opensource.org/licenses/MIT
Package: plantuml
###Python-PlantUML[Plantuml](http://plantuml.sourceforge.net/index.html) is a library for
generating UML diagrams from a simple text markup language.This is a simple python remote client interface to a
[plantuml](http://plantuml.sourceforge.net/index.html) server using the
same custom encoding used by most other plantuml
[clients](http://plantuml.sourceforge.net/running.html). Python was
missing from the list, and while there are other plantuml python
libraries, like
[sphinxcontrib-plantuml](https://pypi.python.org/pypi/sphinxcontrib-plantuml),
they require downloading and installing the java executable and spawning
a shell subprocesses.This client defaults to the public [plantuml server](http://www.plantuml.com/plantuml/),
but can be used against any server.###Installpip install git+https://github.com/SamuelMarks/python-plantuml#egg=plantumlPS: At some point this newer version will be uploaded to PyPi, at which point you can do:pip install plantuml###Command line help:usage: plantuml.py [-h] [-o OUT] [-s SERVER] filename [filename …]Generate images from plantuml defined files using plantuml serverpositional arguments:filename              file(s) to generate images fromoptional arguments:-h,--helpshow this help message and exit-oOUT,--outOUTdirectory to put the files into-sSERVER,--serverSERVERserver to generate from, defaults to plantuml.com###Project Links:[Documentation](http://pythonhosted.org/plantuml/)[PyPi](https://pypi.python.org/pypi/plantuml)[GitHub](https://github.com/dougn/python-plantuml/)
Package: plantuml2freemind
plantuml2freemindConverts plantuml mindmaps to FreeMind .mm files (and few other formats).Created especially forTeamlead Roadmapproject, which stores and
maintains a big community-driven roadmap in a mindmap. It's very convenient to have text plantuml as a source
format and generate other required formats from it.Prerequisitespython >= 3.7Installationpip install plantuml2freemindUsageplantuml2freemind --helporpython -m plantuml2freemind --helpConvert example in one command:plantuml2freemind convert examples/small_teamlead_roadmap.puml output.mmContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Local developmentThe project uses poetry as a dependency management tool. For local development convenient way to installing and
running project is usingpoetry install. Please, use>=1.0.0 versionof
poetry even if it is a beta-version.Poetry automatically creates venv (or uses already activated venv) and install all requirements to it and the project
itself aseditable. After installing you can run project as a typical python script
(python plantuml2freemind/cli.py --help) or as python's package entry_point (plantuml2freemind --help)TIP: Usepoetry shellorpoetry runbefore running commands: they activate venv. If you want to connect venv to
your IDE, usepoetry env list --full-pathLicenseMIT
Package: plantuml_connection
###Python-PlantUML[Plantuml](http://plantuml.sourceforge.net/index.html) is a library forgenerating UML diagrams from a simple text markup language.This is a Python 3 simplified implementation. For Python 2 see:1. https://github.com/dougn/python-plantuml1. https://github.com/SamuelMarks/python-plantumlThis is a simple python remote client interface to a[plantuml](http://plantuml.sourceforge.net/index.html) server using thesame custom encoding used by most other plantuml[clients](http://plantuml.sourceforge.net/running.html). Python wasmissing from the list, and while there are other plantuml pythonlibraries, like[sphinxcontrib-plantuml](https://pypi.python.org/pypi/sphinxcontrib-plantuml),they require downloading and installing the java executable and spawninga shell subprocesses.This client defaults to the public [plantuml server](http://www.plantuml.com/plantuml/),but can be used against any server.###Installpip install git+https://github.com/SamuelMarks/python-plantuml#egg=plantumlPS: At some point this newer version will be uploaded to PyPi, at which point you can do:pip install plantumlOr by cloning it locally and running `python setup.py install` or `python setup.py develop` toinstall it on development mode.###Command line help:To quick test it, you can run `python all/plantuml.py test/test.wsd`To see all the command line options run `python all/plantuml.py --help`## Sublime Text DependencyTo use this as a Package Control Dependency https://packagecontrol.io/docs/dependencies createthis `dependencies.json` file on the root of your Package:```json{"*": {"*": ["PlantUmlConnection"]}}```###Project Links:-   [Documentation](http://pythonhosted.org/plantuml/)-   [PyPi](https://pypi.python.org/pypi/plantuml)-   [GitHub](https://github.com/dougn/python-plantuml/)
Package: plantuml-creator
Library to generate plantuml code from python objectsExamplediagram1=Diagram(name="Example 1",opts={DiagramOptName.AUTO_NUMBER:True,DiagramOptName.AUTO_NUMBER_START:1,DiagramOptName.ADD_SEPARATORS:True,DiagramOptName.TITLE:"Example 1",},type_=DiagramType.COMPONENT,objs=[Container(name="c1",objs=[Class(name="i1",type_=ClassType.INTERFACE_LOLLIPOP,shape_attrs={ShapeAttributeName.COLOR:Color.RED.value,}),Component(name="A",shape_attrs={ShapeAttributeName.COLOR:Color.LIGHT_BLUE.value,})]),Container(name="c3",objs=[Container(name=" ",objs=[Component(name="F",shape_attrs={ShapeAttributeName.COLOR:Color.LIGHT_GREEN.value,}),],container_type=ContainerShapeType.CLOUD),],),Container(name="c2",objs=[Class(name="i2",type_=ClassType.INTERFACE_LOLLIPOP),Component(name="B",shape_attrs={ShapeAttributeName.COLOR:Color.LIGHT_CORAL.value,}),Component(name="C",shape_attrs={ShapeAttributeName.COLOR:Color.LIGHT_CORAL.value,}),]),Container(name="c4",objs=[Component(name="D",shape_attrs={ShapeAttributeName.COLOR:Color.LIGHT_CYAN.value,}),Component(name="E",),]),Component(name="BD",shape_attrs={ShapeAttributeName.COLOR:Color.SALMON.value,ShapeAttributeName.CONTAINER_SHAPE_TYPE:ContainerShapeType.DATABASE.value},),Component(name="G",shape_attrs={ShapeAttributeName.COLOR:Color.LIGHT_BLUE.value,},),],relations=[# i1Relation(obj1="i1",rel_type=RelationType.Association,obj2="A",orientation=Orientation.DOWN),# ARelation(obj1="A",rel_type=RelationType.Call,obj2="F",orientation=Orientation.DOWN),Relation(obj1="A",rel_type=RelationType.Association,obj2="i2",orientation=Orientation.RIGHT),# i2Relation(obj1="i2",rel_type=RelationType.Call,obj2="B",orientation=Orientation.RIGHT),# BRelation(obj1="B",rel_type=RelationType.Call,obj2="D",orientation=Orientation.DOWN),Relation(obj1="B",rel_type=RelationType.Call,obj2="C",orientation=Orientation.RIGHT),# CRelation(obj1="C",rel_type=RelationType.Call,obj2="E",orientation=Orientation.DOWN),Relation(obj1="C",rel_type=RelationType.Dependency,obj2="BD",orientation=Orientation.DOWN),# DRelation(obj1="D",rel_type=RelationType.Call,obj2="E",orientation=Orientation.RIGHT),# E# EMPTY# FRelation(obj1="F",rel_type=RelationType.Call,obj2="B",orientation=Orientation.UP),# GRelation(obj1="G",rel_type=RelationType.Dependency,obj2="BD",orientation=Orientation.DOWN),],)plantuml_code,got_errors=diagram.gen_code(CodeGenerator.Context(code_style=style))Generated code:@startuml
title "Example 1"


/' OBJECTS '/
package "c1" {
    interface "i1" as i1 #FF0000
    component "A" as A #ADD8E6
}
package "c3" {
    cloud " " {
    component "F" as F #90EE90
}
}
package "c2" {
    interface "i2" as i2
    component "B" as B #F08080
    component "C" as C #F08080
}
package "c4" {
    component "D" as D #E0FFFF
    component "E" as E 
}
database "BD" as BD #FA8072
component "G" as G #ADD8E6
/' RELATIONS '/
i1 -down- A
A -down-> F
A -right- i2
i2 -right-> B
B -down-> D
B -right-> C
C -down-> E
C -down-> BD
D -right-> E
F -up-> B
G -down-> BD
@endumlRendered img
Package: plantuml-sequence
plantuml-sequenceCreate PlantUML sequence charts programmatically from PythonThe basic example of thePlantUML Documentationcan be implemented with the
following Python script:fromplantuml_sequenceimportDiagramwithopen("my-diagram.puml","w")asfile,Diagram(file)assequence:(sequence.message("Alice","Bob","Authentication Request").message("Bob","Alice","Authentication Response",arrow_style="-->").blank_line().message("Alice","Bob","Another authentication Request").message("Alice","Bob","Another authentication Response",arrow_style="<--"))Its output insidemy-diagram.pumlis:@startuml
Alice -> Bob: Authentication Request
Bob --> Alice: Authentication Response

Alice -> Bob: Another authentication Request
Alice <-- Bob: Another authentication Response
@endumlThis file be compiled to an image using theplantumlcommand-line or a online server. See thePlantUML documentationfor more details.Read the documentation on ReadTheDocs!Installation and supported Python versionspipinstallplantuml-sequencePython 3.10+ is supportedSupported PlantUML featuresNot all of the features of message sequence charts are supported yet. See the list of implemented features below.GeneralUseteozrendererParticipantsDeclaring participantsMultiline participantsCreate participant with messageLifeline activation / deactivationLifeline auto-activateParticipants encompass (Box around participants)Remove foot boxesMessagesMessagesBasicautonumbermessage numberingAdvanced auto numberingautonumberformatsautonumbersequence incrementsHide unlinked participantsMainframeNotesDifferent note shapes (note,hnote,rnote)Notes on messagesNotes over / left / right of lifelinesNotes across all participantsMultiple notes at the same levelFlowBasic message groupingalt/elsegroupsDividerReferenceDelaySpaceStylingColored groupsArrow style changeStandard arrow stylesShort arrowsSlanted arrowsStyling changes using theskinparamcommandPreprocessingCurrently no preprocessing features are planned to be supportedVariable definitionBoolean expressionConditionsWhile loopsProcedures & functions blocksInclude directiveMemory dumpAssertions
Package: plantweb
Plantweb is a project that provides a command line interface, Sphinx directives
and an API that allows to render powerful plain text UML diagrams, ASCII
diagrams and complex graphs.It is a Python client for thePlantUMLserver and thus it can renderPlantUML,GraphvizandDitaadiagrams without the need to install them.Plantweb features a local cache that prevents requesting the server for
previously rendered diagrams, speeding up building documentation with lots of
diagrams.Finally, being pure Python, non-local rendering, Plantweb is an excellent way
to display and renderPlantUML,GraphvizandDitaadiagrams inReadTheDocspublished documentation.Documentationhttps://plantweb.readthedocs.io/Changelog1.1.0 (Jul 11, 2017)NewAdded documentation on how to run a PlantUML docker container to simplify
deployment.FixesFix #9 passing source files to the Sphinx directive as an absolute path.Fix #7 source files passed as argument to the Sphinx directive failed to
render correctly.Fixed test suite to be compatible with newer versions of Sphinx.Fixed several PEP8 violations.ChangesImproved algorithm to gather configuration for a git repository root.Test suite now test Python 3 with Python 3.5 instead of Python 3.4.1.0.1 (Mar 20, 2017)FixesFix #1 that caused diagrams rendering to fail with a 404 in Windows OSes.1.0.0 (Jun 27, 2016)NewSphinx directives now support passing a source file as argument.0.4.0 (Jun 23, 2016)NewAdded a set of Sphinx directivesuml,graphanddiagram.0.3.0 (Jun 22, 2016)NewDefault options can now be overriden with a.plantwebrcfile in the user
home or in the git repository root.0.2.0 (Jun 22, 2016)FixesFixed bug when callingrender_cachethat returned a non-tuple.ChangesDocumentation was greatly improved.0.1.0 (Jun 9, 2016)NewInitial public release.LicenseCopyright (C) 2016-2017 Carlos Jenkins

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
Package: plaquette
plaquetteis a fully featured and easy-to-use library for studying quantum
error correction and fault tolerance.The library features numerous quantum error correction codes, hardware-relevant
error models and versatile decoders that can be used together seamlessly,
and it is tailored to  accommodate both newcomers and experienced users alike!WARNING: we are in the process of fully making this tool public, so expect
rough corners in the meantime! This is also why currently the project is
marked as “alpha” in the version specifier. Stay tuned. :)Installationplaquetteis a pure Python package, so it can be easily installed viapip:pip install plaquette --pre--preis necessary while the only available release ofplaquetteis
marked as alpha. We will drop this requirement soon!DocumentationLive pre-compiled documentation is availablehere.Alternatively, the documentation can be built from themasterbranch by:make -C docs clean htmland the build files will be available in thedocs/_build/htmldirectory.Need help? Want to contribute?plaquetteis under heavy development, so it might have some rough corners that need
polishing. If you encounter something you think (or the docs say) should work but does
not, just open anissueor, if you also want to share a solution, apull request! See
ourdevelopment standardto
have an idea of how to match your suggestions to the codebase.Want to simply share feedback or you’re unsure how to do something? Open a newdiscussion!Supportersplaquetteis developed and maintained byQC Design.plaquetteis also supported by the German Ministry of Education and Research
(BMBF) via projectPhotonQ. An early prototype ofplaquettewas developed under the support of the BMBF projectPhoQuant.
Package: plaquette-graph
Table of ContentsAboutInstallationUsagePython FrontendC++ BackendAboutTheplaquette-graphplugin extends thePlaquetteerror correction software, providing a fast graph library written in C++.InstallationThe C++ tests/examples and python bindings can be built independently bycmake -Bbuild -G Ninja -DPLAQUETTE_GRAPH_BUILD_TESTS=On -DPLAQUETTE_GRAPH_BUILD_BINDINGS=On
cmake --build ./buildYou can run the C++ backend tests withmake test-cppYou can install just the python interface with (this quietly builds the C++ backend):pip install -r requirements.txt
pip install .or get the latest stable release from PyPIpip install plaquette_graphYou can run the python frontend tests withmake test-pythonTo generate the documentation you will need to install graphviz and doxygen. Then runpip install -r doc/requirements.txt
make docs
firefox ./doc/_build/html/index.htmlUsageThe primary graph class is SparseGraph, an undirected immutable graph structure stored in CSR format for extremely fast lookup of neighbouring vertices and edges. See the documentation for other types of graphs we support.Python Frontendimportplaquette_graphaspgedges=[(0,1),(0,2),(1,2)]num_vertices=3graph=pg.SparseGraph(num_vertices,edges)C++ Backend#include"SparseGraph.hpp"intmain(intargc,char*argv[]){usingnamespacePlaquette;std::vector<std::pair<size_t,size_t>>edges={{0,1},{0,2},{1,2}};size_tnum_vertices=3;autograph=SparseGraph(num_vertices,edges);}
Package: plaquette-ibm-backend
plaquette-ibm-backendis an easy-to-install plugin that allows using IBM Quantum
remote systems and simulators withplaquette.Installationplaquette-ibm-backendis a pure Python package, so it can be easily installed viapip:pip install plaquette-ibm-backendExampleFirst, authenticate to IBM Quantum by providing a token. This can be done for
example viafromqiskit_ibm_providerimportIBMProviderIBMProvider.save_account("<Your token>")NoteTo specify a custom hub/group/project, theinstanceargument can be
passed tosave_account.For further ways of authentication refer to the IBM Quantum and Qiskit documentation.Once the account has been saved, a quantum circuit generated from a code in
plaquette can be run easily on a remote simulator provided by IBM by specifying
the"ibm"backend and the name of an IBM system:importplaquettefromplaquette.circuitimportCircuitfromplaquette.codesimportCodefromplaquette.errorsimportQubitErrorsDictfromplaquette.circuit.generatorimportgenerate_qec_circuit# Select a code we'd like to simulatecode=Code.make_repetition(distance=3)# Generate the quantum circuit of the codelogical_operator="X"circuit=generate_qec_circuit(code,{},{},logical_operator,n_rounds=1)# Select an IBM Quantum system or simulator by specifying its name during# device creationsystem_name="ibm_kyoto"dev=plaquette.Device("ibm",system_name=system_name)dev.run(circuit)samples,_=dev.get_sample()>>>samplesarray([0, 0, 1, 0, 1, 0, 1, 0, 1, 1], dtype=uint8)ImportantNotallcircuits supported byplaquettecan be run on IBM Quantum
systems and simulators, as someplaquetteinstructions cannot be
converted toOpenQASM 3.0(e.g., any circuit with “error instructions”
cannot be converted). When creating aplaquettedevice with an IBM
backend, the plugin will leave unsupported instructions out of the circuit
during conversion toOpenQASM.Need help? Want to contribute?plaquette-ibmis under heavy development, so it might have some rough corners that need
polishing. If you encounter something you think (or the docs say) should work but does
not, just open anissueor, if you also want to share a solution, apull request! See
ourdevelopment standardto
have an idea of how to match your suggestions to the codebase.Want to simply share feedback or you’re unsure how to do something? Open a newdiscussion!