Saravanan666/pypi-org huggingface dataset:
Package: prolintpy
A python package for the automated analysis and visualization of lipid-protein interactions.prolintpy is a lightweight python library that is used by the ProLint webserver on the backend to analyzeProtein-Lipidinteractions.. Use this tool if you want to customize analysis and visualization of lipid-protein interactions and want to scale-up your workflow beyond the capabilities of theProLint webserver.To get familiar withprolintpyplease read theDocumentation. You can also launch the binders:and testprolintpywithout having to install it.
We provide several tutorials in the form of these binders that you can complete in your browser. Please note, however, that these tutorials are still work in progres and we will improve them during the coming days. If you would like to download the tutorials they are located here:https://github.com/ProLint/tutorialsInstallationTo installprolintpysimply execute:# Python v3.6 or v3.7 supported. Python v3.8 may not work.python-mpipinstallprolintpyThis should work on most systems.
If you encounter problems during installation, use one of the more verbose methods below:# Method 1gitclonehttps://github.com/ProLint/prolintpy.gitcdprolintpy
condaenvcreate-fenvironment.yml
condaactivateprolint# Method 2gitclonehttps://github.com/ProLint/prolintpy.gitcdprolintpy
pythonsetup.pyinstall# Method 3 (if MDTraj causes problems)condacreate--nameprolintpython=3.7
condaactivateprolint
condainstall-cconda-forgemdtraj
python-mpipinstallprolintpyGetting StartedTo importprolintpyin your code:# To improve performance of visualization apps, we load everything at once# so initial import may take a few seconds to finish.importprolintpyasplPlease follow the instructions provided in thedocumentationto get started. Note that, to use the visualization interface of prolintpy,
you should use JupyterLab. At the top of your notebook file, make sure to call theoutput_notebookfunction:frombokeh.ioimportoutput_notebookoutput_notebook()Additionally, if you want to use theshow_contact_projectionfunction, make sure that your installation ofnglviewis working properly.
Follow the instruction providedthereto ensure your installation is running correclty.Input file requirementsBefore you load the data to prolintpy make sure to first remove water & ions beads. Leave only membrane and protein beads in the system.Citationprolintpy is research software. If you make use of it in work which you publish, please cite it. The BibTeX reference is@article{10.1093/nar/gkab409,
    author = {Sejdiu, Besian I and Tieleman, D Peter},
    title = "{ProLint: a web-based framework for the automated data analysis and visualization of lipid–protein interactions}",
    journal = {Nucleic Acids Research},
    year = {2021},
    month = {05},
    issn = {0305-1048},
    doi = {10.1093/nar/gkab409},
    url = {https://doi.org/10.1093/nar/gkab409},
    note = {gkab409},
    eprint = {https://academic.oup.com/nar/advance-article-pdf/doi/10.1093/nar/gkab409/38270894/gkab409.pdf},
}
Package: proliphix
Proliphix Thermostat ControlPython Boilerplate contains all the boilerplate you need to create a Python package.Free software: Apache 2Documentation:https://proliphix.readthedocs.org.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.5.0 (2018-01-12)Add support for humidityInclude site name in returned device name0.4.1 (2016-11-18)Fix bug with time setting during standard time0.4.0 (2016-10-13)Fix bug with setting setbacks0.1.0 (2016-01-13)First release on PyPI.
Package: proloaf
Website|Docs|Install Guide|TutorialProLoaF is a probabilistic load forecasting project.DescriptionProLoaF makes use of the big data paradigm that allows machine learning algorithms, trained with data from the power system field. The core comprises a recurrent neural network (encoder-decoder architecture) to predict the target variable.The targets can vary from timerseries of PV, Wind or other generators to most commonly the total energy consumption.
Both, the relevant input data history and prediction horizon are arbitrarily long and customizable for any specific need.InstallationFirst, clone this Repository and initialize the submodules:gitclone--recurse-submodulehttps://git.rwth-aachen.de/acs/public/automation/plf/proloaf.gitor if you have already cloned the project and you are missing e.g. the open data directory for execution run:gitsubmoduleupdate--init--recursiveTo install all required packages first run:pipinstall-rrequirements.txtOn low RAM machines the optionpipinstall-rrequirements.txt--no-cache-dirmight be necessary.ProLoaF supports Python 3.8 and higher. For further information seeGetting StartedGettings started, Key Capabilities, Example Workflows & ReferencesTo keep all infos on what you can do with ProLoaF and how to get there, ouruser documentation, is the place where you'll find all answers.Related PublicationsWe kindly ask all academic publications employing components of ProLoaF to cite one of the following papers:G. GÃ¼rses-Tran, H. Flamme, and A. Monti, "Probabilistic Load Forecasting for Day-Ahead Congestion Mitigation," The 16th International Conference on Probabilistic Methods Applied to Power Systems, PMAPS 2020, 2020-08-18 - 2020-08-21, LiÃ¨ge, Belgium, ISBN 978-1-7281-2822-1, [Access Online](Probabilistic Load Forecasting for Day-Ahead Congestion Mitigation)Copyright2019-2021, Institute for Automation of Complex Power Systems, EONERCLicenseThis project is licensed to theApache Software Foundation (ASF).This program is free software: you can redistribute it and/or modify
it under the terms of the Apache License version 2 of the License, or
any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
Apache License for more details.

You should have received a copy of the Apache License
along with this program.  If not, see <http://www.apache.org/licenses/LICENSE-2.>.For other licensing options please consultProf. Antonello Monti.ContactGonca GÃ¼rses-Trangguerses@eonerc.rwth-aachen.deFlorian Oppermannflorian.oppermann@eonerc.rwth-aachen.deInstitute for Automation of Complex Power Systems (ACS)EON Energy Research Center (EONERC)RWTH University Aachen, Germany
Package: prologterms
prologterms - a python library for constructing prolog termsExample:from prologterms import TermGenerator, PrologRenderer, Var

X = Var('X')
P = TermGenerator()
term = P.member(X, [1, 2, 3])
r = PrologRenderer()
print(r.render(term))writes:member(X, [1, 2, 3])All prolog escaping conventions are handled automatically.See theJupyter notebookRulesThe “<=” operator in python is overloaded to mean the same as prolog
“:-”. This means a rule object can be created as follows:P.ancestor(X,Y) <= (P.parent(X,Z), P.ancestor(Z,Y))This can be done more explicitly using a Rule constructor:from prologterms import TermGenerator, PrologRenderer, Var, Rule

X = Var('X')
Y = Var('Y')
Z = Var('Z')
P = TermGenerator()
rule = Rule(P.ancestor(X,Y), (P.parent(X,Z), P.ancestor(Z,Y))UsageThis module is of little use by itself. It is intended to be used to
generate prolog programs that can be fed into a prolog execution
engine.write prolog programs and queries to a file, and load these using an engine like swi-prologthrough web services, e.g. via penginesPengines[Note: requires latest pengines which may not be on pypi]One of the intended applications is penginesfrom pengines.Builder import PengineBuilder
from pengines.Pengine import Pengine
from prologterms import TermGenerator, PrologRenderer, Program, Var

P = TermGenerator()
X = Var('X')
Y = Var('Y')
Z = Var('Z')
R = PrologRenderer()

p = Program(
    P.ancestor(X,Y) <= (P.parent(X,Z), P.ancestor(Z,Y)),
    P.ancestor(X,Y) <= P.parent(X,Y),
    P.parent('a','b'),
    P.parent('b','c'),
    P.parent('c','d')
)

q = P.ancestor(X,Y)

factory = PengineBuilder(urlserver="http://localhost:4242",
                         srctext=R.render(p),
                         ask=R.render(q))
pengine = Pengine(builder=factory, debug=True)
while pengine.currentQuery.hasMore:
    pengine.doNext(pengine.currentQuery)
for p in pengine.currentQuery.availProofs:
    print('{} <- {}'.format(p[X.name], p[Y.name]))
Package: prologue
ProloguePrologue is an extensible text preprocessor written in Python. It performs evaluation in a continuous stream, which allows it to run fast and keep a minimal memory footprint with few open file handles.Directives can be easily added and removed to customise the behaviour of the preprocessor. By default the following directives are supported:define/undef- allows constants to be declared and undeclaredif/elif/else/endif- conditional inclusion of blocks of text/other preprocessor directivesifdef/ifndef/else/endif- test whether constants are defined or undefinedfor/endfor- repeat a block of text for a number of iterations, can also iterate through an arrayinfo/warning/error- print messages to a log, or raise an exception, from a directiveinclude/import- allows other files to be included or imported (one time include) into the streamInstallationThe easiest way to install Prologue is to use PyPI:$> python3 -m pip install prologueAlternatively, you can install the latest version directly from this repository:$> python3 -m pip install git+git://github.com/Intuity/prologueExampleInput#define MY_VAL 123#undef MY_VAL#define MY_VAL 256intmain(){#if MY_VAL > 200printf("Big value\n");#elseprintf("Small value\n");#endif}ScriptfromprologueimportProloguepro=Prologue()pro.add_file("path/to/main.c")forlineinpro.evaluate("main.c"):print(line)Outputintmain(){printf("Big value\n");}ExamplesA number of examples are available in theexamplesfolder:demo- is a demonstration of many features of Prologue, including loops, conditionals, include and import.c_style- demonstrates how Prologue can be setup to act like GCC's preprocessor.verilog- demonstrates how Prologue can be setup to act like a Verilog/SystemVerilog preprocessor.Running TestsPrologue comes with a suite of tests, which usepytestfor regression:$>gitclonegit@github.com:Intuity/prologue
$>cdprologue
$>python3setup.pytestStill To DoSome features that still need to be implemented are:Support for C-style substitution delimiters to provide separation - for exampleNUMBER_##A_CONST##_IS_THE_BESTSupport for macro functions with nested support - for example#define SUM(A, B) A + B
Package: prolothar-common
Prolothar-CommonCommon functionality for our ProLothar projects, which contain algorithms
for process mining and event sequence analysis tasks.Visithttps://github.com/shs-it?q=prolotharto get a list of the ProLothar repositories.UsageIf you want to use this library, read the following instructions.PrerequisitesPython 3.11+Depending on your system: C++ Compiler for compiling Cython codeInstallingpipinstallprolothar-commonDevelopmentThese instructions will get you a copy of the project up and running on your local machine for development and testing purposes.Additional Prerequisitesmake (optional)Running the testsmaketestDeploymentmakeclean_package||makepackage&&makepublishVersioningWe useSemVerfor versioning.Given a version number MAJOR.MINOR.PATCH, increment the:MAJOR version when you make incompatible API changesMINOR version when you add functionality in a backward compatible mannerPATCH version when you make backward compatible bug fixesAuthorsBoris Wiegand-boris.wiegand@stahl-holding-saar.de
Package: prolothar-process-discovery
Prolothar Process DiscoveryAlgorithms to discover process behavior from data mining on sequential data such as process logs.Based on the publicationBoris Wiegand, Dietrich Klakow, and Jilles Vreeken.Mining easily understandable models from complex event logs.In:Proceedings of the SIAM International Conference on Data Mining (SDM), Virtual Event.2021, pp. 244-252.PrerequisitesPython 3.11+UsageIf you want to run the algorithms on your own data, follow the steps below.Installingpipinstallprolothar-process-discoveryCreating or reading an EventLogOption 1: you can create an EventLog from a pandas dataframe# 1) there must be a header line# 2) each line belongs to one event# 3) there is one column containing the case ID# 4) there is one column containing the activity name of the event# 5) there can be columns for trace and event attributesimportpandasaspdeventlog=EventLog.create_from_pandas_df(pd.read_csv('path/to/eventlog.csv',delimiter=','),'CaseId','Activity',trace_attribute_columns=['Customer'],event_attribute_columns=['Duration'])Option 2: you can create an EventLog from .xes with the help of the pm4py packagefrompm4py.objects.log.importer.xesimportimporterasxes_import_factoryimportprolothar_common.pm4py_utilsaspm4py_utilsxes=xes_import_factory.apply('path/to/eventlog.xes.gz')eventlog=pm4py_utils.convert_pm4py_log(xes)Option 3: you can create an EventLog manuallyfromprolothar_common.models.eventlogimportEventLog,Trace,Eventeventlog=EventLog()#case ID (0 in the example) can be any hashable type, e.g. int or string. must be unique.eventlog.add_trace(Trace(0,[Event('start computer',attributes={'user':'alice'}),Event('drink coffee',attributes={'milk':'yes','grams_of_sugar':5}),]))Discovering a PatternGraphfromprolothar_process_discovery.discoveryimportProseqofromprolothar_process_discovery.discoveryimportProSimpledirectly_follows_graph=PatternGraph.create_from_event_log(eventlog)pattern_graph=Proseqo().mine_dfg(eventlog,directly_follows_graph,verbose=True)pattern_graph.plot()pattern_graph=ProSimple().mine_dfg(eventlog,directly_follows_graph,verbose=True)# we can also plot to a filepattern_graph.plot(filepath='path/to/your/file',filetype:str='pdf',view=False)DevelopmentThese instructions will get you a copy of the project up and running on your local machine for development and testing purposes.Additional Prerequisitesmake (optional)Running the testsmaketestDeploymentmakeclean_package||makepackage&&makepublishVersioningWe useSemVerfor versioning.AuthorsIf you have any questions, feel free to ask one of our authors:Boris Wiegand-boris.wiegand@stahl-holding-saar.de
Package: prolothar-rule-mining
Prolothar Rule MiningAlgorithms to learn classification and event sequence prediction rules for event sequence datasets such as process logs.Based on the publicationBoris Wiegand, Dietrich Klakow, and Jilles Vreeken.Discovering Interpretable Data-to-Sequence Generators.In:Proceedings of the 36th AAAI Conference on Artificial Intelligence (AAAI), Virtual Event.2022, pp. 4237â€“4244.PrerequisitesPython 3.11+UsageIf you want to run the algorithms on your own data, follow the steps below.Installingpipinstallprolothar-rule-miningCreating or reading a dataset of sequences with metadataYou can create datasets manually byfromprolothar_common.models.datasetimportTargetSequenceDatasetfromprolothar_common.models.dataset.instanceimportTargetSequenceInstance#define a list of categorical variables and a list of numeric variablesdataset=TargetSequenceDataset(['color'],['size'])# add instances, where each instance has three parts:# 1. a unique hashable ID (e.g. of type int or str)# 2. a dictionary with attribute names and attribute values# 3. a (potentially empty) list or tuple of events of type strdataset.add_instance(TargetSequenceInstance(1,{'color':'red','size':100},[]))dataset.add_instance(TargetSequenceInstance(2,{'color':'blue','size':42},['A','B']))Alternatively, you can read a dataset from an .arff file:fromprolothar_common.models.datasetimportTargetSequenceDatasetwithopen('dataset.arff','r')asf:dataset=TargetSequenceDataset.create_from_arff(f.read(),'sequence')Exemplary .arff file:@RELATION "TestDataset"

@ATTRIBUTE "color" {"blue","red"}
@ATTRIBUTE "size" NUMERIC
@ATTRIBUTE "sequence" {"[]","[A,B]"}

@DATA
"red",100,"[]"
"blue",42,"[A,B]"Discovering an Event-flow Graph Using ConSequencefromprolothar_rule_mining.rule_miner.data_to_sequence.consequenceimportConSequenceconsequence=ConSequence()rules_model=consequence.mine_rules(dataset)#make predictionsforinstanceindataset:print('=================')print(instance.get_target_sequence())print(rules_model.execute(instance))#get and print the event flow graphgraph=rules_model.get_event_flow_graph()graph.plot()graph.plot(view=False,filepath='path_to_pdf')#get and print the classification rule at each nodefornode,routerinrules_model.get_node_router_table().items():print('===============================')print(f'rule at node{node}')print(node.get_rule())# alternative: print(node.get_rule().to_html())DevelopmentThese instructions will get you a copy of the project up and running on your local machine for development and testing purposes.Additional Prerequisitesmake (optional)Compile Cython codemakecythonRunning the testsmaketestDeploymentmakeclean_package||makepackage&&makepublishVersioningWe useSemVerfor versioning.AuthorsIf you have any questions, feel free to ask one of our authors:Boris Wiegand-boris.wiegand@stahl-holding-saar.de
Package: proMAD
proMADSemiquantitative densitometric measurement of protein microarraysSetuppip install proMADYou can also install the latest version directly from GitHub.pip install -U git+https://github.com/theia-dev/proMAD.git#egg=proMADUsageArrayAnalysefromproMADimportArrayAnalyseaa=ArrayAnalyse('ARY022B')# set array typeaa.load_collection('tests/cases/prepared',rotation=90)# set input folderaa.evaluate("A6")# get result dictionaryaa.get_spot("A6")# get underlying image dataaa.evaluate()# get result dictionary for all spotsaa.report('report.xlsx')# export the resultsCutterinteractivefromproMADimportCutterc=Cutter()c.load_collection('tests/cases/raw')# set input folderc.set_shape()# ask for the shapec.guess_positions()# use a simple guess as a starting pointc.preview()# display guess (uses the last loaded image as default)c.set_positions()# ask for refined cut positionsc.set_names()# ask for namesc.preview()# check in the previewc.save_images('test/cases/formatted_image_folder')# save to folder (will be created if it does not exist)directfromproMADimportCutterc=Cutter()c.load_collection('tests/cases/raw')# set input folderc.shape=(2,3)c.cut_positions=[[20,225,445],[40,130,217,315]]c.names=[['OL','ML','UL'],[None,'MR','UR']]c.preview()c.save_images('test/cases/formatted_image_folder')# save to folder (will be created if it does not exist)CitationIf you use proMAD in your work please cite the followingarticle.Jaeschke, A., Eckert, H. & Bray, L.J.
proMAD: semiquantitative densitometric measurement of protein microarrays.BMC Bioinformatics21, 72 (2020).
doi:10.1186/s12859-020-3402-4The full source code can be accessed onGitHubwith the corresponding documentation hosted atRead the docs.
Package: promail
PromailPromail along with its sister library Promail-Templates aims
to close the email gap between what you as an individual can make your
email do with little effort and what enterprise users doAutomated Professional Rich content HTML emailsAllow you to write your own pluggins that do arbitrary things depending on the content of the email.Installationpip install promailSimple Usagefrompromail.clients.gmailimportGmailClientclient=GmailClient("your-gmail@gmail.com")# The first time you do this it will open a web browser allowing you to sign into your google account directlyclient.send_email()
Package: promalyze
Promalyze===The library to get data out of Prometheus to analyze.# Install```pythonpip install promalyze```# Usage```pythonfrom promalyze import Clientclient = Client('http://localhost:9090')ts_data = client.range_query('go_gc_duration_seconds') # returns PrometheusData objectts = ts_data.timeseries[0] # returns a TimeSeries objectjson_data = ts.as_json()dataframe = ts.as_pandas_dataframe()```
Package: proman-versioning
Proman VersioningOverviewProject Manager Versioning is a PEP-440 compliant tool for automating project
versions using conventional commits.Installpip install proman-versioningSetupThis tool is designed to work with any textfile using a templating pattern and
path to the file.Configuring versionsConfiguration can be performed with either the.versioningorpyproject.tomlfiles.Global configuration settings:Specific types of releases can be disabled by setting the respective release to
false.Disable development releases:enable_devreleases = falseDisable pre-releases:enable_prereleases = falseDisable post-releases:enable_postreleases = falseFile specific settings:Use different version compatibiliy type:compat = "semver"Update only the release version for a configuration:release_only = trueExample.versioningThe.versioningconfig is a non-specfile based project file using TOML. This is the
preferred configuration for non-python projects that may use this tool.[proman]
version = "1.2.3"

[proman.versioning]
disable_devreleases = true

[[proman.versioning.files]]
filepath = "pyproject.toml"
pattern = "version = \"${version}\""

[[proman.versioning.files]]
filepath = "example/__init__.py"
pattern = "__version__ = '${version}'"

[[tool.proman.versioning.files]]
filepath = "chart/Chart.yaml"
compat = "semver"
patterns = [
  "version = \"${version}\"",
  "appVersion = \"${version}\""
]Examplepyproject.toml[tool.proman]
version = "1.2.3"

[tool.proman.versioning]

[[tool.proman.versioning.files]]
filepath = "pyproject.toml"
pattern = "version = \"${version}\""

[[tool.proman.versioning.files]]
filepath = "example/__init__.py"
pattern = "__version__ = '${version}'"

[[tool.proman.versioning.files]]
filepath = "chart/Chart.yaml"
compat = "semver"
patterns = [
  "version = \"${version}\"",
  "appVersion = \"${version}\""
]Examplesetup.cfgSetuptools allowssetup.cfgto pull the version from the application. This
should be used in tandem with either of the above configurations to control
versions for a project.[metadata]
name = example
version = attr: src.VERSION
...Referenceshttps://www.conventionalcommits.org/en/v1.0.0/https://www.python.org/dev/peps/pep-0440/https://semver.orghttps://calver.org
Package: proman-workflows
proman-workflowsOverviewThis project is a task runner to help automate common development tasks for
projects using Python.The goal of this effort is help implement DevSecOps practices consistly with
the Software Development Lifecycle (SDLC) without burdening developers.The objectives for achieving this goal are:Enforce use of commit signingIntroduce QA tools early in developmentSAST, SCA, and DAST integrationEncapulate processes for seamless integration with CI/CD systemsMake TUF compliant packages for PyPIInstallThe project can be installed using the following command:pip install proman-workflowsThe above will only install the workflows but not all dependencies. The
additional dependencies can be install with:pip install proman-workflow[all]UsageCurrently, there are three command line utilities included with this install.
This is due to the primary CLI tool being under heavy development.Theworkflow-toolscommand provides direct access to each of integrations
provided by the task runner. It can either be used directory or extended as
a library for additional workflows.Theworkflow-setupcommandTheworkflowcommand is the intended CLI for the task runner but is still
under development. It will allow control of integrated tools through abstracted
phases accessible to a developer. The functionality is still imited at this time.SetupSetup a signing key for development:workflow-tools setupFAQQ: Why should developers use this?
A: Coodinating procedures and setup for multiple team members and projects is difficult and error
prone. Task runners are purpose built to solve this problem.Q: Why not include this using project templates?
A: Since this is distributed as a library updates and changes can be much more easilly distributed.Q: Why not use Invocations
A: While this project is inspired by Invocations, it does not support a pluggable architecture.Refereceshttps://theupdateframework.io/https://csrc.nist.gov/Projects/ssdf
Package: promap
promapis a command-line tool that you can use
in conjunction with your digital video workflow
to do projection mapping.promapuses a projector and a single camera
to compute the physical scene as viewed from the projector,
as well as a coarse disparity (depth) map.You can import the maps that it generates straight into yourdigital video workflow,
or you can post-process them into masks and uvmaps first using image processing tools.