Saravanan666/pypi-org huggingface dataset:
Package: pyGrad2Surf
pyGrad2Surf===========Software that effectively integrates two vector fields to obtain a scalar field. Example usage can be seen at [cthulhu](https://github.com/cjordan/cthulhu). This repo merely reflects a python translation of the MATLAB code supplied by Harker & O'Leary: [paper](https://arxiv.org/abs/1308.4292) and [code](http://www.mathworks.com/matlabcentral/fileexchange/43149-surface-reconstruction-from-gradient-fields--grad2surf-version-1-0).Usage-----An excerpt from [cthulhu](https://github.com/cjordan/cthulhu):grid_x, grid_y = np.meshgrid(np.linspace(-self.radius, self.radius, resolution),np.linspace(-self.radius, self.radius, resolution))self.grid_dra = np.flipud(np.fliplr(griddata(np.vstack((ra, dec)).T, ra_shifts,(grid_x, grid_y), method=interp_method, fill_value=0)))self.grid_ddec = np.flipud(np.fliplr(griddata(np.vstack((ra, dec)).T, dec_shifts,(grid_x, grid_y), method=interp_method, fill_value=0)))self.tec = np.flipud(g2s_method(grid_x[0, :], grid_y[:, 0], self.grid_dra, self.grid_ddec))where ```grid_dra``` and ```grid_ddec``` are generated from griddata from scipy.interpolate. Put simply, the gradient values (```ra_shifts``` and ```dec_shifts```) at the spatial positions (```ra``` and ```dec```) are gridded to form vector fields, which are then integrated by pyGrad2Surf.Limitations-----------A number of g2s methods are detailed by Harker & O'Leary, however, only the basic g2s method is available here. The other methods require some work to translate, thanks to syntactic and functional differences between python and MATLAB. These may or may not be completed in the future, but pull requests are welcome.Contact-------christopherjordan87 -at- gmail.comDependencies------------- python 2.7.x- numpy- scipy
Package: pygrade
auto-grade python assignmentsFree software: ISC licenseDocumentation:https://pygrade.readthedocs.org.This library helps one create and grade programming assignments written in Python and submitted by students via Github.Features include the ability to:Create private GitHub repositories for each student.Populate student repositories with starter code.Grade student assignments by running unittests against their code.Push grades and failing tests back to the student repositories.Summarize grades by test or studentSee theexamplefor a tutorial on usage.Related librariesteacherspet: manipulates github repos for teaching.CreditsTools used in rendering this package:Cookiecuttercookiecutter-pypackageHistory0.2.5 (2018-01-25)BugfixesNew feature: delete student accounts0.2.4 (2017-01-23)BugfixesEnforce alpha version of github30.2.3 (2016-10-14)Bugfixes0.2.2 (2016-10-14)Support extra file for external deductionsSummarize grades by student/test/etc.0.1.8 (2016-01-16)First fully functional version0.1.0 (2016-01-01)First release on PyPI.
Package: pygradflow
PyGradFlowPyGradFlow is a simple implementation of the sequential homotopy method to
be used to solve general nonlinear programs.To solve a nonlinear problem, subclass theProblemclass, implementing
its abstract methods, pass a problem instance to aSolver, and call
itssolve()method.Note: This code is for research purposes, not productive use.ReferencesPotschka, A., Bock, H.G. A sequential homotopy method for mathematical programming problems. Math. Program. 187, 459–486 (2021).https://doi.org/10.1007/s10107-020-01488-zPearson, John W., and Andreas Potschka. "A preconditioned inexact active-set method for large-scale nonlinear optimal control problems." arXiv preprint arXiv:2112.05020 (2021).
Package: pygrading
PygradingCourseGrading(希冀)信息类专业教学与科研一体化平台开发用Python工具包What is it•Install•Quick Start•Change Log•FAQ•CG SiteMade by Charles Zhang • :globe_with_meridians:https://gitlab.educg.net/zhangmingyuan/PyGradingWhat is it希冀平台全面支撑计算机、大数据、人工智能、集成电路、信息安全、机器人、金融科技、区块链等专业建设。 基于平台建成了涵盖实验、质量指标及过程控制的完整在线实验体系，实现了“任何人、任何时间、任何地点均能开展实验学习”的目标。通用评测是一个通用的自动评测框架，基于该框架可以定制开发任何自己需要的自动评测内核。PyGrading工具包目前该工具包包含以下功能：支持CourseGrading平台通用评测内核快速构建；支持适用于通用评测题、云桌面环境和Jupyter实验环境的评测结果JSON串的快速生成；支持HTML标签文本内容的快速生成，绝对好用的HTML生成工具；希望使用本工具能够提高大家的工作效率，祝各位开发顺利！Install使用pip可以轻松安装PyGrading：pipinstallpygradingPyGrading的运行环境要求Python >= 3.5，不支持Python2。Quick Start下面从一段简单的代码开始，使用PyGrading创建一个简单的通用评测内核：frompygradingimportJob# 创建一个任务对象job=Job()# 设定任务得分、评定结果和评语job.score(100)job.verdict("Accept")job.comment("Hello World")# 输出评测结果job.print()这样就可以得到一个评测结果：{"verdict":"Accept","score":"100","rank":{"rank":"-1.0"},"HTML":"enable","comment":"Hello World"}详细的使用手册请参考：PyGrading开发文档Change Logv1.1.7 Change Log (2020.12.14)将gg.utils.loge()输出位置从stdout定向到了stderr。v1.1.6 Change Log (2020.12.14)为gg.utils.loge()绑定了环境变量PYGRADING_DEBUG，该变量为True时loge生效。v1.1.5 渲染更新 Change Log (2020.11.28)添加了Bootstrap4和Jinja2模板引擎的支持。支持了使用gg.render_template()方法渲染HTML模板！添加了默认渲染模板，该模板可使用python -m pygrading init创建，位于新建项目中的templates/html/index.htmlv1.0.1 Change Log (2020.11.24)去除了渲染结果时默认使用str2html的特性，因为其可能会导致JS失效。v1.0.0 正式版 Change Log (2020.11.21)重构了测试版底层架构，简化了导入步骤和部分包的使用方式。添加了命令行程序，支持使用python -m pygrading init创建项目模板。添加了多线程评测支持，高效利用服务器资源，提高评测效率。添加了评测超时控制功能，限制评测任务执行时间，防止卡死。添加了快速提取程序输出中评测指标的功能（键值对智能识别）。添加了图片转base64功能，快速生成图片展示元素。添加了携带环境变量执行评测功能（用于支撑需要读取不同环境变量的测试用例）。添加了评测指令执行静默模式，支持直接抛出评测指令的异常。添加了一键打包评测内核功能，打包好的评测内核可以通内核扩展上传。优化了评测过程函数的参数要求，支持不带参数的简单过程函数。FAQ暂无内容
Package: pygradle
Python gradle wrapperOverviewpygradleis an wrapper for gradle, the modern open source build automation
system. Its goal is to call gradle command and configuration from python script.UsageIt’s helpful to use pygradle andpytractor <https://github.com/kpodl/pytractor/>for testing ex. java web application in python.BasicYou can create Gradle wrapper from factoryfrom pygradle import gradlew

gradle = GradleFactory.create(gradle_cmd='/path/to/gradle')

gradle.build()GradleFactory reads all tasks from gradle. Creation of gradle wrapper with factory
is slow because factory is asking real gradle for tasks. Instead of that you can use:from pygradle import gradlew

gradle = gradlew.Gradle(gradle_cmd='/path/to/gradle')

gradle.clean()

gradle.add_tasks('package:build', 'package2:build').parallel().execute()Which is quicker.Missing FeaturesGradle task configurationRest optionsFinds better way to check exection status.
Package: pygraf
Supports:Python:Python 2.6+Author:dw.livion@yandex.ruInstall:$pipinstallpygrafor$pip3installpygrafCommand List:graph=pygraf.graf(n,mas)graph.check_orient()graph.dfs(v,0)graph.print_dfs()graph.comp(True/False)graph.minwayves_wihtout_cicly(v,u)graph.minwayprint_wihtout_cicly(v,u)graph.add_rebro(v,u,c)graph.del_rebro(v,u)pygraf.graf(n,mas)n - count of pointmas - massive of [First point,Second point,Cost]Example init graph:graph=pygraf.graf(3,[[1,2,2],[1,3,4]])graph.check_orient()Checking directed graphExample init graph:graph=pygraf.graf(3,[[1,2,2],[1,3,4]])
graph.check_orient()#return true - Directed; False - Undirectedgraph.dfs(v,0)Starting DFS algoritm from v-pointExample init graph:graph=pygraf.graf(3,[[1,2,2],[2,3,4]])
graph.dfs(2,0)#Nothing returngraph.print_dfs()Return result DFS algoritm from v-pointExample init graph:graph=pygraf.graf(3,[[1,2,2],[2,3,4]])
graph.dfs(2,0)#Nothing return
print(graph.print_dfs())#print [False,True,True]graph.comp(True/False)Only for Undirected graph, if graph directed return Falseif True:Return Connected component and List all component:graph=pygraf.graf(3,[[2,1],[2,3],[3,1],[1,3],[1,2],[3,2]])
print(graph.comp(True))#print "1->2" "1->3" "1"if False:graph=pygraf.graf(5,[[2,1],[2,3],[3,1],[1,3],[1,2],[3,2],[4,5],[5,4]])
print(graph.comp(False))#print "2"graph.minwayves_wihtout_cicly(v,u)Print min-cost from v to uExample init graph:graph=pygraf.graf(3,[[1,2,2],[2,3,4]])
graph.minwayves_wihtout_cicly(2,3)#print "4"graph.minwayprint_wihtout_cicly(v,u)Print min-cost from v to uExample init graph:graph=pygraf.graf(3,[[1,2,2],[2,3,4]])
graph.minwayprint_wihtout_cicly(2,3)#print "2 3"graph.add_rebro(v,u,c)Add path from “v” to “u” cost “c”Example init graph:graph=pygraf.graf(3,[[1,2,2],[2,3,4]])
graph.add_rebro(2,1,4)#add path from 2 to 1 cost 4graph.del_rebro(v,u)Delete path from “v” to “u”Example init graph:graph=pygraf.graf(3,[[1,2,2],[2,3,4]])
graph.del_rebro(2,3)#delete path from "2" to "3"
Package: pygrafanaapi
pygrafanaapipygrafanaapi contains some functions to facilitate the usage of grafana apis inside python modules.The source for this project is available here.Example of importing grafanaapi inside a python module :import os
from pygrafanaapi import GrafanaApiurl = "http://localhost:3000"
json = "apikey2.json"
itoken = os.environ.get("GRAFANA_TOKEN")
key, message= GrafanaApi.createApiKey(url, json, token=itoken)
print(key)
print(message)
keys = GrafanaApi.listApiKeys(url, token=itoken)
for key in keys:
print(key)
Package: pygraff
GraffAnMinimalOverkill HTML only blog posts previews generator.Setuppip install pygraffto installlook atsettings.tomlfor example configSet theGRAFF_CONFenvironment to the location of graff config.Usagegraff -n <Page name>to create new blog page in posts_dir.graff -gto generate previews.What needs to be doneAdd<a>tag to the title of the previews that links to the articlegroff.py: file where it calls the functions fromsettings.pyandgenerator.pyError handling :missing or wrong values from the settings.toml file should return an error message warranting the user and not starting generation so we need a checker insettings.pyand also ingenerator.pyin case the class of the blog previews doesn't exist orthe file isn't even html.add creating new blog posts with commandnewand with chosen template
Package: pyGrained
pyCoarsepyCoarse is a Python library designed for generating coarse-grained models of proteins, particularly for the development of coarse-grained biomolecular models such as viruses.Coarse grained model generationThese steps are common to all coarse grained models.PDB file is load and analyzed. Different chains are grouped into classes. Two chains are considered to belong to the same class if one chain's sequence is contained within the other. Each class is associated with a leader chain, which is the shortest chain in the class.A structure is created containing only the leader chains. The rest of the protein is stored as a translation and rotation operation.The coarse-grained model is then applied to each leader chain, and the full structure is reconstructed at coarse-grained resolution.Coarse grained models availbleShape based coarse grained model (SBCG)More information about this model can be foundhere.  The following example shows how to construct the coarse grained using the SBCG model. The P22 virus (PDB id : 5uu5) is used.import pyGrained
import pyGrained.models

resolution = 300 #Number of atoms per bead
steps      = 10000 #Number of minimization steps

pathToPDB = "./p22/data/5uu5.pdb"
outputFile = "p22_sbcg"

test = pyGrained.models.SBCG("p22_sbcg",pathToPDB)
test.generateModel(resolution,steps)

#Models to be used in topology generation. Elastic network model for the bonds and a proximity model of alpha carbons for native contacts.

model = {"bondsModel":{"name":"ENM",
                       "parameters":{"enmCut":12.0}},
         "nativeContactsModel":{"name":"CA",
                                "parameters":{"ncCut":8.0}}
         }

test.generateTopology(model)

#Generate .json with all information
test.generateSimulation(outputFile+".json",K=5.0,epsilon=1.0,D=1.2)

#Write a PDB file with the coarse grained model
test.writePDBcg(outputFile+".pdb")

#Write a superpunto file
test.writeSPcg(outputFile+".sp")
Package: py-grama
py_gramaImplementation of agrammar of model analysis(grama). See thedocumentationfor more info.OverviewGrama is agrammar of model analysis---a Python package that supports building and analyzing models with quantified uncertainties. This language is heavily inspired by theTidyverse. Grama provides convenient syntax for building a model (with functions and distributions), generating data, and visualizing results. The purpose of this language is to support scientists and engineers learning to handle uncertainty, and to improve documentation + reproducibility of results.Uncertainty Quantification (UQ) is the science of analyzing uncertainty in scientific problems and using those results to inform decisions. UQ has important applications to building safety-critical engineering systems, and to making high-consequence choices based on scientific models. However, UQ is generally not taught at the undergraduate level: Many engineers leave their undergraduate training with a purely deterministic view of their discipline, which can lead to probabilistic design errors thatnegatively impact safety. To that end, Grama is designed to facilitate rapid model analysis, communication of results, and the teaching of concepts, all with quantified uncertainties. Intended users ofGramaare scientists and engineers at the undergraduate level and upward, seeking to analyze computationally-lightweight models.InstallationQuick install:$pipinstallpy-gramaFor a manual install clone this repo, change directories and run the following to install dependencies. (Note: I recommendAnacondaas a Python distribution; it takes care of most of the dependencies.)$gitclonegit@github.com:zdelrosario/py_grama.git
$cdpy_grama/
$pipinstall-rrequirements.txt
$pipinstall.Run the following to check your install:$python
>importgramaQuick Tourpy_gramahas tools for bothbuildingandanalyzingmodels. For a quick look at functionality, see the following notebooks:video demomodel building demomodel analysis demoTutorialsThetutorialspage has educational materials for learning to work withpy_grama.Support and ContributingIf you are seeking support or want to contribute, please seeContributing.Cite AsIf you find Grama useful in your work, we'd appreciate that you cite it as:del Rosario, Z., (2020). Grama: A Grammar of Model Analysis. Journal of Open Source Software, 5(51), 2462,https://doi.org/10.21105/joss.02462Bibtex code:@article{del Rosario2020,
  doi = {10.21105/joss.02462},
  url = {https://doi.org/10.21105/joss.02462},
  year = {2020},
  publisher = {The Open Journal},
  volume = {5},
  number = {51},
  pages = {2462},
  author = {Zachary del Rosario},
  title = {Grama: A Grammar of Model Analysis},
  journal = {Journal of Open Source Software}
}
Package: pygrambank
pygrambankCuration tools forGrambank data.Installpygrambankcan be installed from PyPI viapipinstallpygrambankor from a clone of [grambank/pygrambank]:gitclone...cdpygrambank
pipinstall-e.You should installpygrambankin avirtual environmentto make sure it does not mess with a system-wide Python installation.CLIInstallingpygrambankwill also install a command line programgrambank. Data curation functionality is implemented as subcommands
of this program. To get information about available subcommands, rungrambank--helpMore info on individual subcommands can be obtained runninggrambank<SUBCOMMAND>-he.g.$grambankdescribe-h
usage:grambankdescribe[-h][--columns]SHEET

Describea(setof)sheets.

Thisincludescheckingforcorrectness-i.e.thefunctionalityof`grambankcheck`.
Whilereferenceswillbeparsed,thecorrespondingsourceswill**not**belookedupinGlottolog(sincethisisslow).Thus,forafinalcheckofasheet,youmustrun`grambanksourcelookup`.

positionalarguments:SHEETPathofaspecificTSVfiletocheckorsubstringofafilename(e.g.aglottocode)optionalarguments:-h,--helpshowthishelpmessageandexit--columnsListcolumnsofthesheet(default:False)APIpygrambankalso allows programmatic access to Grambank data from Python
programs. All functionality is mediated through apygrambank.Grambankinstance:>>>frompygrambankimportGrambank>>>gb=Grambank('.')>>>gb.sheets_dirPosixPath('original_sheets')>>>forsheetingb.iter_sheets():...print(sheet)...break...original_sheets/AH_alag1248.tsv
Package: pygrambot
PytelegrambotContentGuide to Basic OperationsGuidelines for creating middlewaresCreating message catchersBuilt-in data typesAbout the projectPytelegrambot is a python framework for creating telegram bots. The framework is completely asynchronous. The main idea of this project is to make the architecture of telegram bots as structured, as possible and easy to use and understand.Getting StartedTo create your own project, follow these instructions.InstallingTo install, run the following command:pip install pytelegrambotAfter executing the command, the framework will be available in your python virtual environment.Create and set up a projectFirst you need to create a python file (in this example, there will be a "main" file) and write the following code in it:from pygrambot.cli import bot_cliBot console commands are now available. To create bot configuration files, run the following command:python3 main.py initThe config directory has now been created in the root directory of the project, which contains the configuration files. For the minimum performance of the bot, you need to specify your own bot token.
To start the bot, you need to enter the command:python3 main.py startHow to use the bot further can be found in theadditional instructions.
Package: pygramm
pygramm : Grammar processing in PythonExperiments in processing BNF with Python.
Work in progress.Why?While Ply provides a semi-yaccalike, it has some
characteristics that bother me.  First, it prioritizes
lexical processing by the length of the pattern,
not the length of the token ... in violation of the
"maximum munch" rule.  Second, it tries to do everything
at run time.Also I want to experiment with generation of
sentences as well as parsing, and with LL as well
as LR parsing.Work in progressDoneParse BNF (llparse.py) and create an internal form.
The BNF form is extended with Kleene *, but a grammar
in pure BNF without Kleene is also fine.Internal structure (grammar.py) represents the BNF
structure directly.  The Grammar object contains a list
of symbols, each of which has a singleexpansion(which could be a sequence or a choice).  The following two
grammars will produce precisely the same internal form:S ::= "a";
S ::= "b";andS ::= "a" | "b";A phrase generator (generator.py), together with some
grammar analysis ingrammar.py, can produce sentences
within a given length limit (thebudget) with or without
direction.  Seechoicebot.pyfor an example of how
grammar choices can be controlled.To DoDistinguish lexical from CFG productions even for
sentence generation because we will want different tactics for
tokens than for RHS.  In CFG we budget for length of sentence.
In lexical productions we should choose between new and previously
used tokens.  Currently the BNF goes all the way to string
constants, always.  The works for the kinds of grammars thatGladelearns, but it is
not really ideal for generating useful program inputs.Related to the prior point:  Infer a good boundary between
CFG and lexical structure.  In conventional grammar processing,
a developer makes this distinction.  For grammar learners
like Glade, though, the distinction is not trivial to recognize.Add classic grammar analyses, starting with analyses for LL(1)
grammars (first, follow), then checking for conflicts, and
likewise for LALR(1) and/or LR(1).Add simple transformations, such as left-factoring for LL(1).
Package: pygrammalecte
pygrammalecte(english version at the bottom of this document)Grammalecte, le correcteur grammatical en Python.Pour être précis, ce projet n’est pas Grammalecte, mais un « wrapper » permettant de l’utiliser facilement en Python.InstallationVous devez utiliser un Python en version supérieure ou égale à 3.7.L’utilisation d’un environnement virtuel est fortement recommandé.python3-mpipinstallpygrammalecteUtilisationVérification d’une chaîne de caractèresfrompygrammalecteimportgrammalecte_texttexte_bidon="""\Coucou, je veut du fromage.Je sais coder en VHDL.Le VHDL est est compliquer."""formessageingrammalecte_text(texte_bidon):print(message)Vérification d’un fichierVous devez fournir le chemin du fichier enstrou enpathlib.Path. Le fichier doit être un fichier texte brut (pas un fichier Word ou OpenDocument par exemple).frompathlibimportPathfrompygrammalecteimportgrammalecte_filefilepath=Path("toto.txt")formessageingrammalecte_file(filepath):print(message)Messages générésLes fonctionsgrammalecte_fileetgrammalecte_textsont des générateurs, vous pouvez donc les utiliser dans une bouclefor. Elles génèrent desGrammalecteMessage.Deux types deGrammalecteMessageexistent :GrammalecteSpellingMessagequi a comme attributs :line: numéro de la ligne dans le texte vérifiéstart: numéro du caractère de début de l’erreur dans la ligneend: numéro du caractère de fin de l’erreur dans la ligneword: le mot non reconnu parGrammalectemessage: message d’erreurGrammalecteGrammarMessagequi a comme attributs :line: numéro de la ligne dans le texte vérifiéstart: numéro du caractère de début de l’erreur dans la ligneend: numéro du caractère de fin de l’erreur dans la ligneurl: l’URL fournie parGrammalectecolor: une couleur fournie parGrammalecte, c’est une liste de 3 entiers entre 0 et 255.suggestions: propositions de correctionmessage: message d’erreurrule: identifiant de la règle violéetype: type de la règle ("conj"…)ChangelogVersion v1.3.0Correction due à un fonctionnement étrange de Grammalecte v1.12.0Version v1.2.0Utilisation de Grammalecte v1.12.0Version v1.1.0Ajout de l'attributmessagepourGrammalecteSpellingMessageVersion v1.0.0RefactoringAjout de l'intégration continueVersion v0.1.0Première version !Utilisation de Grammalecte v1.11.0English versionThis is a wrapper for the french grammatical checker called Grammalecte.
Package: pygrams
PyGramsThe Python Package to get all your hustling Programs in one CodeBaseQuick startSeveral quick start options are available:Download the latest releaseClone the repo:git clone https://github.com/Yaseen549/pygrams.gitInstall withpypi:pip install pygramsRead theGetting started pagefor information on the Library contents, examples, and more.What's includedWithin the download you'll find the following directories and files, logically grouping common assets. You'll see something like this:Bugs and feature requestsHave a bug or a feature request? Please first search for existing and closedissues. If your problem or idea is not addressed yet,please open a new issue.is there any program missed?Raise an Issue.Contribution Guideif you are willing to contribute, here are the stepsFork the Repo.clone the Repo. (git clone REPO)Create a new remote for the upstream repository. (git remote add upstream REPO)Create a new branch. (git checkout -b my-branch)Add Codes (git add .)commit your changes. (git commit -m "Adding an awesome feature to my-branch")Push the changes to your repository. (git push -u origin my-branch)Create a pull request. (We will review it ASAP)And That's it, get your name in contribution ListFeature Request ProcessTitle: Program NameDescription:Add the description how the function worksorWrite the complete program and the comments which explains the program Clickhere to Request
Package: pygranta
Welcome to the PyGranta metapackage repository. Thepygrantametapackage
provides a single package of collected PyGranta packages that ensures compatibility
of these packages amongst themselves and the Granta MI release that they are linked to.Thepygrantametapackage ensures compatibility between these PyGranta packages:BoM Analytics: Pythonic interface to the Ansys Granta MI BoM Analytics services.RecordLists: Pythonic interface to the Ansys Granta MI Lists API.serverapi-openapi: Autogenerated client library for the Ansys Granta MI Server API Services.The PyGranta metapackage installs these core modules and their dependencies:BoM AnalyticsRecordListsserverapi-openapiDocumentationDocumentation for the latest stable release of PyGranta is hosted atPyGranta documentation.
The documentation has four sections:Getting started: Describes
how to install PyGranta in user mode.User guide: Describes how to
use PyGranta.API reference: Provides API member descriptions
and usage examples.Examples: Provides examples showing
end-to-end workflows for using PyGranta.License and acknowledgmentsAll PyGranta libraries are licensed under the MIT license.PyGranta libraries make no commercial claim over Ansys whatsoever.
These libraries extend the functionality of Ansys products by
adding Python interfaces to legally obtained software products
without changing the core behaviors or licenses of the original
software.For more information on Ansys products, visit theAnsys website.