Saravanan666/pypi-org huggingface dataset:
Package: prosopopee
ProsopopeeProsopopee. Static site generator for your story.Make beautiful customizable pictures galleries that tell a story using a static website generator written in Python. You don't need to care about css, code and presentation, manage your contents in YAML file and Prosopopee will take care about the rest.Prosopopee is sections oriented, make it very flexible, many kinds of section already available:ParallaxGroup of pics (gallery)ParagraphIframe (Youtube, Maps, etc..)QuoteAnd moreScreenshotsFeaturesProsopopee currently supports:Automatic generationLightweightThumbnails & multiple resolutions for fast previews (JPEG progressive)Videos supportMobile friendlyCaching for fast renderingMulti level gallerySupport themes (default, material, light)Password access (encrypt page)Image lazy loadingNight ModeCompletely static output is easy to host anywhereHackableExamplesYou can find example usages here:http://surleschemins.frhttp://media.faimaison.net/photos/galerie/https://www.thebrownianmovement.org/http://outside.browny.pinkhttp://www.street-art.meCode exampletitle:Titledate:2015-12-18cover:P1070043-01-01.jpegsections:-type:full-pictureimage:P1060979-01-01.jpegfixed:truetext:title:My Storysub_title:some subtitledate:2015-12-18-type:paragraphtitle:Beautiful Titletext:Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor-type:pictures-groupimages:--P1060938-01-01.jpeg-P1060946-01-01.jpeg-P1060947-01-01.jpeg-P1060948-01-01.jpegUsageprosopopeeprosopopeetestprosopopeepreviewprosopopeedeployprosopopeeautogen(-d<folder>|--all)[--force]prosopopee(-h|--help)prosopopee--version

Options:testVerifyallyouryamldatapreviewStartpreviewwebserveronport8000deployDeployyourwebsiteautogenGenerategalleryautomaticaly-h,--helpShowthisscreen.--versionShowversion.Dockerhttps://hub.docker.com/r/beudbeud/prosopopee/LicenceGLPv3Documentationhttp://prosopopee.readthedocs.org/en/latest/IRCchannel : irc.freenode.net#prosopopee
Package: prospect
Prospectprospectis a Python package for simulating archaeological field surveys. It was originally developed byJacob Deppenin research associated with theDigital Archaeology Research Labat the University of Washington.DocumentationRead theProspect User Guidefor the latest documentation, including API docs.Reporting BugsAs with any software, bugs are bound to surface. If you discover a bug inprospect, please create aNew Issue on GitHubusing the Bug Report template.ContributingContributions are welcome but please contactJacob Deppento coordinate.
Package: prospecting
Google Sheets with Pandas dataframes, useful when ‘prospecting’ in analytics work and hacking.SetupCreate or select a project inGoogle’s developer consoleAlso, you will need to enable the APIs you plan to useGet aclient_secrets.jsoncredentials file from thecredentials sectionSelectOAuth client IDfrom the dropdown in theAPI access paneLoad theprospectingmodule in a Python session to initialize the~/.prospecting/folder in your home directoryPlace theclient_secrets.jsonfile in the~/.prospecting/credentials/directoryLoad an API class in a Python session, then run apiclass.authenticate() and follow stepsYou only need to setup authentication once per API unless creds changeExamples:import prospecting as p—Use stats sheet to store stats and misc statistics (scopelist defaults to read-only, so pass scopes for writing):ss_stats = p.SheetsApi(spreadsheetid = 'PASTE_GOOGLE_SHEETID_HERE',
                       scopelist=['https://www.googleapis.com/auth/spreadsheets',
                                  'https://www.googleapis.com/auth/drive.metadata'])
ss_stats.authenticate()
ss_stats.update('Sheet1', somedataframe)—Use a reference sheet to provide a named entity list (or stopwords, vocabulary) for NLP preprocessing:ss_reference = p.SheetsApi(spreadsheetid = 'PASTE_GOOGLE_SHEETID_HERE',
                           scopelist=['https://www.googleapis.com/auth/spreadsheets',
                                      'https://www.googleapis.com/auth/drive.metadata'])
ss_reference.authenticate()
named_entity_list = list(ss_reference.get('ne!A:B').iloc[:,0].values)—Get keywords sheet as dataframe, filter, take sampled subset, upload new df to other tab in spreadsheet:ss_kw = p.SheetsApi(spreadsheetid = 'PASTE_GOOGLE_SHEETID_HERE',
                    scopelist=['https://www.googleapis.com/auth/spreadsheets',
                               'https://www.googleapis.com/auth/drive.metadata'])
