Saravanan666/pypi-org huggingface dataset:
Package: resultr-format
resultr-formatback end forresultrresultr-format letsresultr:get your weighted average for a yearget your rank in your yearre-format the results by module (as below) and output to csvoutput format:DevcomPHAS0000PHAS0001PHAS0002PHAS0003PHAS0004PHAS0005PHAS0006PHAS0007Averages100999897969594939295.52435534934315254039Release History0.1.4.5Odd/Even indexing in myGrades0.1.4.4Odd/Even indexing for columns needed fixing for year3+ as no more devcom in first column (in myGrades)0.1.4.3Odd/Even indexing for columns needed fixing for year3+ as no more devcom in first column (in goodFormater)0.1.4.2Professional spelling error in goodFormater0.1.4.1Forgot to initialise goodFormater when i fixed devcom bug0.1.4Fixed devcom bug for year 3+ people0.1.3.1convert 'DA' results to 0 in badFormater0.1.3Convert 'DA' results to 00.1.2.3Added .upper() to key in badformater incase 'cand'/'Cand'/'CAND'0.1.2.2Changed form doing .upper() in badformater to doing it in goodformater0.1.2.1Changed from doing .upper() to each row in badformater to key.upper():val.upper()0.1.2Changed badformater to import everything uppercase0.1.1goodFormatter would throw key error when popping '0' if '0' didn't exist0.1.0The first proper releaseMetaHayk Khachatryan –hi@hayk.ioDistributed under the MIT license. SeeLICENSEfor more information.https://github.com/haykkhContributingFork it (https://github.com/haykkh/resultr-format/fork)Create your feature branch (git checkout -b feature/fooBar)Commit your changes (git commit -am 'Add some fooBar')Push to the branch (git push origin feature/fooBar)Create a new Pull Request
Package: resultr-plot
resultr-plotplotting part ofresultrnoteit's very possible that I made mistakes so take what this gives with a bucketload of salt.resultr-plot lets you:plot a histogram of the results for a module in the bins: (0,40), (40,50), (50, 60), (60, 70), (80, 90), (90, 100)Usage exampleRequires:Python 3pandasandmatplotlibfor plottingpython-inquirerfor the user inputRunning resultr-plotYou can run interact with resultr usinginquirerprompts:Or equivalently by passing arguments when you run resultr-plot:$pythonresultr-plot.py-husage:resultr-plot.py[-h][--plot][--exportplotsEXPORTPLOTS][--showplots]MakesUCLPHASresultsbetteroptionalarguments:-h,--helpshowthishelpmessageandexit--plot,-pplotthemoduleresults--exportplots,-epEXPORTPLOTSexportallplotsto/path/you/want/--showplots,-spshowallplotsRelease History0.1.2addedhowPlotArgsback, added arguments to passexportplotsandshowplots0.1.1removed as_posix fromplotter0.1.0The first proper releaseMetaHayk Khachatryan –hi@hayk.ioDistributed under the MIT license. SeeLICENSEfor more information.https://github.com/haykkhContributingFork it (https://github.com/haykkh/resultr-plot/fork)Create your feature branch (git checkout -b feature/fooBar)Commit your changes (git commit -am 'Add some fooBar')Push to the branch (git push origin feature/fooBar)Create a new Pull Request
Package: result-wrapper
ResultWrapperHow to install it?You can install ResultWrapper from this Github repository withpython3 setup.py install,
or just install it directly from pypi withpip3 install result-wrapper.What is it?ResultWrapper is a very small utility library that provides a class containing either an Error, or a set of Results.
This can be used in APIs to quickly and easy communicate if the operation failed or not. AResultWrapperinstance
provides access to its underlying results if it did not fail, otherwise all access to possible results are denied.How to use it?To enable the capabilities of ResultWrapper, decorate a function with thewrap_resultdecorator.
This function then returns an instance ofResultWrapper. To check wether aResultWrapperis failed or not, use
the.failedproperty.You can pass a tuple of exception classes that should be caught and transformed
to a failed Result in the decorator parameterexceptions:fromresult_wrapperimportwrap_result@wrap_result(exceptions=(ValueError,))deffunction1():raiseValueError("This exception will be caught and transformed to a failed result.")@wrap_result(exceptions=(ValueError,))deffunction2():raiseTypeError("This exception will not be caught. The exception is thrown normally.")assertfunction1().failedisTruefunction2()# this will throw TypeError !!!Another way of returning a failed result is to use theResultWrapper.make_failedfunction:fromresult_wrapperimportwrap_result,ResultWrapper@wrap_resultdeffunction1():returnResultWrapper.make_failed()assertfunction1().failedisTrueOptionally you can pass any object to themake_failedfunction to pass some error information to the caller.
In the case of a thrown exception, the error information is set to the arguments to the constructor of the exception:fromresult_wrapperimportwrap_result,ResultWrapper@wrap_resultdeffunction1():returnResultWrapper.make_failed({"ErrorID":1})@wrap_result(exceptions=(ValueError,))deffunction2():raiseValueError({"ErrorID":1})assertfunction1().error_information.get("ErrorID")==1assertfunction2().error_information.get("ErrorID")==1To return a successful result, return an instance ofResultorResultWrapper.make_succeeded:fromresult_wrapperimportwrap_result,Result,ResultWrapper@wrap_resultdeffunction1():returnResult(result1="value1",result2=2)@wrap_resultdeffunction2():returnResultWrapper.make_succeeded(result1="value1",result2=2)result=function1()assertresult.result1=="value1"assertresult.result2==2result=function2()assertresult.result1=="value1"assertresult.result2==2
Package: resumableds
resumabledsA Python class that supports Data Science projects.resumableds supports you in writing data science scripts including save/resume functionality.Data can be saved and resumed avoiding unnessary retrievals of raw data from data storages.The data directory structure is inspired by cookiecutter-data-science (https://drivendata.github.io/cookiecutter-data-science/).The class also supports the statement 'Analysis is a DAG' (https://drivendata.github.io/cookiecutter-data-science/#analysis-is-a-dag).resumableds is written in pure Python and it is intended to be used within Jupyter notebooks.
It however can also be useful in Python scripts or script pipelines.Exampleproj1 = RdsProject('project1') # create object from class (creates the dir if it doesn't exist yet)
proj1.raw.df1 = pd.DataFrame() # create dataframe as attribute of proj1.raw (RdsFs 'raw')
proj1.defs.variable1 = 'foo' # create simple objects as attribute of proj1.defs (RdsFs 'defs')
proj1.save() # saved attributes of all RfdFs in proj1 to diskThis will result in the following directory structure (plus some overhead of internals):<output_dir>/defs/var_variable1.pkl<output_dir>/raw/df1.pkl<output_dir>/raw/df1.csvNote, pandas dataframes are always dumped as pickle for further processing and as csv for easy exploration. The csv files are never read back anymore.Later on or in another python session, you can do this:proj2 = RdsProject('project1') # vars and data are read back to their original names
proj2.defs.variable1 == 'foo' # ==> True
isinstance(proj2.raw.df1, pd.DataFrame) # ==> True
Package: resume-as-code
Resume-as-codeTODO: update ReadMeDescriptionThis project is aimed at reducing the work required to create resumes.In the business context, it is often required to have resumes in all kinds of different formats, styles, etc.We want our team members at Dataroots to spend as little as time possible on formatting their resume(s), and have the ability to generate their resume in an efficient fashion.For this, resume-as-code was created.
This resume generator combines technologies such as Jinja, yaml and allows the decoupling of creating a resume from formatting a resume.The idea is that it is possible to define template, such as LaTex, Word, Markdown, etc. and using the same YAML-file, all different kinds of resumes can be generated.InstallationThis is a Python-based tool.It is developed on Python 3.9.1 and it hasn't been tested on other python versions.For the remainder of this installation and usage guide, it is assomed that you have python version 3.9.1 installed, together with pip@21.3.1.Set up:Download the code from githubgitclonegit@github.com:datarootsio/resume-as-code.gitInstall the requirements inrequirements.txtpipinstall-rrequirements.txtGenerate Google Drive credentials inhttps://console.cloud.google.com/apis/dashboardStore the credentials in a secrets folder.Create an environment file in /src (execute from project root).Add the path to the credentials folderAdd a path to the file that will be used to store the Google Drive token in.Add the location of the resume_schemaAdd the allowed image formattouch./src/.env
cat<< EOT >> ./src/.envCREDENTIALS_FILENAME=/path/to/secrets/credentials.jsonTOKEN_FILENAME=/path/to/secrets/token.jsonSCHEMA_FILENAME=/path/to/resume_schema.yamlIMAGE_FORMATS='["image/png","image/jpeg","image/jpg"]'EOTUsageCurrently, the tool only supports Word templates.There is 1 non-optional argument, namely the location of the resume (yaml-file) on your disk.Local template, local targetUse a local template on diskStore the template locally on diskExample usage:pythonmain.py/path/to/resume.yaml--template_location/path/to/template.docx--target_location/path/to/target.docxLocal template, target on driveUse a local template on diskStore the template on your google drive.If we do no specifytarget_location, the generated file is sent to Google DriveExample usage:pythonmain.py/path/to/resume.yaml--template_location/path/to/template.docxTemplate on driveUse a template from your driveThis is done by passing the name of the docx-template (without the extension) to the commandExample usage:pythonmain.py/path/to/resume.yaml--template_namename-of-template-on-driveVerbosityVerbosity can be enabled by passing the--verbose- or-v-flag to the tool.
Package: resumeback
A Python library for using callbacks to resume your code.resumebackprovides a utility function decorator
that enables using callback-based interfaces
ina single line of execution– a single function.Documentationhttps://fichtefoll.github.io/resumeback/Installation$pipinstallresumebackExample UsagefromthreadingimportThreadfromresumebackimportsend_selfdefask_for_user_input(question,on_done):defwatcher():result=input(question)on_done(result)Thread(target=watcher).start()@send_selfdefmain(this):# "this" is a reference to the created generator instancearbitrary_value=10# Yield pauses execution until one of the generator methods is called,# such as `.send`, which we provide as the callback parameter.number=yieldask_for_user_input("Please enter a number",this.send)number=int(number)print("Result:",number*arbitrary_value)if__name__=="__main__":main()DevelopmentRequires Python, poetry, and GNU Make.Usemake helpto show the available targets.poetryis used for dependency and virtualenv management.toxis used as a test runner for multiple isolated environments.flake8is used for code linting.Github Actionsare used for CI.AcknowledgementsProject started initially after aforum postfrom@Varriounton the Sublime Text forum.
I just took his idea “to the next (abstraction) level”
and made it more convenient to use.
Package: resume-classification
Resume ClassificationObjectiveAim of this project is to train a set of resumes of specific domain and create a machine learning model
to predict the unseen resumes.Currently the model is trained using logistic regression on these four domain:JavaCloudBig DataMachine LearningResumes are read using a package calledtikawhich supports many file formats including the following popular ones:- doc
- docx
- pdfNOTE: To know more about tika visit the following link:https://pypi.org/project/tika/Installationpip install resume_classificationDependenciesnumpy==1.17.3pandas==0.25.1tika==1.24nltk==3.4.5Python version`Python 3.7.4`Project GuidelinesTrainIn order to train a new set of resumes, the project ought to have a defined folder structure given below:Then run the following commands:from resume_classification import traintrain(path-to-resumes-folder)OutputThe output will consist of the following metricsModel AccuracyF1 ScoreConfusion MatrixPredictUse the following command:from resume_classification import predictpredict(path-to-resumes)NOTEfor predict module, the path to resume will contain all the unseen resumes in a single folder.OutputThe output will be a dataframe consisting offile nameandpredicted domain.
Package: resumejson-converter
JSON Resume ConverterA small package for convert json resume with templating to html and pdf.WARNING: For the moment the filters are very specific to my template who is not
in this repo at this time.WARNING: Many of thing in this code is only in French, like date generation,
phone number or some dates.InputAbout the JSON resume standard:https://jsonresume.org/schema/.TemplateAbout the jinja2 template:https://jinja.palletsprojects.com/en/2.10.x/OutputPDF file generated in out folder where you launch the code.
Package: resume-matcher
Resume MatcherA Python library for matching resumes with job description.InstallationYou can install the required dependencies using pip:pip install resume-matcherUsageHere's how you can use theresume_job_desc_matchfunction:from resume_matcher.matching import resume_job_desc_matchPath to the resume and job description filesresume_path = "My_Resume.docx"
job_desc_path = "Job_desc.docx"Call the resume_job_desc_match functionmatch_percentage = resume_job_desc_match(resume_path, job_desc_path)Print the match percentageprint("Match percentage:", match_percentage)Overall Code:from resume_matcher.matching import resume_job_desc_matchresume_path = "My_Resume.docx"job_desc_path = "Job_desc.docx"match_percentage = resume_job_desc_match(resume_path, job_desc_path)print("Match percentage:", match_percentage)Note:Please upload doc files of Job Description and Resume.
Package: resumeos
Easily bootstrap an OS project to fool HR departments and pad your
resume.InstallationThe old waygitclonehttps://github.com/melonmanchan/ResumeOScdResumeOSpythonsetup.pyinstallOr with PIPpipinstallresumeosTested with Python 2.7.10 on Ubuntu 15.10.UsageJust install the required dependancies as specified above, and runresumeos--name'My cool OS project'--output'Best project ever!'to bootstrap your very own totally unique OS, that prints the output
message and halts.Example outputCreditsThis project is based completely on the works of the very handsome and
talented Philipp Oppermann and his ‘Writing an OS in Rust’-bookhttp://os.phil-opp.com/
Package: resume-parser
Resume parserPremium resume parsing services have been moved to [Resume-Parser](https://www.resume-parser.com/application/resumes). Please try the demo for free and give us your [feedback](https://www.resume-parser.com)Premium resume parsing services have been moved toResume-Parser.
Please try the demo for free and give us yourfeedbackA resume parser used for extracting information from resumesBuilt with ❤︎ and :coffee: byKumar
RajwaniandBrian
NjorogeFeaturesExtract nameExtract emailExtract mobile numbersExtract skillsExtract total experienceExtract college nameExtract degreeExtract designationExtract company namesInstallationYou can install this package usingpipinstallresume-parserFor NLP operations we use spacy and nltk. Install them using below
commands:# spaCypython-mspacydownloaden_core_web_sm# nltkpython-mnltk.downloaderstopwordspython-mnltk.downloaderpunktpython-mnltk.downloaderaveraged_perceptron_taggerpython-mnltk.downloaderuniversal_tagsetpython-mnltk.downloaderwordnetpython-mnltk.downloaderbrownpython-mnltk.downloadermaxent_ne_chunkerSupported File FormatsPDF and DOCx and TXT files are supported on all Operating SystemsUsageImport it in your Python projectfromresume_parserimportresumeparsedata=resumeparse.read_file('/path/to/resume/file')ResultThe module would return a dictionary with result as follows:{'degree': ['BSc','MSc'],
     'designition': [
         'content writer',
         'data scientist',
         'systems administrator',
     ],
     'email': 'maunarokguy@gmail.com',
     'name': 'Brian Njoroge',
     'phone': '+918511593595',
     'skills': [
         'Python',
         ' C++',
         'Power BI',
         'Tensorflow',
         'Keras',
         'Pytorch',
         'Scikit-Learn',
         'Pandas',
         'NLTK',
         'OpenCv',
         'Numpy',
         'Matplotlib',
         'Seaborn',
         'Django',
         'Linux',
         'Docker'],
     'total_exp': 3,
     'university': ['gujarat university', 'wuhan university', 'egerton university']}
Package: resume-pycli
resume-pycliCLI tool to build a beautiful resume from aJSON
Resumefile.This is a Python port ofresume-cli.FeaturesValidate yourresume.jsonagainst schemaExport your resume to HTMLExport your resume to PDFCustomize the theme of your HTML and PDF exportsRun a local HTTP server to preview the HTML exportCreate an initalresume.jsonwith placeholder values to get startedInstallationWithpipx:pipx install resume-pycliUsageUsage: resume [OPTIONS] COMMAND [ARGS]...

  CLI tool to easily setup a new resume.

Options:
  --help  Show this message and exit.

Commands:
  export    Export to HTML and PDF.
  init      Initialize a resume.json file.
  serve     Serve resume.
  validate  Validate resume's schema.
  version   Show application version.Export your resume with a custom theme, for exemple one located in./themes/my-beautiful-theme:resume export --theme my-beautiful-themeIf you want to export custom version of your resume, for example a shorter one
located at./resume.short.json, to PDF only:resume export --resume resume.short.json --pdfThemesYou can put your theme inthemes/<name>next to yourresume.jsonfile. It
usesJinjaas templating engine.
Take a look at theincluded
themesthat you can take as example to write your own.Since it uses Jinja, it is not compatible with"official" community
themes.
Package: resumeschema
resumeschemais ajson-schemavalidator for theresume-schemaspec.resumeschemais mostly just a wrapper aroundjsonschema.Installation$[sudo]pipinstallresumeschemaAPIvalidate(instance)Check if the providedinstanceis valid under theresume-schemaspec.Returns nothing.Raises ajsonschema.ValidationErroron error.importresumeschemainstance={'basics':{'name':'Resume Schema',},}resumeschema.validate(instance)is_valid(instance)Check if the providedinstanceis valid under theresume-schemaspec.ReturnsTrueif validFalseif not.importresumeschemainstance={'basics':{'name':'Resume Schema',},}ifresumeschema.is_valid(instance):print'It is valid!'iter_errors(instance)Get an iterator to iterate anyjsonschema.ValidationErrorsfrom the providedinstance.Returns an iterator ofjsonschema.ValidationErrors.importresumeschemainvalid_instance={'basics':{# `first_name` is not a supported field'first_name':'Resume Schema',},}forerrorinresumeschema.iter_errors(invalid_instance):printerror.messagevalidatorAn instance ofjsonschema.Draft4Validatorto use as you so choose.importresumeschemainstance={'basics':{'name':'Resume Schema',},}resumeschema.validator.validate(instance)
Package: resumy
resumyFeaturesNow supports thejsonresumeformatA default theme already supportedEasy to create a theme or a config fileConfigs and schemas are both in yaml formatExports a pdfInstallpip install resumyIt may not work out of the box as some external dynamic libraries are necessary depending on your platform, please take a look at the weasyprint documentation page:https://doc.courtbouillon.org/weasyprint/stable/first_steps.htmlCommandsUsageresumy --helpInit a config fileresumy init -o myconfig.yamlThis creates a file that you can easily edit:basics:
  email: anakin@skywalker.com
  location:
    city: Mos Eisley
    countryCode: Tatooine
  name: Anakin Skywalker
  phone: 123-456-7890
  profiles:
  - network: Github
    url: https://github.com/alexlren
    username: alexlren
  - network: Linkedin
    url: https://www.linkedin.com/anakin
    username: anakin
  url: https://shaoner.com
education:
- area: Jedi / General
  institution: Jedi Academy
  startDate: '2011-01-01'
projects:
- description: a multiplatform gameboy engine
  keywords:
  - Rust
  - React.js
  name: padme
  url: https://padme.cc
skills:
- keywords:
  - Rust
  - Python
  name: Languages
work:
- highlights:
  - Killed a few rebels here and there
  - Tracked Jedi all around the galaxy
  - Practiced the force with my master Darth Sidious
  - Killed some younglings
  name: Empire
  position: Darth Vader
  startDate: '2016-08-01'And it makes it easier to support multiple languages (i.e. multiple config files)Build a resumeresumy build -o myresume.pdf myconfig.yamlCreate and use your own themeresumy theme mytheme -o /tmp/mythemeNow you can simply edit /tmp/mytheme/theme.html and /tmp/mytheme/theme.css, and use your custom theme with--themeoption.resumy build -o myresume.pdf --theme /tmp/mytheme myconfig.yamlDevelopmentCreate a virtual envpython -m venv venv
source venv/bin/activateInstall dependenciespip install -e .Create a config filecp config.example.yaml my_config.yamlorpython src/resumy/resumy.py initRunpython resumy/resumy.py build -o my_resume.pdf my_config.yamlMigrating from v0.0.2It's now possible to transform the previous resumy format into the jsonresume standard:resumy normalize my_config.yaml -s jsonresume.yaml -o my_new_config.yamlYou can still use the original format, it is internally transformed into the new formatresumy build -o myresume.pdf --schema resumy.yaml myconfig.yamlThe old theme is not supported anymore, but it's not that hard to migrate it yourself.TestsLinting with flake8tox -e flake8Type checking with mypytox -e mypy
Package: resurrector
ResurrectorResurrector helps you to restore your backed-up MySQL Databases to any specified instance.PipYou can install this package from pip by running the following command :pip install resurrectorProsRestore multiple databases at onceNo need o know CLI commands to treat backup filesNo need to know an OS to handle this processYou can specify which databases should be restored and exclude dbs which are should not.You can restore only missing databases in the instance (no need to treat the existing ones)Automatic decompressionGood to knowDepending on your MySql instance settings (such as user permissions or global variable specifications) you may needto deal with input parameters of the Ressurector (see below).ParametersName | Description | Type | Default--- | --- | --- | ---source | Input Folder (.zip or just normal folder) | string | -host | MySQL Instance Ip | string | localhostuser | MySQL Instance User | string | rootport | MySQL Instance Port | integer | 3306skip_dbs | List of Databases to skip | array | Noneskip_existing | Should it skip the existing Databases? | boolean | Truemysql_global_vars | Global variables which should be run before each restoration | string (if multiple then semicolon sepearated) | SET @@GLOBAL.GTID_PURGED='';exclude_sql_parts | SQL contents which should be removed | string | SET GLOBAL max_allowed_packet=268435456;charset | Database charset | string | utf8collate | Database collation | string | utf8_general_cidebug | Debug the process on console | boolean | FalseHow it worksResurrector reads a folder (either as zipped or not) and searches for .gz files in it, these must contain .sql files which werebacked up in your servers either automatically or manually. After connecting to the given database instance it creates these databases byand "fills" them one by one (executes the whole .sql file (query) on each respective database).Simple usageimportresurrectorresurrector.resurrect(source='files/2022-07-06',host='localhost',user='root',password='',port=3306,skip_existing=True,debug=True)