Saravanan666/pypi-org huggingface dataset:
Package: grade-change-emailer
This is a simple python script that checks for new grades at the FH
Aachen.ConfigurationCopy theexample.initodefault.iniin your OS-specfic user
config directory and fill in the necessary details. You can also place a
configuration file under/etc/grade_change_emailer.inior specify a
custom location via env variableGRADE_CHANGE_EMAILER_CONFIG_FILE.UsageRun the script withgrade_change_emailer. Now everytime the script
runs it checks for new grades and e-mails you about it if that is the
case. Note that the script will always e-mail you the first time the
script is run. If you don’t receive an e-mail, you misconfigured it. Go
and recheck all you login data. You might want to schedule this script
with something likecronto automate the grade checking.DependenciesThis scripts depends onPython 3, therequests, theappdirsand theBeautifulSoup4package from python.LicenseThis code is licensed under the MIT License. See LICENSE.md for more
details.
Package: gradedb
# GradeDBThe program that load the CSV file and use them as database. Main function is to Insert / Update / Save course and it’s detail and Calculate the GPA from given CSV## PrerequisitesThis program needs Python 3 and following libraries[PyInquirer](https://github.com/CITGuru/PyInquirer) - The interactive UI for Python[tabulate](https://pypi.org/project/tabulate/) - Pretty table presentation[pandas](https://pandas.pydata.org/) - The way of playing with data[art](https://pypi.org/project/art/) - Used to generate ASCII art[NBLOGIC](https://pypi.org/project/nblogic/) - NBLOGIC for python by Thanawat Petchuen### InstallingFirst, install this project by pip` pip install gradedb `And then run the script` gradedb "filename.csv" `or use KLOGIC database (require authentication)` gradedb `## AuthorsThanawat Petchuen- [Thanawat(GitHub)](https://github.com/thanawatpetchuen) - [Thanawat(Bitbucket)](https://bitbucket.org/thanawatpetchuen/)## LicenseThis project is licensed under the MIT License
Package: gradedoc
gradedocGrader for DOCX lab reports using comments.InstallingPrerequisitesMake surepython, Windows Terminal, and AutoHotkey are installed. These links should get you started:PythonAutoHotkeyWindows TerminalIf you're not familiar with configuring these tools, just accept the default options when installing.Installpipxpy-mpipinstallpipxpy-mpipxensurepathInstallgradedocpy-mpipxinstallgradedoc
Package: gradefast
GradeFast-2019Gradefast is a framework whose intention is to make eYRC evaluations faster and bring a standardization across task evaluations. Most important benefit is that the test scripts can then be extended and be reused in other themes having similar tasks. Primary thought behind making GradeFast is to take care of all the boundary tasks that happen in theme evaluations and also make utility scripts that take care of other common tasks so that a lot of time is saved. Some of these tasks are downloading new submissions, iterating over each of the submission folders, easily finding files to test, comments based on criterias, uploading marks and plagiarism checking. The framework is also easy to use causing less to no cognitive load on a theme developer using it.Installing gradefastInstalling from pip$ pip install gradefastORInstalling from sources$ git clone https://github.com/eyantra-eysip/GradeFast-2019$ cd GradeFast-2019$ git checkout develop$ pip install .Creating a gradefast projectDo this once [sudo permissions may be required]npm install -g yonpm install -g generator-gradefastThen generate your new project like thisyo gradefastFeaturesSubmission downloadingPlagiarism checkingPrimarily built for python but can support evaluation of any other tasksAggregate resultsUpload marksAdd commentsAlso includesDetailed error loggingTiming and static code analysis of scriptsResume tasks from where they are stoppedChecking test conventionsBoilerplate code generationRunning testsFor unit tests:python -m unittest discover -s tests/unit/For integration tests:python -m unittest discover -s tests/unit/Checking coverageInstall coverage.py:pip install coverageRuncoverage run --source=gradefast/ -m unittest discover -s tests/unit/orcoverage run --source=gradefast/ -m unittest discover -s tests/integration/Generate static htmlcoverage htmlcd htmlcovand run http server withlive-serverorpython3 -m http.serverBuilding and running documentationInstalling required packages$ pip install sphinx_ustack_themeandpip install sphinx_rtd_theme.$ pip install --upgrade sphinxBuilding docs$ cd docs$ make htmlRunning web server to host documentation$ cd docs/_build/htmlStart a web server in this directory. You can use either the python 3
HTTP server orlive-server.$ python3 -m http.serverFuture workStatistics and analysis of resultsSandboxed environmentsMulti-programmingRefactoringPlugins API
Package: grademage
Grade MageAuto grader for online quiz.Use the following command to ensure all the tests are passed:pytestUse the following commands for development locally:python3 setup.py developThen execute the following command t generate the wheel:python3 setup.py sdist bdist_wheelUpload the module to test server:python3 -m pip install --upgrade twine
python3 -m twine upload --repository testpypi dist/*Distribute the module to production server:python3 -m twine upload --repository pypi dist/*
Package: gradepy
# grade.pygrade.py is a testing framework that aids in grading python assignments. grade.py gracefully handles exceptions and offers error carried forward support.This package differs from standard testing frameworks in two major ways. First, it relies on a correct implementation of the module, making test scripts quick to write and enabling error carried forward. Second, it is designed to identify graded quality of performance, rather than giving binary PASS/FAIL judgements.## UsageAs an end user (i.e. a grader), usage is simple:$ grade.py path/to/student/module.pyFor example, one could test all the python modules in a directory of student submissions with the command: `grade.py students/*/*.py`. Of course, this will only work if testing scripts have been appropriately registered by the lead grader.## Writing test scriptsWriting a test script comes in two phases:1. Correctly implement the assigned module specification.2. Write a test suite with functions that generate output using the module.### Example test function```pythondef test_foo(module):for i in range(10):yield Check('foo({i})', note='good effort')```This function might generate the following output:```foo(0) should be 0, but student code raised an exception:File "flc37/foo.py", line 15, in fooreturn 1.0 / xZeroDivisionError: integer division or modulo by zeroNote: good effortfoo(5) should be 5, but it is 5.0Note: good effort```You can find a more complete example in `example/`, which includes two "student submisions" along with an example grading package and detailed commentary.To create a new test, first copy the boilerplate from `test/grade_template/`. A package in the `tests/` directory that follows the naming convention `grade_MODULE/` will be used to grade any module with the name `MODULE`. Putting the module in this directory makes it visible to the grade.py command line tool.## Distributing test scriptsWe are still in the process of developing a generalized distribution strategy. At present, the best option is fork this repository and add scripts directly into the repository. Then update the name of the package and upload it to PyPI so that graders can easily download and update the package using e.g. `$ pip install cs1110grading`
Package: grader-purdueece
Module InterfaceThis grader can load specified tests in a desired loaction that match a specified pattern then run them against source code in another module. The results are collected in CSV format with configurable overrides for each test. Test runs can also change based on a custom submission name (e.g. student name). If grading the submission fails, it will fallback to grading a sepcified template submission directory. It can load a config file that can rename the submission directory to a custom label and can assign weights to individual tests. The help output for the grader is below:usage: grader [-h] [--submission SUBMISSION] [--tests TESTS] [--test-pattern TEST_PATTERN] [--output OUTPUT] [--log LOG] [--config CONFIG] path

positional arguments:
  path                  Path of the module to grade. Defaults to ./

optional arguments:
  -h, --help            show this help message and exit
  --submission SUBMISSION
                        Submission name to grade.
  --tests TESTS         Path of tests to run. Defaults to ./
  --test-pattern TEST_PATTERN
                        Test name pattern to match. Defaults to "test*.py"
  --output OUTPUT       Output file for scores. Defaults to stdout.
  --log LOG             Log file to use. Defaults to stdout.
  --config CONFIG       Config file to use.Tests DiscoveryTests to run can be located anywhere using a combination of the--testsand--test-patternargs. By default, they are searched for under the current directory and match thetest*.pypattern. Tests are discovered using theunittestmodule.Grader ConfigThe grader config can be specified with the--configarg. It is a json file that can specify what happens when a certain test runs or when a certain submission is graded. Individual test configs should be under the"tests"map and the key should be of the form:testFunction (test_filename.TestCaseName). Inividual submission configs should be under the"submissions"map and match the name of the submission. An example format is below:{"tests":{"testSimple1 (test_simple.TestSimpleTestCase)":{"name":"Simple Test 1","weight":2}},"submissions":{"submission_name":{"name":"custom label here"}}}
Package: gradescent
Optimization by Gradient DescentThis optimizer varies a list of input variables x1, x2, ... xn in order to find a minimum for an target function func(x1, x2, ...xn).The optimizer supports min/max limits of the input variables and inputs that can only be integers.The optimization process either starts at a given point of initial input values or does a grid search in the input space to increase the probability to find a global optimum instead of a local one. It supports an automatic learning rate adjustment via backtracking line search, autmatic zoom-in for fine tuning as well as an adjustable momentum.Using the optimizer involves four steps:1. Create any number of Parameter() objects by using the constructor:Parameter (name, initial_value=None, min=None, max=None, grid=None, integral=False, dx=None)The meaning of these parameters:name: identifies the parameterinitial_value: where the search will start. Either initial_value or a grid must be specifiedmin/max: limits for this inputgrid: an integer specifying the number of intervals between min and max. The midpoint in each of these intervals will be a start point for optimization. If multiple parameters have grids, their cartesian product will be used.integral: if True, the input is an integerdx: the (initial) increment to estimate the gradient at a certain point by (f(x + dx) - f(x)) / dxMust be specified if initial_value is zero. Otherwise, dx defaults to initial_value * 0.0012. Create an optimizer instance by using the constructor:Optimizer (function, args='enum', zoom_limit=1e6, cfactor=0.5, momentum=0, iterations=100, min_improvement=0, trace=False, debug=False)The meaning of these parameters:function: the target functionargs: the way the parameters will be passed to the function. If there are two parameters x and y, there are the following options:args='enum': function(x, y)args='kwargs': function(x=x, y=y)args='dict': function(params) with x=params['x'] and y=params['y']args='list': function(params) with x=params[0] and y=params[1]cfactor: control parameter in the Armijo condition for the backtracking line search algorithmzoom_limit: if applying the steps doesn't improve the result any more, learning as well as the dx for calculating the gradient will be divided by an ever increasing zoom factor. This parameter limits the zooming process.momentum: if momentum > 0, the (momentum * last_step) is added to the current stepiterations: maximum number of iterationsmin_improvement: iteration is stopped early if per-iteration improvement is less than this valuetrace/debug: print some output during iterations3. add the parameters to the optimizer:opt.add_par (param1)
opt.add_par (param2)
...4. invoke the calculation:res = opt.optimize()
# res[0] will contain a dictionary of the optimal parameter values
# res[1] will conmtain the function value at this point
Package: grades-check2
grades-checkPython Boilerplate contains all the boilerplate you need to create a Python package.Free software: MIT licenseDocumentation:https://grades-check.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2021-10-28)First release on PyPI.
Package: gradescope
gradescopeThis is a Python utility library for Gradescope.This library is a subset of a library created by Jérémie Lumbroso, licensed under the LGPL3 license. You can find this library here:https://github.com/jlumbroso/pylifttk.Configuration fileTheconfig.yamlfile contains Gradescope credentials.gradescope:username:""# credentials for https://gradescope.compassword:""ExampleComing soon!
Package: gradescope-mean
Gradescope MeanA utility which computes final grades (example:grade_full.csv) from gradescope outputs. It allows the instructor to ...weight assignments per categorye.g. all HW assignments are 50% of gradewaive lowest N assignments per categorye.g. 2 lowest HW assignments, per student, are waivedapply a late penalty (per day) that assignments are submitted beyond
deadlinee.g. HW is penalized 15% of average assignment hw weight for every day late it is submittedalso includes support for not penalizing the first N "late days" per assignment category (e.g. each student may use up to 3 "late days" across all HWs without penalty)waive assignments per individual studentwaive late penalties per individual student's assignmentvalidate gradescope student list by passing an email list of active studentse.g. one student has a low average grade, have they dropped the course?exclude assignments which shouldn't be included in final gradeassignments automatically excluded if they don't have some minimum completion thresholdsubstitute one assignment in place of another (where substitute has
higher percentage)e.g. to "merge" two versions of the quiz with their own unique gradescope assignmentsubstitutequiz_02forquiz_01excludequiz_02Installationpip3 install gradescope-meanUsageDownload all gradescope assignments to some localscope.csvfile
(Assignments > Download Grades > Download CSV) and run:python -m gradescope_mean scope.csvto create outputgrade_full.csvusing default configuartion.
This first run will have created aconfig.yamlconfiguration file which you can modify to take advantage of the functionality listed above (details given in theconfiguration doc).
To re-run with your configuration options:python -m gradescope_mean scope.csv --config config.yamlOther outputsProvide an output file via--late_csvto observe late days per student-assignment pair.Provide the--per_studentflag to create a folder of student-specific csvs, helpful for emailing students the particulars of their grades.Pass the--plotflag above to view histograms (hist.html) per assignment category:Exporting GradesThe interface above yields a "grade_full.csv" which can be processed so its ready to import intocanvasorNortheastern's Banner, see links for detail.
Package: gradescope-utils
Gradescope Python UtilitiesInstallingMake sure you have pip installed (eg. on Debian/Ubuntu,apt-get install python-pip).Then, runpip install gradescope-utilsPackagesAutograder UtilitiesChangelogSee theReleasespage.Releasing new versionsFollowhttps://packaging.python.org/tutorials/packaging-projects/, but in brief:Bump the version in setup.pyDraft a release onhttps://github.com/gradescope/gradescope-utils/releasesThis can take care of tagging for you. Otherwise, tag the commit:git tag vX.Y.Z COMMIT_SHAMake sure that the setup.py version matches the release/tag versionGitHub releases can help auto-generate release notes from merged PRs. Edit these as necessary.Publish the release on GitHub. GitHub Actions will build and publish a new release when a version is tagged (e.g. when a GitHub release is published).SupportContact us athelp@gradescope.comif you need help with these packages.
Package: grades-report
grades-report 📝Get info and stats about gradesgrades-reportis a Command Line Interface (CLI) tool that shows useful statistics and generates a report about a set of given grades, e.g., from school, university, etc.FeaturesThe report displays:Thenumberof individuals that weregraded, thatpassedand thatfailedThearithmetic meanof thepassing grades(taking into account only grades that are over the passing threshold) and of thetotal grades(taking into account all the grades that are provided)Thestandard deviationof thepassing grades(taking into account only grades that are over the passing threshold) and of thetotal grades(taking into account all the grades that are provided)Themaximum gradefrom all the given gradesTheminimum gradeof thepassing grades(taking into account only grades that are over the passing threshold) and of thetotal grades(taking into account all the grades that are provided)Thepercentage of the grades you have scored abovefrom thetotal grades(taking into account all the grades that are provided) and of thepassing grades(taking into account only grades that are over the passing threshold)Thedistributionof all the grades (split into 10 equally sized and non-overlapping bins)Example report (CLI output):# Graded: 4
# Passed: 4
# Failed: 0

-----------------------------------------------------

Arithmetic Mean of PASSING GRADES: 7.0
Arithmetic Mean of TOTAL GRADES: 7.0

Standard Deviation of PASSING GRADES: 1.8257418583505538
Standard Deviation of TOTAL GRADES: 1.8257418583505538

Max TOTAL GRADE: 9.0
Min PASSING GRADE: 5.0 & Min TOTAL GRADE: 5.0

-----------------------------------------------------

Your grade: 6.0
You scored above 25.0% of all the grades.
You scored above 25.0% of the passing grades.

-----------------------------------------------------

GRADE       TOTAL
[0.0-1.0)      0
[1.0-2.0)      0
[2.0-3.0)      0
[3.0-4.0)      0
[4.0-5.0)      0
[5.0-6.0)      1
[6.0-7.0)      1
[7.0-8.0)      0
[8.0-9.0)      1
[9.0-10.0]     1Example usageTo learn how to use the CLI tool just type:grades-report --helpCreates a report for the following list of grades: 40, 80, 75, 60, 90, with the maximum grade being 100 and the passing threshold being 60 (if no arguments are given the defaults are 10 and 5 respectively):grades-report -l [40,80,75,60,90] -m 100 -p 60Creates a report for the following list of grades: 4, 8, 7.5, 6, 9, with your personal grade being 8 (by default the perfect score is considered to be 10 and the passing grade 5):grades-report -l "[4, 8, 7.5, 6, 9]" -pg 8Creates a report for the grades given in the file grades.csv, with the "," character used as a delimiter (for the path in Windows make sure to use double backslashes, \\, or a single forward slash, /.)grades-report -f /home/grades.csv ,Installationpip install grades-reportContributingYou can always submit a PR if you want to suggest improvements or fix issues.Check out the open issues athttps://github.com/KAUTH/grades-report/issues.
Package: grade-tracker
This is a CLI written in python for tracking grades. It reads data from a yaml fileInstallationInstall this with$ pip install grade-trackerThe Data FileThe data file, by default read from$XDG_DATA_HOME/gradeTracker/data.ymlis a yaml file containing the data to calculate with. An example of this file can be foundin the github repositoryThe file should always contain amoduleskey with a list of submodules. These submodules should have aweightingset which sums to 100 (this is checked when gradeTracker is run). This represents how much this module is worth.The keypercentrepresents the mark given out of 100 for that assignment. If not set, gradeTracker will ignore the module or assume it's 0 depending onignore_unmarkedA module can also have submodules by including themodulestag, and following the same pattern. gradeTracker should deal with any depths, though it is not thoroughly tested will many layers.ConfigurationConfiguration is done in the yaml file$XDG_CONFIG_HOME/gradeTracker/config.yml. By default this is ​~/.config/gradeTracker/config.yml. An example of this file can be foundin the github repository. There are 5 possible options:ignore-unmarkedIf set to true, gradeTracker will ignore variables without a mark attatched. If set to false, gradeTracker will assume they are 0. Defaults to true if unset.data-fileThis is the file that gradeTracker will read to calculate percentages. If not set, it will default to$XDG_DATA_HOME/gradeTracker/data.ymlindent-stringThis is used each time gradeTracker indents. Default is"  ", but"| "also looks nicepost-stringThis is used after each mark is given. Defaults to"%"total-weightingtoleranceHow close we require the total weighting to be to 100. This is so that fractional percentages can be properly used.UsageThegradeTrackercommand has one required parameter, which is the command you would like to run. It has 3 options:print-markswill calculate and output a breakdown of marks, calculating the percentages at each moduleprint-moduleswill output the module tree, showing the name,
weighting and percent. This is essentially just reformatting thedata.ymlfile.check-configwill check the data file and config file for validity.
Package: gradient
Gradient CLIGet started:Create Account•Install CLI•Tutorials•DocsResources:Website•Blog•Support•Contact SalesGradient is an an end-to-end MLOps platform that enables individuals and organizations to quickly develop, train, and deploy Deep Learning models.  The Gradient software stack runs on any infrastructure e.g. AWS, GCP, on-premise and low-costPaperspace GPUs.  Leverage automatic versioning, distributed training, built-in graphs & metrics, hyperparameter search, GradientCI, 1-click Jupyter Notebooks, our Python SDK, and more.Key components:Notebooks: 1-click Jupyter Notebooks.Workflows: Train models at scale with composable actions.Inference: Deploy models as API endpoints.Gradient supports any ML/DL framework (TensorFlow, PyTorch, XGBoost, etc).Seereleasenotes.mdfor details on the current release, as well as release history.Getting StartedMake sure you have a Paperspace account set up. Go tohttp://paperspace.comto register and generate an API key.Use pip, pipenv, or conda to install the gradient package, e.g.:pip install -U gradientTo install/update prerelease (Alpha/Beta) version version of gradient, use:pip install -U --pre gradientSet your api key by executing the following:gradient apiKey <your-api-key-here>Note: your api key is cached in ~/.paperspace/config.jsonYou can remove your cached api key by executing:gradient logoutExecuting tasks on GradientThe Gradient CLI follows a standard [command] [--options] syntaxFor example, to create a new Workflow in a project use:gradient projects list
gradient workflows create --name <name> --projectId <project-id>For a full list of available commands rungradient workflows --help. You can also view more info about Workflows in thedocs.ContributingWant to contribute?  Contact us athello@paperspace.comPre-Release TestingHave a Paperspace QA tester install your change directly from the branch to test it.
They can do it withpip install git+https://github.com/Paperspace/gradient-cli.git@MYBRANCH.