ss_kw.authenticate()

#  Get data using spreadsheet syntax like ('sheetname') or ('sheetname!A:B25')
df_query = ss_kw.get('queries')
df_query_subset = df_query[(df_query['raw_len'] > 1) &
                           (df_query['reject'] != 1)]

#  Take a subsample of data
df_query_subset_sample = df_query_subset.sample(frac=0.5)
df_query_subset_sample.reset_index(drop=True, inplace=True)

#  Update 'sheetname' with dataframe object
ss_kw.update('queries_shuffled', df_query_subset_sample)Key changes between 0.1.4 and 0.1.2:Switched order of input arguments for ss.update() function:From
   ss.update(dataframe, 'sheetname')
To
   ss.update('sheetname', dataframe)Removed Docker files to simplify
Package: prospector2html
prospector-htmlHTML and JSON report generator fromprospectorandsemgrepstatic analyzer tools JSON output.
Handy when using with GitLab CI.Synopsisprospectorpip3 install prospector
pip3 install prospector2html
cd <python-project-sources-dir>
prospector --no-style-warnings --strictness medium --output-format json > prospector_report.json
prospector-html --input prospector_report.json
cat prospector-html-report.htmlsemgreppip3 install prospector2html
cd <project-sources-dir>
docker run --rm -v "${PWD}:/src" returntocorp/semgrep:latest semgrep scan --json --output semgrep-native-report.json --config=auto
prospector-html --input semgrep-native-report --output filtered-report.html --filter semgrep
cat filtered-report.htmlGitLab CI SASTpip3 install prospector2html
cd <project-sources-dir>
docker run --rm -v "${PWD}:/src" returntocorp/semgrep:latest semgrep ci --gitlab-sast --output gl-sast-report.json --config=auto
prospector-html --input gl-sast-report.json --output filtered-report.json --json --filter gitlab-sast
cat filtered-report.jsonMessage filteringSometimes it is necessary to filter analyzer results by content of the message,
rather than filter-out the whole error class by it's suppression.
For example prospector would always complains at usage of_metamember in Django projects.In this case one could fileter such messages by specifing it in prospector-html config file..prospector-html.yamlby default. See details in the source of sample config or use following example:# cat .prospector-html.yaml
filter:
  message:
      # Filter by exact match
    - "Message to filter"
    - Oter message to filter
  message_re:
      # Regexps to filter
    - 'Exactly one space required after comma.*'
    - 'Exactly one space required before assignment.*'TODO???.
