Saravanan666/pypi-org huggingface dataset:
Package: oagdedupe
oagdedupeThis project is under active development.oagdedupe is a Python library for scalable entity resolution, using active
learning to learn blocking configurations, generate comparison pairs,
then clasify matches.installation# PyPI
pip install oagdedupedocumentationYou can find the documentation of oagdedupe athttps://deduper.readthedocs.io/en/latest/,
where you can find:Installation and Getting StartedExamplestheAPI referenceUser Guide / Methodology
Package: oagre
OAGRE : Outlier Attenuated Gradient Boosting RegressionStatus: Functional -A meta-learning model for regression on noisy data with heteroscedasticity.This work was initially started in 2017 while working with a large scale
noisy regression problem. The initial experiments were done in R and abandoned
when I moved onto other projects. The same line of thinking recurred in 2021
as I looked at more regression problems and led to this repository.This time round the implementation has been done in Python in a scikit-learn
compatible structure. It also allows you to define the internal classifier and
regression algorithms to be used, rather than forcing the use of decision trees.Massive thanks are required to the contributors at the scikit-lego project for
the inspiring open-source library that informed much of the development here.InstallationThe package will be released via PyPi and can installed via pip.Alternatively you can install from source codeExperimentsWe have conducted experiments using synthetically generated data for highly non-linear
regression problems and multiple variations of heteroscedastic noise.
These experiments can be executed using the scriptrun_experiment.pyand the analysed with the scriptscripts/analyse.py.How to citePaper to be published (under revision)@InProceedings{Hawkins2024,author={John Hawkins},year={2024},title={OAGRE: Outlier Attenuated Gradient Boosted Regression},booktitle={},month={},}
Package: oaicli
OAICLI 🕶️A Command Line Interface to Open AI(pronounced Oakley (IPA oʊk.li)OAICLI is designed to help developers create and use assistants, which were launched on OpenAI Dev Day, November 2023.Threads, messages, and thread runs are abstracted, to make the user experience of creating and chatting with agents simpler.
Your files, agent prompts, and messages will be saved to.oaicli, from which you can edit prompts and files.Use at your own risk.I built this for myself. Feel free to open issues and PRs.
If you want a complete implementation of what Assistants are capable of, you can use the friendlyOpenAI playground.installationpip install oaicliNext, creat an.envfile in your project home:OPENAI_API_KEY  = "[your key]"
OPEN_AI_MODEL_TYPE = "gpt-4-1106-preview"
OPEN_AI_VISION_MODEL_TYPE = "gpt-4-1106-vision-preview"When you first runoaicli, it will install the.oaiclidirectory in the project location.
You could version prompts for example in your repo, and then update your agents.Threads are given names to make it easier to choose.Commandsoaicli -h | --help for helpQuickstartoaicli start- allows you to start up quickly, choose a thread, agent, and start communicating.If runs reach a time limit, they will be canceled.File and Agent maintenanceOtherwise there is some agent and file maintenence.oaicli file upload
oaicli file list
oaicli file download-allexperimentalProbably broken. If you want autocompletion (useful for editing agents and uploading files)For Bash:eval "$(_OAICLI_COMPLETE=source_bash oaicli)"For Zsh:eval "$(_OAICLI_COMPLETE=source_zsh oaicli)"Roadmapv0.3upload doc from url, or get web contentscat a directory into a single file and uploadshare publicically OAICLI help agent, uploading entire github repo. For example "what changes would you make to README.md based on the source code"v1.xHave agents select and talk to each other.Other:agent.dialog [agent name one] [agent name two] ... - have  agents talk to eachother ala autoGPTagent.local-rag [agent] - add a file to local rag for use with an agentagent.function [agent] - add a file to local rag for use with an agentpydantic, mypy for typingtox and testingshell completionfor commands and directories and files (clicko?)SQL lite for RAG and storagetools supporthttps://platform.openai.com/docs/api-reference/assistants/createAssistant#assistants-createassistant-toolsfunction call supportDevelopmenthttps://github.com/HumanAssistedIntelligence/OAICLIhttps://pypi.org/project/oaicli/pyenv install 3.12
pyenv virtualenv 3.12 oaicli
export PYTHONPATH="[project path]/oaicli
pip install .
Package: oaipmharvest
oaipmharvestDescriptionoaipmharvest is a harvester forOAI-PMHwritten in python
and based onsickle(for now). It's special focus lies on support for advanced
non-standard use cases. If you just need a the standard feature set, you might be better off with something more mature
and better tested.The oaipmharvester will connect to a given OAI-endpoint and store its responses in a given output folder. It enables you
to make incremental requests from the given OAI-endpoint or even restrict the result set by a given date. In addition to
that, it provides several features to dynamically construct set specifiers from smaller parts.This is an alpha release. Use with caution.FeaturesConfiguration via TOMLAdvanced configuration support for dynamic sets (for e.g. those supported byBASE)InstallationAfter cloning the git repository locally, set up a virtual environment and runpip install .RunningFor running the application, you can call after the installation the CLI commandoaipm_harvest, which also provides a help function
by callingoaipm_harvester -h.usage: oaipm_harvest [-h] [--from FROM] [--until UNTIL] file

positional arguments:
  file                  Config file (TOML)

optional arguments:
  -h, --help            show this help message and exit
  --from FROM, -f FROM  Harvest only items that where published after the specified date
  --until UNTIL, -u UNTIL
                        Harvest only items that where published before the specified dateTo harvest a specific OAI, you have to provide a conf-file. An example conf-file for the
most basic use case could beconf/my-journal.confand would contain, for example:endpoint_url = "https://www.contributions-to-entomology.org/oai/"
metadata_prefixes = ["marcxml"]
out_dir = "./out_cte"
use_sets = falsewhereendpoint_urlis the OAI-base-URL you want to connect to.metadata_prefixesis a list of formats you want to download. The format is simply handed to the OAI-interface and, hence, it depends on the OAI-interface, if it supports the given format or not.out_diris the directory, where all the downloaded data will be stored. If the given folder(s) do not exists, they will be created.use_setsfalseLicenceAll parts of this code are copyrighted by the University Library JCS, Frankfurt a. M. The project is made available
under the Mozilla Public License 2.0.AcknowledgementThis is a project created and maintained by theSpecialised Information Service for Linguisticsat theUniversity Library J. C. Senckenbergand funded by the German Research Foundation (DFG; project identifier326024153).
Package: oaipmh-scythe
oaipmh-scythe: A Scythe for harvesting OAI-PMH repositories.Welcome to oaipmh-scythe, an updated and modernized version of the originalsickle,
now with additional features and ongoing maintenance.CIDocsPackageMetaoaipmh-scythe is a lightweightOAI-PMHclient library written in Python. It has been designed for conveniently retrieving data from OAI interfaces the Pythonic way:fromoaipmh_scytheimportScythewithScythe("https://zenodo.org/oai2d")asscythe:records=scythe.list_records()next(records)# <Record oai:zenodo.org:4574771>FeaturesEasy harvesting of OAI-compliant interfacesSupport for all six OAI verbsConvenient object representations of OAI items (records, headers, sets, ...)Automatic de-serialization of Dublin Core-encoded metadata payloads to Python dictionariesOption for ignoring deleted itemsRequirementsPython>= 3.10oaipmh-scythe is built with:httpxfor issuing HTTP requestslxmlfor parsing XML responsesInstallationYou can install oaipmh-scythe via pip fromPyPI:python -m pip install oaipmh-scytheDocumentationThedocumentationis made withMaterial for MkDocsand is hosted byGitHub Pages.Similar ProjectsThere are a couple of similar projects available onPyPIand GitHub, e.g. via
the topicsoai-pmhandoai-pmh-client. Among them are these implementations in Python:ProjectDescriptionLast commitsickleoaipmh-scythe is a fork of sicklepyoaisickle was inspired by pyoaipyoaiharvesteroai-pmh harvester CLIddblabs-omethaoai-pmh harvester with CLI and TUIoai-harvestuses pyoai internallyoai-pmh-harvesteruses sickle internallyThere are also similar projects available inJavaandPHP.AcknowledgmentsThis is a fork ofsicklewhich was originally written by Mathias Loesch.Licenseoaipmh-scythe is distributed under the terms of theBSD license.
Package: oai-repo
oai_repoTheoai_repoPython module provides a configurable implementation of anOAI-PMHcompatible repository.FeaturesCompletely customizable to work with any backend you have.Compliant to the OAI-PMH 2.0 specification.Easy to integrate within any Python application.DocumentationFor full documentation visit theoai_repo documentationsite.Author and LicenseTheoai_repomodule was developed at the Michigan State University Libraries.
It is released under the Apache License version 2.0.CopyrightCopyright (c) 2022 Michigan State University Board of Trustees
Package: oai-sam
oai-samis a script generating a SAM template together with OpenAPI documentation includingAWS OpenAPI extensionsfrom an OpenAPI/swagger documentation.Simply provide your OpenApi/Swagger as an input and then useSAM CLIto deploy a working AWS ApiGateway.Installpip install oai-samUsageGenerateoai-sam -f <OPENAPI_DOCS> -u <BACKEND_URL> -c <CORS_ORIGINS>e.g:oai-sam -f https://petstore.swagger.io/v2/swagger.json -u http://petstore.swagger.io/v2 -c "*"Deploy AWS ApiGatewayInstallSAM CLIsam package --template-file out/apigateway.yaml --s3-bucket <SAM_BUCKET> --output-file packaged.yaml(Seesam packagefor more options)sam deploy --template-file packaged.yaml(Seesam deployfor more options)Show list of available argumentsoai-sam --help
Package: oais-utils
oais-utilitiesUtilities to work with the CERN OAIS artifacts, such as Submission Information Packages.FeaturesValidate CERN SIPValidates the folder in the given path according to theCERN SIP specification, following these steps:Verify directory structureValidate the manifest file against the desired sip JSON schema. By default usessip-schema-d1.json, also shipped in this packageValidate the folder as a BagIt packagefile are allowed to be missing if the manifest specifies it's a "lightweight" SIP.Checks if every content file mentioned in the manifest is actually present in the payloadUsage:fromoais_utilsimportvalidatevalidate("name_of_the_sip_folder")sip.json schemasSIP manifest JSON schemas are also shipped and exposed with this package.To get a python dictionary with the schema short name as keys and the parsed (as python object) schema as value for the corresponding schema name, run:importoais_utilsschemas=oais_utils.schemasschemas.keys()# ['draft1']schemas['draft1']# [...]# (Returns the sip JSON schema "draft1" as parsed python object)schemas['draft1']['$id']# https://gitlab.cern.ch/digitalmemory/utils/-/raw/master/oais_utils/sip-schema-d1.jsonInstallInstall from PyPipipinstalloais-utilsFor development, you can clone this repository and then install it with the-eflag:# Clone the repositorygitclonehttps://gitlab.cern.ch/digitalmemory/oais-utilscdoais-utils
pipinstall-e.Usefromoais_utilsimportvalidatevalidate("../bagit-create/bagitexport::cds::2751237")
Package: oai-tools
OAI ToolsThis repository contains a collection of useful tools built on top of OpenAI's API. These tools can help automate various tasks and provide assistance through natural language processing.Installation or Upgradepip install --upgrade oai-toolsToolscligpt: A command-line helper that takes a user prompt and returns shell commands, along with explanations of what they do. It also supports command completions for various shells. Seecligpt.mdfor more details.ConfigurationConfiguration file is read from~/.config/oai_tools/config.yamlfile. See theconfig-example.yamlfile for more details.API KeyOpenAI's API key is required.
The key is read from theOPENAI_API_KEYenvironment variable. If this variable is not set, the API key is read from the~/.config/oai_tools/api_keyfile.
Package: oaix
oaixA minimalist OpenAI API client.InstallationpipinstalloaixUsageimportoaixoaix.Api().post('chat/completions',json={'model':'gpt-3.5-turbo','messages':[{'role':'system','content':"You will introduce yourself as Batman. Then I will ask you a question which you will answer as Batman."},{'role':'assistant','content':"Hello, I'm Batman."},{'role':'user','content':'Tell me exactly who you are and what you do using only four words.'}]})
Package: oak-build
oak-buildA make-like build system written on pythonHow to useCreateoak_build.pyfile in your project directory.
Every method marked with@taskdecorator can be called from CLI.frompathlibimportPathfromoak_buildimporttask@taskdefcreate_file():withopen(Path("result.txt"),"w")astxt:txt.write("test content\n")To executecreate_filetask calloak create_filefrom console.Task dependenciesYou can link dependent tasks withdepends_onparameter.fromoak_buildimporttask,run@taskdefunit_tests():run("poetry run pytest tests")@taskdefintegration_tests():run("poetry run pytest integration_tests")@task(depends_on=[unit_tests,integration_tests,])deftests():passWhenoak testsis called oak build will executeunit_testsandintegration_teststasks as well.CLI paramsYou can pass parameters to tasks with--param key=valueparameter of command line.
Oak will try to parse all task function params regarding its annotation type.Example:fromenumimportEnum,autofromoak_buildimporttaskclassTaskEnum(Enum):VALUE=auto()@taskdefenum_param(param:TaskEnum):passTask resultsExit codeAll int return value from task will be treated as return code.
If return is integer and not zero task will be marked as failed and further execution will be stopped.fromoak_buildimporttask@taskdefexit_code_task():return0Result dictAll dict return value will be treated as result.
Those results can be used in another tasks with tas name prefix (see example below).fromoak_buildimporttask@taskdefsource():return{"result":123,}@task(depends_on=[source])defresult_consumer(source_result):passPlease note that CLI params have greater priority than arguments deducted from task results.Code and resultYou can returnTuple[int, Dict[str, Any]]from task, and it will be treated as return code and result dict.
If code is not zero task is considered failed.
The result dict processing is the same as in dict resultExceptionsIf task throws exception it is considered faled and further execution will be stopped.ExamplesFor examples seeintegration tests filesand self buildoak_file.py.
Package: oakprofile
PyPi:https://pypi.org/project/oakprofile/สวัสดีครับแพ็คเกจนี้เป็นแพ็คเกจที่อธิบายโปรไฟล์ของนายโอ๊คและสามารถนำไปใช้กับผู้อื่นได้วิธีติดตั้งเปิด CMD / Terminalpipinstalloakprofileวิธีใช้งานแพ็คเพจนี้เปิด IDLE ขึ้นมาแล้วพิมพ์…if__name__=='__main__':my=Profile('oak')my.company='uncle-engineer'my.hobby=['watchingTV','sleeping','reading']print(my.name)my.show_email()my.show_myart()my.show_hobby()พัฒนาโดย: อริญชย์ ชาติละอองFB: Arin Chatlaong
Package: oakschool
This is example of oop (class) in python for beginnerวิธีติดตั้งเปิด CMD / TerminalpipinstalloakschoolHow to useเปิด IDLE ขึ้นมาแล้วพิมพ์...fromoakschoolimportStudent,SpecialStudentprint('-----------------Day 1-------------------')student0=SpecialStudent('Mark','Bill Gates')student0.NeedExp()student0.ShowExp()student1=Student('Albert')# st is object // this line is using classprint(student1.name)student1.Hello()print('-----------------------------------------')student2=Student('Steve')print(student2.name)student2.Hello()print('-----------------Day 2--------------------')print('Who wanna coding? (get 10 exp)')print(student1.name)student1.AddExp(10)print('-----------------Day 3--------------------')print('Each your exp is :')print(student1.name,student1.exp)print(student2.name,student2.exp)print('-----------------Day 4--------------------')foriinrange(5):student2.Coding()student1.ShowExp()student2.ShowExp()
Package: oaktree
Make your cloud throw some shadeoaktree is a gRPC interface for interacting with OpenStack clouds that is
inherently interoperable and multi-cloud aware. It is based on the python
shade library, which grew all of the logic needed to interact with OpenStack
clouds and to work around differences in vendor deployment choices. Rather
than keep all of that love in Python Library form, oaktree allows othre
languages to reap the benefits as well.oaktree is not a replacement for all of the individual project REST APIs.
Those are all essential for cross-project communication and are well suited
for operators who can be expected to know things about how they have
deployed their clouds - and who in fact WANT to be able to make changes in
the cloud knowing deployment specifics. oaktree will never be for them.oaktree is for end-users who do not and should not know what hypervisor, what
storage driver or what network stack the deployer has chosen. The two sets
of people are different audiences, so oaktree is a project to support the
end user.UsingInstall oaktreemodel by hand. Then:In one window:pythonoaktree/server.pyoaktree/server.py assumes you have a clouds.yaml accessible.In another window:python-idevstack/test.pyYou’ll have an images and a flavors object you can poke at.If you want to operate against a different cloud thandevstack, you can
pass it to devstack/test.py as the first command line argument.Shape of the Projectoaktree should be super simple to deploy, and completely safe for deployers
to upgrade from master constantly. Once it’s released as a 1.0, it should
NEVER EVER EVER EVER EVER EVER EVER have a backwards incompatible change.
There is no reason, no justification, no obessession important enough to
inflict such pain on the user.The shade library will grow the ability to detect if a cloud has an oaktree
api available, and if it does, it will use it. Hopefully we’ll quickly reach
a point where all deployers are deploying oaktree.Documentation:http://docs.openstack.org/developer/oaktreeSource:http://git.openstack.org/cgit/openstack/oaktreeBugs:http://bugs.launchpad.net/oaktree
Package: oaktreemodel
oaktree is a gRPC interface for interacting with OpenStack clouds that is
inherently interoperable and multi-cloud aware.oaktreemodel is the protobuf definitions and the libraries and/or code
generated from that to make it possible for people of all languages to
interact with the gRPC system without developing a python dependency anywhere.At start, go, C++ and python are supported.With go, the generated files are checked in to the git repo, because that’s
how go dependencies work.With C++ and python, they are not, as we exepct the unit of consumption to
be a built library and header files for C++ or a PyPI package for Ruby. It’s
the most likely that as we add structure for more languages that they will
follow the C++/Python approach and not the go approach - but the decision
will be made on a per-language basis and reported back here.Note on API compattl;dr - Upgrading oaktree should NEVER negatively impact end users.Until a 1.0.0 release is cut, please consider that literally everything in
this repo can change with no notice or consideration of breaking backwards
compat. This is a new approach to several things and it’s entirely likely
we’re going to get things wrong a few times.Post 1.0.0 oaktree and oaktreemodel will be held to the same backwards-compat
promises as shade itself. That is - there will never be backwards-compat
breaking release, and it should _always_ be safe to deploy the latest release
in production. In fact, even for people running older stable releases of
OpenStack, the recommendation will be to run the latest oaktree, so that the
latest cross-compatibility changes can be picked up.Note on ImplementationsIt is absolutely the intent of oaktreemodel that multiple implementations
based on the protobuf descriptions exist for the client interaction. In fact,
the code generated and published from this repo is fairly low-leve on a gRPC
basis, so it’s almost certainly the case that each language will want to
consume this code in the context of some other library that has an end-user
focused UI.It is absolutely NOT the intent that multiple implementations of the server
side exist.The reason for that is that, at least as of now, the business logic in the
shade library is extensive and complex. It handles a million corner cases in
the underlying clouds. oaktree servers should all be able to talk not just
to the cloud they are deployed with, but also to other OpenStack clouds
either talking to the remote oaktree or directly to the remote OpenStack API.The client interfaces in gRPC should be considered to be comprehensive and
as descriptive of the interface as possible. For people wanting an oaktree
server, please use actual oaktree.BuildingFirst you need some dependencies:pipinstallbindepapt-getinstall$(bindep-b)pipinstall-frequirements.txtpipinstallgrpcio-toolsgoget-ugithub.com/golang/protobuf/protoc-gen-goThen you can build the code:autoreconf-fi./configuremakeSource:http://git.openstack.org/cgit/openstack/oaktreemodelBugs:http://storyboard.openstack.org
Package: oakvar
OakVar: Genomic Variant Analysis PlatformMissionOakVar is a bridge between cutting-edge genomics research and everyday people.OakVar democratizes access to genomics knowledge for all.What it doesAnnotate genomic variants with diverse annotation sources.Make databases of annotated variants.Query annotated variants with filter sets.Make reports in diverse formats.Visualize annotated variants with graphical user interface.Works via CLI and GUI.Easily develop, run, and distribute CLI and GUI genomics apps. OakVar acts as an operating system for genomics apps.Connect genomic data to AI/ML models.InternshipThe main project will be OakVar. Full remote work. Unpaid position (no funding yet). Please send your application torkim@oakbioinformatics.com.ResourcesReady to start?OakVar DocumentationSubscribe to the mailing list: Be in the loop and notified of the new releases and news of OakVar.Medium:https://medium.com/oakvarDiscord:https://discord.gg/wZfkTMKTjGReddit:https://www.reddit.com/r/oakvarEmail:rkim@oakbioinformatics.comMany Thanks to Our SponsorsOrganizational SponsorsIndividual SponsorsOakVar is in CodeXLicenseOakVar is licensed under dual licensing: 1) APGL v3 or higher and 2) paid subscription for commercial or closed-source use. For full license information, seeLICENSE.
Package: oakx-grape
oakx-grape🌳 🍇 Grape wrapper for OAK 🌳 🍇ALPHAUsageMacbook users with M1 processor need to do a few extra steps as follows:DownloadAnaconda.conda create --name oakx-grape-env python=3.9conda activate oakx-grape-envpip install poetrypoetry installThe steps below are common to everyone.pip install oakx-grape
poetry run runoak -i grape:sqlite:obo:pato relationships --direction both shapeInstall NVM + NPMTheseinstructionshelp setup nvm and npm on one's system.Install GraphViz and OboGraphVizbrew install graphviznpm install -g obographvizHow it worksThis plugin implements a grape wrapper. The wrapper in fact wraps two adapters:An adaptor to ensmallen/grape, for performing performance-intensive graph operationsAn OAK adapter for handling everything else, including lookup by labels, search, predicate filtering, etcThere are two choices of selector:grape:kgobo:{go,pato,uberon,...}grape:OAK-SELECTORwith the first pattern, the grape graph is loaded from kgobo, and the oak adapter is loaded from semantic sqlwith the second, you can most existing existing OAK adapters:sqlite/semsqlobordf/owlNote you CANNOT use a backend like ubegraph or bioportal that relies on API callsThe idea is we will be able to run a notebook like this:https://github.com/INCATools/ontology-access-kit/blob/main/notebooks/Monarch/PhenIO-Tutorial.ipynbWith the semsim part handled by OAKAcknowledgementsThiscookiecutterproject was developed from theoakx-plugin-cookiecuttertemplate and will be kept up-to-date usingcruft.