Saravanan666/pypi-org huggingface dataset:
Package: opml
Date:2007-03-20 08:30:21 -0700 (Tue, 20 Mar 2007)Version:5612Author:Nathan R. Yergler <nathan@yergler.net>Organization:Creative CommonsCopyright:2008, Nathan R. Yergler, Creative Commons;
licensed to the public under theMIT license.ContentsInstallationUsageDownloadopmlprovides simple support for readingOPMLfiles.  OPML is an XML-based format for describing outlines and is
often used as an interchange format for subscription lists.  This
package is intended as a light-weight, permissive parser.  It does
very little validation of the incoming OPML.InstallationThe Python OPML package and its dependencies may be installed usingeasy_install(recommended)$ easy_install opmlor by using the standard distutils setup.py:$ python setup.py installIf installing using setup.py,lxmlwill also need to be installed.easy_installwill manage this for you.UsageDocument PurposeThis document is intended to provide a set of literate tests
for theopmlpackage; it isnotintended to provide
thorough coverage of the OPML specification or semantics.  See
theOPML 2 Specificationfor
details on OPML.opmlcan parse OPML from a URI or from a local string.  For
example, to parse an example from the OPML validator:>>> import opml
>>> outline = opml.parse(
... 'http://hosting.opml.org/dave/validatorTests/clean/subscriptionList.opml')Elements in the OPML header can be accessed as attributes:>>> outline.title
'mySubscriptions.opml'
>>> outline.ownerName
'Dave Winer'
>>> outline.ownerEmail
'dave@scripting.com'Items in an OPML outline are stored in<outline>elements; these
are accessible via the standard Python sequence operators:>>> len(outline)
13
>>> outline[0]
<opml.OutlineElement object at ...>AnOutlineElementobject exposes the attributes associated with
the element as properties:>>> outline[0].text
'CNET News.com'
>>> outline[0].type
'rss'outlineelements may contain other outline elements:>>> len(outline[0])
0When parsing a feed with nested items, the sub-items are accessible
using the standard Python sequence operators:>>> nested = \
... opml.parse('http://hosting.opml.org/dave/spec/placesLived.opml')
>>> len(nested[0])
6
>>> nested[0][0].text
'Boston'
>>> len(nested[0][0])
2
>>> nested[0][0][0].text
'Cambridge'Download
Package: opml2json
opml2json is a simple python module that convert opml to jsoninstallationUsing pippip install opml2jsonfrom sources* git clone https://github.com/vishnu012/opml2json && cd opml2json

    * python3 setup.py installusagefor helppython3 -m opml2json -himport on another python filefrom opml2json.dump import write_json

write_json("input.opml","output.json")directly use on terminal / cmdpython3 -m opml2json -f filename.opml