Package: prospector-profile-duplicated
Prospector profile duplicateProfile that can be used to disable the duplicated or conflict rules between Prospector tools and also
external tools like and Black, isort and docformatter.The profile considers that you are using Pylint, pyupgrade, Black, isort, docformatter and autoflake and remove conflict or duplicate with them.Usageinherits:# Get All-duplicated# Get for individual tools-duplicated:black-duplicated:isort-duplicated:pyupgrade-duplicated:pylint-duplicated:docformatter-duplicated:autoflakeContributingInstall the pre-commit hooks:pipinstallpre-commit
pre-commitinstall--allow-missing-config
Package: prospector-profile-utils
Prospector profile utilsIt contains some utility Prospector profiles.Usagepipinstallprospector-profile-utilsThen, in your.prospector.yamlfile, you can use the profiles like this:inherits:-utils:base-utils:fix-utils:no-design-checksContributingInstall the pre-commit hooks:pipinstallpre-commit
pre-commitinstall--allow-missing-config
Package: prospectpredictor
This is a pretty simple prospectivity prediction package that predicts the
prospectivity of an element based on how close it is to different
bedrock units.Overview of PackageThe package utilizes 3 main classes.PrepShapeshandles exploring and prepping a shapefile and determining the project boundary. It can read in a single shapefile (using geopandas) and then you can use it to select the polygons of interest.RasterTemplateuses the previously initializedPrepShapes()class to help you setup the raster template used by the predictor to predict prospectivity at a specified location.PredictByDistancethe predictor class that predicts the likelihood based on distance to shapes of interest and the weighting schema architect. The predictor class uses the previously initialized PrepShapes() and RasterTemplate() classes. Only one prediction architect is currently implemented.Prediction Weighting SchemaCurrently this package uses a pseudo variogram style weighting schema with the following model (for locationiand as an example 2 distances)Generating a prospectivity heat mapUsing the package you can generate a heat map with liklihood of finding the element (based on a distance from 2 or more shape categories). The predictor generates prediction values ranging from 0, being least likely (i.e. 0%), to 1, being most likely (i.e. 100%). As an example here is a heat map generated from the included dataset.ExampleAn example.ipynb is included in the repo to demostate how to use the package.Datasetthe included dataset is from theBritish Columbia Geologica Survey.
Package: prosper-nn
Prosper_NNProblem-Specific Pre-Structuring of Neural NetworksAccurate data-driven forecasts can provide a crucial advantage in many application areas. One of the methods with the most promising results in forecasting time series are neural networks. However, especially in macro-economic applications, it can be difficult and time-consuming to adapt state-of-the-art neural network architectures in a way that leads to satisfying results. For instance, the final prices of materials and stocks result from a highly complex interplay between supply and demand. Additionally, there is often only one (albeit long) historical time series available for training which makes correlations in the data difficult to detect.Under these circumstances, applying state-of-the-art neural networks architectures successfully poses a great challenge. Pre-structuring the models can solve this problem. For this purpose, Zimmermann, Tietz and Grothmann (Neural Networks: Tricks of the Trade, 2012) propose recurrent architectures for various time series problems that help recognize correlations. They recommend Error-Correction Neural Networks (ECNNs), Historical-Consistent Neural Networks (HCNNs) and Causal-Retro-Causal Neural Networks (CRCNNs). One of the main ideas of the pre-structuring is embedding the model in a larger architecture in order to use the past prediction errors for predicting the next time step. The three approaches mentioned use this idea and apply it in different settings. So far, the proposed architectures are not publicly available in common machine learning frameworks. Therefore, we have implemented the models in PyTorch. This way, we can easily test them on diverse datasets.
In this package the neural network architectures developed by Hans-Georg Zimmermann are implemented in PyTorch.
The full documentation can be found herehttps://iis-scs-a.pages.fraunhofer.de/prosper/prosper/. There are also tutorials that show how to work with the package.
Package: prosper-shared
prosper-sharedShared build files for the Python Prosper librariesprosper_shared.autohooksPre-commit hooks for use withautohooks.prosper_shared.omni_configUtil for defining, parsing, merging, validating, and using configs from various sources, including file-based configs,
environment variables, and command-line arguments. This will probably be factored out into an independent library.prosper_shared.serdeUtil for serializing and deserializing Python objects based on type annotations.ConfigsAvailable config values:prosper-shared.serde.parse-dates:default:truedescription:Date values represented as strings should be parsed into `date` and `datetime` objects.Supports ISO-8601-compliant date strings.optional:falsetype:boolprosper-shared.serde.parse-enums:default:truedescription:Enum values represented as strings should be parsed into their respective types.optional:falsetype:boolprosper-shared.serde.use-decimals:default:truedescription:Floating point values should be parsed as decimals instead of floats.optional:falsetype:boolFeedbackThis project usesGitHub issuesfor feature requests and bug reports.ContributingThis project usesPoetryto manage dependencies and building. Follow the instructions
to install it. Then usepoetry install --all-extrasto install the project dependencies. Then runpoetry run autohooks activateto set up the pre-commit hooks. Please ensure the hooks pass before submitting a pull request.
Package: prosperworks
Prosperworks ApiA python based api wrapper forProsperworks.InstallationFrom pip (recommended):pip install prosperworksFrom source:pip installgit+git://github.com:tizz98/prosperworks-api.git@masterModelsprosperworks.models.CompanyFieldsidnameaddress (prosperworks.models.Address)assignee_idcontact_type_iddetailsemail_domainphone_numbers (list ofprosperworks.models.PhoneNumber)socials (list ofprosperworks.models.Social)tags (list of strings)websites (list ofprosperworks.models.Website)date_createddate_modifiedcustom_fields (list ofprosperworks.models.CustomField)Methodssearch(search for companies), available kwargs are:page_numberpage_sizesort_bysort_directiontagsageassignee_idscitystatepostal_codecountryminimum_interaction_countmaximum_interaction_countminimum_interaction_datemaximum_interaction_dateminimum_created_datemaximum_created_dateminimum_modified_datemaximum_modified_datecreate(create new company), available kwargs are:nameaddressassignee_idcontact_type_iddetailsemail_domainphone_numbers[]socials[]tagswebsites[]date_createddate_modifiedcustom_fields[]update(update current company),will use currently set values
to updatedelete(delete current company)Examples:fromprosperworksimportapifromprosperworks.modelsimportCompanyapi.configure('key','your.name@example.com')forcompanyinCompany.search():printcompany.namenew_co=Company.create(name='New Co.')printnew_co.idnew_co.name='New Co. (updated)'new_co.update()new_co.delete()prosperworks.models.LeadFieldsidnameaddress (prosperworks.models.Address)assignee_idcompany_namecustomer_source_iddetailsemailmonetary_valuephone_numbers (list ofprosperworks.models.PhoneNumber)socials (list ofprosperworks.models.Social)statustags (list of strings)websites (list ofprosperworks.models.Website)date_createddate_modifiedcustom_fields (list ofprosperworks.models.CustomField)Methodssearch(search for companies), available kwargs are:page_numberpage_sizesort_bysort_directiontagsageassignee_idscitystatepostal_codecountryminimum_interaction_countmaximum_interaction_countminimum_interaction_datemaximum_interaction_dateminimum_created_datemaximum_created_dateminimum_modified_datemaximum_modified_datecreate(create new company), available kwargs are:nameaddressassignee_idcompany_namecustomer_source_iddetailsemailmonetary_valuephone_numbers[]socials[]statustagstitlewebsites[]date_createddate_modifiedcustom_fields[]update(update current company),will use currently set values
to updatedelete(delete current company)convert(convert a lead), available kwargs are (all optional):personcompany (prosperworks.models.Company)opportunityExamples:fromprosperworksimportapifromprosperworks.modelsimportCompany,Leadapi.configure('key','your.name@example.com')new_co=Company.create(name='New Co.')printnew_co.idlead=Lead.create(name='John Doe')lead.name='Jane Doe'lead.update()printlead.idlead.convert(company=new_co)
Package: prosphera
This tool utilises sophisticated PCA with a cosine kernel to generate informative visualisations of multi-dimensional data in three-dimensional space.  Following the PCA process, the data is normalised by shifting each point to a centroid and making it the unit norm. To enhance the visualisation, vectors are additionally scaled with precision to move the farthest points closer to the surface of the sphere. The outcome is an engaging and instinctive representation of the data in spherical format. The tool initiates interactive visualisations in a new tab of your default web browser, facilitating data exploration and analysis.Basic UsageInit visualizerimportpandasaspdfromsklearnimportdatasetsfromsklearn.datasetsimportmake_blobsfromprosphera.projectorimportProjector# Instantiate the classvisualizer=Projector()Generated dataset# Generate datadata,labels=make_blobs(n_samples=5000,centers=50,n_features=25,random_state=1234)# Call the visualize method to generate and display the visualizationvisualizer.project(data=data,labels=labels)Browser tab:Wine datasetwine=datasets.load_wine()visualizer.project(data=wine['data'],labels=wine['target'])Browser tab:Cancer datasetcancer=datasets.load_breast_cancer()visualizer.project(data=cancer['data'],labels=cancer['target'])Browser tab:Digits dataset (no labels)digits=datasets.load_digits(n_class=5)visualizer.project(data=digits['data'],meta=digits['target'])Browser tab:Digits dataset (apply labels)visualizer.project(data=digits['data'],labels=digits['target'])Browser tab:Housing dataset (labels from 'age')housing=datasets.fetch_california_housing()visualizer.project(data=housing['data'],labels=pd.qcut(housing['data'][:,1],5).astype(str))Browser tab:Change rendererYou can set renderer asvisualizer = Projector(renderer='iframe')to save the plot locally as HTML.
Available renderers:'jupyterlab''vscode''notebook''kaggle''colab'
andothers
Package: prospr
Prospr: The Protein Structure Prediction ToolboxCreator:Okke van EckProspr is a universal toolbox for protein structure prediction within the
HP-model.
At the core, Prospr offers an easy-to-use Protein data structure, which can be
used to simulate protein folding.
It also offers algorithms, datasets and visualization functions.
The Protein data structure tracks many properties when folding the protein.
This includes tracking the number of conformation changes, which makes it
possible to determine the relative hardness of a protein for a specific
algorithm.
This allows for a fair comparison between different algorithms.So far, only square lattices are supported in n-dimensions.
The amino acids can only be placed in the corners of the squares and have to be
one unit distance away from the previously placed amino acid.The Python package is based on a C++ core, which gives Prospr its high
performance.
The C++ core is made available as a separate zip file to facilitate
high-performance computing applications.
See the C++ core section below for direct links to the core.Installation and documentationThis package can simply be installed via pip by running:pipinstallprosprA quickstart and reference documentation can be found atprospr.readthedocs.io.
The PDF version of the complete documentation can be foundhere.ArchivesAll the C++ core files and datasets are also available as compressed archives.
See the subsections below for direct links.C++ coreAll the core code which prospr runs on, is available as a compressed archive.
The folderarchivescontains a.zipand
a.tar.gzarchive.DatasetsThe complete collection of datasets is available as a compressed archive in thearchivesfolder. It is available as a.zipand a.tar.tzarchive.Future workThis toolbox could be used for other protein folding problems within discrete
models.
It would be a great extension to support different models by creating a modular
amino acid.LicenseThe used license is the GNU LESSER GENERAL PUBLIC LICENSE.
A copy can be found in theLICENSEfile on GitHub.
Package: prosrs
ProSRS algorithmProgressive Stochastic Response Surface (ProSRS) is a parallel surrogate-based optimization algorithm for optimizing noisy expensive functions. This algorithm utilizes a radial basis function (RBF) as the surrogate, and adopts stochastic response surface (SRS) framework to balance exploitation and exploration. Compared to theoriginal parallel SRS work, the novelties of this algorithm includeIntroducing a new tree-based technique, known as the "zoom strategy", for efficiency improvement.Extending the original work to the noisy setting (i.e., an objective function corrupted with random noise) through the development of a radial basis regression procedure.Introducing weighting to the regression for exploitation enhancement.Implementing a new SRS that combines the two types of candidate points that were originally proposed in the SRS work.ProSRS algorithm is configured in a master-worker structure, where in each optimization iteration, the algorithm (master) constructs a RBF surrogate using the available evaluations, then proposes new points based on the constructed RBF, and finally distributes the tasks of evaluating these points to parallel processes (workers).Compared to the popular Bayesian optimization algorithms, ProSRS is able to achieve faster convergence on some difficult benchmark problems, and is orders of magnitude cheaper to run. Moreover, ProSRS enjoys asymptotic convergence gaurantees. The common applications of this algorithm include efficient hyperparamter tuning of machine learning models and characterizing expensive simulation models.InstallationPython dependencies:numpy:http://www.numpy.orgscipy:https://www.scipy.orgmatplotlib:https://matplotlib.orgscikit-learn:https://scikit-learn.org/stable/pyDOE:https://pythonhosted.org/pyDOE/pathos:https://pypi.org/project/pathos/To installprosrspackage, type and run the following:pip install prosrsNote:The abovepipmethod should work for most users. If a user encounters any installation problems including import errors or warnings, please refer to theWiki pagefor possible solutions.Getting startedAfter having successfully installed theprosrspackage, users are ready to use ProSRS algorithm for solving optimization problems. The easiest way of getting started is to read the tutorials in theexamplesdirectory, where different usages, from the basic level to the advanced level, are demonstrated through code examples. Of course, users are also encouraged to check out the source codes of the algorithm in theprosrsdirectory.
Package: prost
microRNAs (miRNAs) are an important class of small noncoding RNAs (~22nt) with
multiple and widespread regulatory roles in many development and disease
processes. We have created the tool Prost! to explore metazoan miRNA-enriched
RNA-Seq data. Prost! quantifies and normalizes expression levels (in the form
of Illumina reads) in several views that are suitable as input into
differential expression software such as DESeq2. Some key features of Prost!
include the identification of both candidate mirror-miRNAs and putative 5 ́/3 ́
mature miRNA arm switching. Of particular interest is the tightly regulated
post-transcriptional modification of miRNAs via multiple modes of regulation
during their biogenesis. Such modifications have been found to have important
consequences on characteristics such as Argonaute loading, target choice, and
miRNA turnover. Prost! provides valuable quantification across samples of
several classes of miRNA modifications, for example putative seed shifting,
seed editing, and untemplated 3 ́ nucleotide additions.