python3 -m opml2json -f ./dir/filename.opml -o ./dir/output_filename.json
Package: opni-nats
opni-nats-wrapperThis repo contains shared code used to build the pypi packagehttps://pypi.org/project/opni-nats/which is used in several opni servicesTestinghave your nats server running in another terminal. For Mac user, you can do:brew install nats-server
nats-servertest the script: (assume your nats server is running on nats://0.0.0.0:4222)export NATS_SERVER_URL="nats://0.0.0.0:4222"
export NATS_USERNAME=
export NATS_PASSWORD=
cd src/opni_nats
python nats_wrapper.pyContributingWe usepre-commitfor formatting auto-linting and checking import. Please refer toinstallationto install the pre-commit or runpip install pre-commit. Then you can activate it for this repo. Once it's activated, it will lint and format the code when you make a git commit. It makes changes in place. If the code is modified during the reformatting, it needs to be staged manually.# Install
pip install pre-commit

# Install the git commit hook to invoke automatically every time you do "git commit"
pre-commit install

# (Optional)Manually run against all files
pre-commit run --all-files
Package: opni-nats-test
opni-nats-wrapperThis repo contains shared code used to build the pypi packagehttps://pypi.org/project/opni-nats/which is used in several opni servicesTestinghave your nats server running in another terminal. For Mac user, you can do:brew install nats-server
nats-servertest the script: (assume your nats server is running on nats://0.0.0.0:4222)export NATS_SERVER_URL="nats://0.0.0.0:4222"
export NATS_USERNAME=
export NATS_PASSWORD=
cd src/opni_nats
python nats_wrapper.pyContributingWe usepre-commitfor formatting auto-linting and checking import. Please refer toinstallationto install the pre-commit or runpip install pre-commit. Then you can activate it for this repo. Once it's activated, it will lint and format the code when you make a git commit. It makes changes in place. If the code is modified during the reformatting, it needs to be staged manually.# Install
pip install pre-commit

# Install the git commit hook to invoke automatically every time you do "git commit"
pre-commit install

# (Optional)Manually run against all files
pre-commit run --all-files
Package: opni-nats-yb
opni-nats-wrapperThis repo contains shared code used to build the pypi packagehttps://pypi.org/project/opni-nats/0.0.0.1/which is used in several opni servicesContributingWe usepre-commitfor formatting auto-linting and checking import. Please refer toinstallationto install the pre-commit or runpip install pre-commit. Then you can activate it for this repo. Once it's activated, it will lint and format the code when you make a git commit. It makes changes in place. If the code is modified during the reformatting, it needs to be staged manually.# Install
pip install pre-commit

# Install the git commit hook to invoke automatically every time you do "git commit"
pre-commit install

# (Optional)Manually run against all files
pre-commit run --all-files
Package: opnmf
opnmfThis package implements orthogonal projective non-negative matrix factorization as described in:Z. Yang and E. Oja, "Linear and Nonlinear Projective Nonnegative Matrix Factorization," in IEEE Transactions on Neural Networks, vol. 21, no. 5, pp. 734-749, May 2010, doi: 10.1109/TNN.2010.2041361.CitingIf you use this software, consider citing:Sotiras A, Resnick SM, Davatzikos C. Finding imaging patterns of structural covariance via Non-Negative Matrix Factorization. Neuroimage. 2015;108:1-16. doi:10.1016/j.neuroimage.2014.11.045
Package: opn-sonarqube-api
API Handler for SonarQube web service, providing basic authentication (which
seems to be the only kind that SonarQube supports) and a few methods to run sonarqube API.InstallationInstall from PyPI:pip install opn-sonarqube-apiCompatibilityThis package is compatible Python versions 2.7, 3.4, 3.5 and 3.6.
Probably others, but those are the ones against which we build (by Travis CI).UsageThe API handler is easy to use, you just need to initialize it with the
connection parameters (by defaultlocalhoston port9000without
authentication) and use any of the methods to get the required information or
create rules.Example getting projects with coverage and issues metrics:from sonarqube_api.sonar import SonarAPI

h = SonarAPI(user='admin', password='admin')
for project in h.get_resources_full_data(metrics=['coverage', 'violations']):
    # do something with project data...Since the actual response data from SonarQube server is usually paged, all
methods return generators to optimize memory as well retrieval performance of
the first items.You can also specify a single resources to fetch, but keep in mind that the resource methods
return generators, so you still need toget the next object:proj = next(h.get_resources_full_data(resource='some:example'))Sonar authentication tokens can also be used in place of username and password,
which is particularly useful when accessing the SonarQube API from a CI server,
as tokens can easily be revoked in the event of unintended exposure:h = SonarAPI(token='f052f55b127bb06f63c31cb2064ea301048d9e5d')Supported MethodsThe methods supported by the SonarAPI are:activate_rule: activate a rule for a given profile in the servercreate_rule: create a rule in the serverget_metrics: yield metrics definitionget_rules: yield active rulesget_resources_debt: yield projects with their technical debt by categoryget_resources_metrics: yield projects with some general metricsget_resources_full_data: yield projects with their general metrics and technical debt by category (merge of previous two methods)validate_authentication: validate authentication credentialscreate_groupsearch_groupupdate_groupdelete_groupcreate_permission_templateupdate_permission_templatesearch_permission_templatedelete_permission_templateadd_group_to_templatelist_groups_of_templateremove_group_from_templateadd_permission_to_userremove_permission_to_useradd_permission_to_groupremove_permission_to_groupsearch_permission_for_groupgenerate_tokenrevoke_tokenuser_tokensuser_currentget_metricsrestore_quality_profile_from_xmlcreate_quality_profileadd_project_to_quality_profiledelete_quality_profileactivate_ruleget_resources_debtget_resources_metricscreate_ruleget_rulesget_resources_full_datasettinggettinglist_qualitygatesshow_qualitygatescreate_qualitygatesdestroy_qualitygatescreate_condition_qualitygatescreate_quality_gate_from_jsondelete_condition_qualitygatesupdate_condition_qualitygates
Package: opo
📦 setup.py (for humans)This repo exists to providean example setup.pyfile, that can be used
to bootstrap your next Python project. It includes some advanced
patterns and best practices forsetup.py, as well as some
commented–out nice–to–haves.For example, thissetup.pyprovides a$ python setup.py uploadcommand, which creates auniversal wheel(andsdist) and uploads
your package toPyPiusingTwine, without the need for an annoyingsetup.cfgfile. It also creates/uploads a new git tag, automatically.In short,setup.pyfiles can be daunting to approach, when first
starting out — even Guido has been heard saying, "everyone cargo cults
thems". It's true — so, I want this repo to be the best place to
copy–paste from :)Check out the example!Installationcdyour_project# Download the setup.py file:#  download with wgetwgethttps://raw.githubusercontent.com/navdeep-G/setup.py/master/setup.py-Osetup.py#  download with curlcurl-Ohttps://raw.githubusercontent.com/navdeep-G/setup.py/master/setup.pyTo DoTests via$ setup.py test(if it's concise).Pull requests are encouraged!More ResourcesWhat is setup.py?on Stack OverflowOfficial Python Packaging User GuideThe Hitchhiker's Guide to PackagingCookiecutter template for a Python packageLicenseThis is free and unencumbered software released into the public domain.Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any means.
Package: opoca
OpocaOpoca library aims to drastically speed up producing proof of concepts (PoC) for machine learning projects.We define proof of concept as a small, quick and (not) dirty projects that results in:exploratory data analysislog of experiments along with modelsdeployable best modeldemo (jupyter notebook/streamlit app etc.)short report including results analysisThere are several challenges that ML Engineer faces given a task to build new PoC project:it's not easy to track and reproduce experimentsit's not easy to version and share datait's not easy to schedule jobs and not burn much money on trainingthere's a lot of code that can be reused between different PoCs such as:training logic for similar problemsevaluation logicplottinghyperparameters searchgeneric feature engineering transformationsThose are just few and a list is not complete without a doubt.PrerequisitesBefore you begin, ensure you have met the following requirements:You have installed the latest version ofpoetryInstalling OpocaOpoca is installable from PyPi by executing:pipinstallopocaOne may also use docker to build image:dockerbuild-topoca-fDockerfile.And run bash session interactively by executing:dockerrun-it--rm-v$PWD:/home-w/homeopocabashContributing to OpocaTo contribute toOpoca, follow these steps:Fork this repository.Create a branch:git checkout -b <branch_name>.Make your changes and commit them:git commit -m '<commit_message>'Push to the original branch:git push origin <project_name>/<location>Create the pull request.Alternatively see the GitHub documentation oncreating a pull request.ContributorsThanks to the following people who have contributed to this project:@plazowicz@pedrito87@mjmikulski@AdrianMaciej@dkosowski87ContactIf you want to contact me you can reach me atml-team@netguru.com.LicenseThis project uses the following license:Apache License, Version 2.0.
Package: opod
opod is a an orhestrator for Podman.ObjectivesProvide a replacement for docker-compose/podman-compose.Provide as close to 100% Test Coverage as possibleProvide clear documentation with full coverage of the API and example code.InstallingInstall and update usingpipenv:pipenvinstallopodA Simple Exampleopodup-dLinksWebsite:https://pypi.org/project/opod/Documentation:https://brianfarrell.gitlab.io/opod/License:https://www.gnu.org/licenses/agpl.htmlReleases:https://pypi.org/project/opod/Code:https://gitlab.com/brianfarrell/opod/Issue tracker:Test status:Test coverage:
Package: opof
OPOF, the Open-Source Planner Optimization Framework, is an open source framework for developing domains and algorithms for planner optimization. It provides a standard API to communicate between optimization algorithms and domains, along with a set of stable algorithm implementations.Our complete documentation is available athttps://opof.kavrakilab.org.OPOF is developed and maintained by theKavraki Labat Rice University.AlgorithmsOPOF includes the following stable algorithm implementations.Generator-Critic (GC)- Learns a conditional and stochastic generator using gradient-based deep learning techniques.SMAC- Learns an unconditional and deterministic generator using the latest Bayesian optimization techniques. Wrapper around the actively maintainedSMAC3Bayesian optimization library.PyPop- Learns an unconditional and deterministic generator using the latest evolution strategies. Wrapper around the actively maintainedPyPop7library for population-based (i.e. evolution strategy) techniques.We expect the list to grow with time, and welcome any additions.DomainsDomains are available as external packages maintained separately from OPOF. Some existing domain include:opof-grid2d- Simple navigation domains in a 2D grid world to help users familiarize with OPOF. They also act as a sanity check for developing optimization algorithms.opof-sbmp- Sampling-based motion planning (SBMP) domains for high-DoF robots to accomplish real-world picking tasks. They include the optimization of planner hyperparameters, sampling distributions, and projections.opof-pomdp- Online POMDP planning domains for 2D navigation under uncertainty. They include the optimization of macro-actions.We expect the list to grow with time, and welcome any additions.InstallationTo install OPOF's core library, runpip install opof.External packages containing additional domains and algorithms may be installed alongside OPOF. Please refer to the specific package's setup instructions.OPOF is officially tested and supported for Python 3.9, 3.10, 3.11 on Linux.APIBelow is an example of interacting with theRandomWalk2D[11]domain.fromopof_grid2d.domainsimportRandomWalk2Ddomain=RandomWalk2D(11)problems=domain.create_problem_set()planner=domain.create_planner()parameters=[pspace.rand(100).numpy()forpspaceindomain.composite_parameter_space()]foriinrange(100):result=planner(problems(),[p[i]forpinparameters],[])print(result["objective"])Our complete documentation is available athttps://opof.kavrakilab.org.CitingIf you use OPOF, please cite us with:@article{lee23opof,
  author = {Lee, Yiyuan and Lee, Katie and Cai, Panpan and Hsu, David and Kavraki, Lydia E.},
  title = {The Planner Optimization Problem: Formulations and Frameworks},
  booktitle = {arXiv},
  year = {2023},
  doi = {10.48550/ARXIV.2303.06768},
}LicenseOPOF is licensed under theBSD-3 license.OPOF is developed and maintained by theKavraki Labat Rice University, funded in part by NSF RI 2008720 and Rice University funds.
Package: opof-grid2d
opof-grid2dOPOFsimple navigation domains in a 2D grid world to help users familiarize with OPOF. They also act as a sanity check for developing optimization algorithms.opof-grid2dis maintained by theKavraki Labat Rice University.Installation$pipinstallopof-grid2dopof-grid2dis officially tested and supported for Python 3.9, 3.10, 3.11.Domain:RandomWalk2D[size]fromopof_grid2d.domainsimportRandomWalk2Ddomain=RandomWalk2D(11)# Creates a RandomWalk2D domain instance for a 11x11 board.DescriptionAn agent starts at a location (green) and moves in random directions according to some fixed probabilities until it reaches the goal (magenta).
When attempting to moveintoan obstacle (black) or the borders of the grid, a step is spent but the position of the agent does not change.
The probability of moving in each direction is fixed across all steps.Planner optimization problemWe want to find a generator that maps a problem instance $c$ (in this case, the combination of board layout and start and goal positions) into direction probabilities (in this case, vectors $\in \mathbb{R}^4$ with non-negative entries summing to $1$), such that the number of steps taken during the random
walk is minimized.Planning objective$\boldsymbol{f}(x; c)$ is given as $- steps / (4 \times size^2)$, where $steps$ is the number of steps taken to reach the goal. A maximum of $4 \times size^2$ steps are allowed.Problem instance distributionThe training set and testing set each contain $1000$ problem instances, where the obstacle, start, and goal positions
are uniformly sampled.Domain:Maze2D[size]fromopof_grid2d.domainsimportMaze2Ddomain=Maze2D(11)# Creates a Maze2D domain instance for a 11x11 board.DescriptionA* searchis run against aheuristicfunction $h(n)$ to find a path from the start (green) to the goal (green). The heuristic function determines the priority in which nodes are expanded (cells that are in darker red have a lower $g(n) + h(n)$ value, and have higher priority). The maze is assumed to beperfect, i.e., there is exactly one path between any two cells.Planner optimization problemWe want to find a generator $G_\theta(c)$ that maps a problem instance $c$ (in this case, the combination of board layout and start and goal positions) to $h(n)$ (in this case, assignments of values $\in [0, size^2]$ to each of the $size^2$ cells) such that the number of nodes expanded in the A* search is minimized.Planning objectiveThe planning objective $\boldsymbol{f}(x; c)$ is given as $- steps / n_{\mathrm{empty}}$, where $steps$ is the number of nodes expanded before finding the goal and $n_{\mathrm{empty}}$ is the number of obstacle-free cells.Problem instance distributionThe training set and testing set each contain $1000$ problem instances, where the maze is generated usingWilson's algorithm, and the start and goal positions are uniformly sampled.CitingTBDLicenseopof-grid2dis licensed under theBSD-3 license.opof-grid2dis maintained by theKavraki Labat Rice University, funded in part by NSF RI 2008720 and Rice University funds.
Package: opossum
OpossumPackage for simulation of data generating process to evaluate causal inference models.Getting StartedLatest release version: 0.2.0Download with pip*nix OSpip3 install opossumWindowspip install opossum --user --upgradeBuild it yourselfgit clone https://github.com/jgitr/opossum.gitcd opossumgit checkout mastercd opossum*nixpython3 main.pyWindowspython main.pySHA-256: opossum-0.2.0-py3-none-any.whl19b0b705b37a71fd5deac40720d30da4caa6529a9f1e1e7db648ecd07aea3077SHA-256: opossum-0.2.0.tar.gze13000b1755576a80693dca5f2560cc9b7d3e1391701bdc5cae86f3a9b7eb036ApplicationBellow you can find a short description of the core functions that the package offers in code form. For more detailed information on how to apply the package and to get insight into the theoretical model that it is based on, please refer to the following blog posthttps://humboldt-wi.github.io/blog/research/applied_predictive_modeling_19/data_generating_process_blogpost/.Default SettingfromopossumimportUserInterface# number of observations N and number of covariates kN=10000k=50# initilizing classu=UserInterface(N,k,seed=None,categorical_covariates=None)# assign treatment and generate treatment effect inside of class objectu.generate_treatment(random_assignment=True,assignment_prob=0.5,constant_pos=True,constant_neg=False,heterogeneous_pos=False,heterogeneous_neg=False,no_treatment=False,discrete_heterogeneous=False,treatment_option_weights=None,intensity=5)# generate output variable y and return all 4 variablesy,X,assignment,treatment=u.output_data(binary=False,x_y_relation='partial_nonlinear_simple')Choosing covariatesN=1000k=20# whole dataset is binaryu=UserInterface(N,k,categorical_covariates=2)# one quarter of the dataset is binaryu=UserInterface(N,k,categorical_covariates=[5,2])# dataset consists of 10 continuous, 4 binary, and 3 variables each with 3 and 5 categories respectivelyu=UserInterface(N,k,categorical_covariates=[10,[2,3,5])Creating treatment effects# random treatment assignment resulting in on average 20% treated observationsu.generate_treatment(random_assignment=True,assignment_prob=0.2)# non-random treatment assignment with on average 65% treated observationsu.generate_treatment(random_assignment=False,assignment_prob='high')# generating only a positive heterogeneous treatment effectu.generate_treatment(constant_pos=False,constant_neg=False,heterogeneous_pos=True,heterogeneous_neg=False,no_treatment=False,discrete_heterogeneous=False)# generating a heterogeneous treatment effect that is in 20% of cases negative and 80% positiveu.generate_treatment(treatment_option_weights=[0,0,0.8,0.2,0,0])Creating output# Creating continuous y with partial nonlinear relationy,X,assignment,treatment=u.output_data(binary=False,x_y_relation='partial_nonlinear_simple')# Creating binary y with underlying linear relation and added interaction terms of Xy,X,assignment,treatment=u.output_data(binary=True,x_y_relation='linear_interaction')