Saravanan666/pypi-org huggingface dataset:
Package: o
Operator Information LibraryThe library to get information about various operators in
Python.Install through pip:pipinstalloStart off my importing the module:importoUse thegetmethod to get the Operator object for a specific
operator, provided as a string.operator=o.get("+=")print(operator)>>>"<class 'Operator(operator='+=', name='addition assignment', type=AssignmentOperatorType, methods=['__iadd__'], function=operator.iadd)'>"Use the various attributes to retrieve information for the operator.operator.methods>>>['__iadd__']str(operator.type)>>>"assignment"isinstance(operator.type,o.AssignmentOperatorType)>>>TrueOr, you can use the Operator object directly.
Be careful, an unknown operator raises an UnknownOperator exception.LicenseThis repo is under the MIT license.
Package: o2h
H2O2HThis repository is used to help Obsidian publish more conveniently.Installingpipinstallo2hGetting StartedAfter o2h package is installed, the cli command obs2hexo is available. The help info is listed here.obs2hexo-h

usage:obs2hexo[-h][-oOUTPUT][-cCATEGORY][-p|--picgo|--no-picgo]filename

positionalarguments:filenamegettheobsmarkdownfilename

options:-h,--helpshowthishelpmessageandexit-oOUTPUT,--outputOUTPUTgetoutputdir-cCATEGORY,--categoryCATEGORYgetcategory-p,--picgo,--no-picgousepicgoAs the Github repository space is limited, so it is not recommanded to upload all the pictures  to the repository. So I provide an alternative option-pto upload pictures withpicgo.The default output directory is/tmp/o2houtput.Configurationo2h cannot find the position of Obsidian Vault automatically, so it relies on the configuration file. A configuration file should be created in$HOME/.config/o2h/config.jsonHere is an example of my config file:{"obsidian_target":["$HOME/Documents/Work/Notes"]}If there are multiple Obsidian Vault in you system, you can add them like this:{"obsidian_target":["path_1","path_2",...,"path_n"]}ExampleHere are some examples:# translate a.md to standard markdown# the category is "Skill"# all the picture are copied to a new folder named 'a' in current directoryobs2hexo-o$PWD-cSkilla.md# translate b.md to /tmp/o2houtput, all the picture are uploaded by picgoobs2hexo-cDevelop-pb.md
Package: o2-processing-utils
o2-processing-utilsTool for running and logging various bioinformatics tools on Harvard Medical School's high performance computing cluster O2.InstallationConda environmentTo install the package, you can first install conda and then create a conda environment using the provided .yml file with the following command:conda env create -f o2_processing_utils.yml. The environment can then be activated with the commandconda activate o2_processing_utils.Manual installationYou can also set up the environment manually. Runpip install o2_processing_utilsto install the package. You also need to install samtools, pbmm2 1.13.*, and at least Python 3.8.UsageAfter installation, first ensure that the environment variableO2_PROCESSING_CONFIGis set to the absolute path of the .json file containing the path to the reference file, the path to the log file, and the resources to be allocated to the Slurm job running pbmm2. You can set the environment variable using the commandexport O2_PROCESSING_CONFIG=/PATH_TO_CONFIG/config.jsonAn example configuration file (config.example.json) is provided.To analyze a PacBio HiFi/Fiber-Seq unaligned BAM, repeatedly run the following command from the command line:o2p-run-pbmm2-workflow -b <input.bam>Each time the command is run, a single step will be performed on the file or files of interest; as a result, you will have to run the same command several times on the same file. Repeat runs of the command will automatically perform the next analysis if the previous step was completed successfully. The workflow for a file is finished once you receive the message "The workflow is complete for file {file_name}. Nothing else is done for this file". The steps that are run include alignment, performing basic checks, gathering QC metrics, and parsing QC metrics. The tool will automatically submit Slurm jobs for the steps if needed. To analyze multiple samples simultaneously, the user can pass the folder path containing the unaligned BAM files as an argument to the command with the -f flag.The following commands are provided for additional functionality:CommandDescriptiono2p-print-configPrint out O2_PROCESSING_CONFIG.o2p-reset-pbmm2-workflowReset a given workflow step for a given BAM file. This command only works for workflow runs that are incomplete.o2p-print-qc-filePrint out a specified qc file in a more human-readable format.o2p-create-summary-qc-fileGenerate a summary QC file from a set of individual .qc files.o2p-search-logSearch the log for a given string.For additional information, you can type any of the following commands into the command line followed by the flag--help. If you forget any of the available commands, you can also typeo2p-into the command line and then hit TAB twice. This will display all of the available functions.The currently supported alignment tools are:pbmm2 v1.13.* (employs minimap2 v2.26)The currently supported QC tools are:samtools (samtools stats)DevelopmentTo develop this package, clone this repo, make surepoetryis installed on your system and runmake install.
Package: o2r-meta
o2r metaThis is python library with a set of tools for extract-map-validate workflows as part of the o2r project:schema & documentation of the o2r metadataextract - collect meta information from files in a workspacebroker - translate metadata from o2r to third party schemasvalidate - check if metadata set is valid to the schemaharvest - collect metadata from external sources via OAI-PMHadding new parsers to the programFor their role within o2r, please refer too2r-architecture.Getting startedThe full functionality of o2r-meta, including building the documentation and running the tests, requires Python >= 3.7.Installation from source codegitclonehttps://github.com/o2r-project/o2r-meta.gitcdo2r-meta
pipinstall-rrequirements.txt
pipinstall-e.Common pitfall: pygdal version has to match the system GDAL version. Verify the system GDAL version like this:gdal-config--versionand, if necessary, force pygdal version to be installed as following:pipinstallpygdal==x.x.x.xInstallation with DockerAnother way of installation is provided by the Dockerfile. Build it like this:gitclonehttps://github.com/o2r-project/o2r-meta.gitcdo2r-meta
dockerbuild-tmeta.And start a tool of o2r-meta like this:dockerrun--rm-v$(pwd)/extract/tests/:/testdata:rometa-debugextract-i/testdata-sBuild the documentationTo familiarise with the use of o2r-meta and get access to the How-to guide, we recommend the installation of the documentation before using the tool.cddocs/
pipinstall-rrequirements-docs.txt
makehtmlThis will create directory build/html under docs, which contains the documentation. The entry point is file index.html.Run the testsThe o2r-meta tests use pytest. To install the necessary packages:pipinstall-Upytest
pipinstall-Upytest-console-scriptsTo run the tests:cdtests
pytestHow to citeTo cite this software please useNüst, Daniel, 2018. Reproducibility Service for Executable Research Compendia: Technical Specifications and Reference Implementation. Zenodo. doi:10.5281/zenodo.2203843Licenseo2r-meta is licensed under Apache License, Version 2.0, see file LICENSE. Copyright (C) 2016-2020 - o2r project
Package: o2w_settings
===========Default settings===========# In app/settings/common.py#encoding:utf-8import sysfrom os.path import abspath, dirname, join, normpath######### PATH CONFIGURATION# Absolute filesystem path to this Django project directory.DJANGO_ROOT = dirname(dirname(abspath(__file__)))# Add all necessary filesystem paths to our system path so that we can use# python import statements.sys.path.append(dirname(DJANGO_ROOT))sys.path.append(normpath(join(DJANGO_ROOT, '../apps')))sys.path.append(normpath(join(DJANGO_ROOT, '../libs')))sys.path.append(normpath(join(DJANGO_ROOT, "lib", "python2.7", "site-packages")))########## END PATH CONFIGURATIONimport o2w.settingso2w.settings.DJANGO_ROOT = DJANGO_ROOTfrom o2w.settings.common import *# In app/settings/dev.pyfrom common import *from o2w.settings.dev import *# In app/settings/prod.pyfrom common import *from o2w.settings.prod import *
Package: o2w_settings_cms
===========Default settings===========# In app/settings/common.py#encoding:utf-8import sysfrom os.path import abspath, dirname, join, normpath######### PATH CONFIGURATION# Absolute filesystem path to this Django project directory.DJANGO_ROOT = dirname(dirname(abspath(__file__)))# Add all necessary filesystem paths to our system path so that we can use# python import statements.sys.path.append(dirname(DJANGO_ROOT))sys.path.append(normpath(join(DJANGO_ROOT, '../apps')))sys.path.append(normpath(join(DJANGO_ROOT, '../libs')))sys.path.append(normpath(join(DJANGO_ROOT, "lib", "python2.7", "site-packages")))########## END PATH CONFIGURATIONimport o2w.settingso2w.settings.DJANGO_ROOT = DJANGO_ROOTfrom o2w.settings.common import *# In app/settings/dev.pyfrom common import *from o2w.settings.dev import *# In app/settings/prod.pyfrom common import *from o2w.settings.prod import *
Package: o3
The quick summary:Ozone or trioxide, is an allotrope of Oxygen. It’s found in the higher
atmosphere, and can also be smelled after rain.
Ozone configuration library is meant to be used when building cloud native
applications (or 12 Factor applications).Usually these application are configured with environment variables. These in
turn are constants usually typed as SOME-VARIABLE. To read this in Python you
would do this:>>> import os
>>> os.getenv("SHIFTSOME_VARIABLE")I got tired of this and I want to access SOME-VARIABLE as an attribute, so:export SOME_VARIABLE=magic

>>> from o3 import Config
>>> c = Config()
>>> c.some_variable
magicNotice, access is done via attribue instead of dictionary lookup.
Package: o365-notifications
O365-notificationsis apythonicimplementation for the Notification services
from Office 365. There are currently 2 ways for receiving notifications:Push NotificationsStream NotificationsThe versions on these are beta. For more details, see its documentation.This approach is built on top of the currentO365package. You are recommended to look into its
documentation for advance setups.Notification strategiesAs mentioned, there currently 2 supported notification types inO365:pushandstreaming.As of now, this project relies onOutlook REST Beta API. But because this API is
now deprecated and will be decommissioned, a transition toMicrosoft Graph APIis
required. Seethissection for more details.Push notificationsThis project does not contain an implementation for this type of notification.
Therefore, contributions are more than welcome.O365documentation on push notifications can be foundhere.Streaming notificationsThis project provides an implementation for this type of notification. A quick example
on how to use it is found below:importO365fromO365_notifications.baseimportO365NotificationHandlerfromO365_notifications.constantsimportO365EventTypefromO365_notifications.streamingimportO365StreamingSubscriberaccount=O365.Account(...)mailbox=account.mailbox()# create a new streaming subscribersubscriber=O365StreamingSubscriber(parent=account)# ... and subscribe to resource eventsresource=mailbox.inbox_folder()events=[O365EventType.CREATED]subscriber.subscribe(resource=resource,events=events)# subscriber keeps track of active subscriptionsassertlen(subscriber.subscriptions)==1# implement a notification handler for customized behaviorsubscriber.start_streaming(handler=O365NotificationHandler())O365documentation on streaming notifications can be foundhere.Important note ⚠️As communicated byMicrosofthere, Thev2.0REST endpoint will be
fully decommissioned in November 2022, and thev2.0documentation will be removed
shortly after.What does it mean to this package?Let’s see what it means for each one of the notification types:Push notificationsPush notifications will be moved toMicrosoft Graph, and go under the name ofchange notifications. Its documentation can be foundhere.Transitioning to theMicrosoft Graphshould be a simple and straightforward task.Streaming notificationsUnfortunatelyMicrosoftwill not port this service toMicrosoft Graph. Therefore, as
of November 2022, the current implementation in this project will be obsolete. More
details on that can be foundhere.Tests & lintingRun tests withtox:# ensure tox is installed$toxRun linter only:$tox-elintOptionally, run coverage as well with:$tox-ecoverageLicenseMIT licensed. SeeLICENSE.
Package: o3iss
Iterated-sums signature in RustThis is an implementation of the one-dimensional iterated-sums signature in Rust,
with Python 3 bindings.InstallationFrom PyPINormally, this package can be installed by runningpip3installo3issFrom sourceCurretly we provide wheels for Linux, macOS and 64-bit Windows.
If your system is not included in any of these targets, you will have to compile the package yourself.
This will require you to have a Rust compiler, which can be obtained from [https://www.rust-lang.org/tools/install].Start by cloning this repository by runninggitclonehttps://github.com/ntapiam/o3iss.gitThen, enter the directory and runpython3setup.pyinstallThis should compile and install the package on your system.UsageThis implementation offers only a single function:iss.computewith signature(np.ndarray, int) -> np.ndarraywhere both the input and ouput arrays are one-dimensional.Inv0.1.2, we introduced partial support for thesklearnframework.
Example (assuming thatsktimeis present):fromissimportIssClassifierfromsktime.datasetsimportload_gunpointfromsktime.utils.data_processingimportfrom_nested_to_2d_arrayXtrain,ytrain=load_gunpoint(split="train",return_X_y=True)Xtest,ytest=load_gunpoint(split="test",return_X_y=True)Xtrain,Xtest=(from_nested_to_2d_array(Xtrain).to_numpy(),from_nested_to_2d_array(Xtest).to_numpy(),)ytrain,ytest=ytrain.astype(int),ytest.astype(int)clf=IssClassifier(level=3,n_jobs=7)clf.fit(Xtrain,ytrain)print(clf.score(Xtest,ytest))>>0.9133333333333333TO DOMultidimensional signaturePropersklearnintegrationProduce a proper Python 3 package
Package: o3soil
A toolkit of extensions for using o3seespy for geotechnical simulationsPackage overviewo3soil is high-level package that takes advantage of several libraries to perform geotechnical analyses
without rewriting common functions.The package is based on the genericsfsimodelspackage soil object (sfsimodels.Soil()), soil
profile object (sfsimodels.SoilProfile()) and building object (sfsimodels.Building()), as well as the
the acceleration time series object from the eqsig package (eqsig.AccSignal()).
These objects allow soil, building and ground shaking to be defined in an agnostic way which is compatible
with other software and Python packages and export them to json file format.
The toolkits in this package convert the generic objects into o3seespy objects and run an OpenSees analysis.The eco-system of Python packages that relate to this package are outlined in the figure below.Key areas:Site response analysisSeismic Soil-foundation-structure interactionFoundation bearing capacityLiquefaction triggeringElement test behaviourLateral spreading
Package: o4
## Installpip install -r requirements.txt## Runfrom o4 import O4weights = “tests/wheights/yolov3.weights”names = “tests/wheights/coco.names”anchors = “tests/wheights/yolov3.cfg”INPUT_DIR = “o4/data/input/braga.mp4”OUTPUT_DIR = “o4/data/output/output.avi”o4 = O4(weights, names, anchors)o4.video(INPUT_DIR, OUTPUT_DIR)o4.add_feature(DetectionBoxes())o4.add_feature(Counter(object_types=[“person”])while o4.next():`  value = counter_persons.get_value()`
`  print(value)`o4.close()
Package: o7cli
O7 CLIA useful tool for O7 Conseils AWS DevOps activities.
This is developed as we need it in our projects. It shared to allow others to use it.InstallationRun the following to install:pipinstallo7cliUsage# Helpo7# See all AWS pipeline in us-east-1o7-rus-east-1pl# See all AWS Cloudwatch logs for profile ab in us-west2o7-pab-rus-west-2logOptions & Moduleo7 [options] <module>
Useful CLI and scripts for O7 Conseils DevOps practice
version: <VERSION>
Options:
    -p <profile> : Set AWS Profile
    -r <region>  : Set AWS Region
    -d           : Set DEBUG Traces
    -v           : Version Number
Available Modules:
    report: Multiple Reports
    cost: Analyse AWS Sccount Cost
    log: Cloudwatch Logs
    cm: Cloud Map

    s3: S3 (Simple Scalable Storage)
    ec2: Elastic Computing
    ecs: Elastic Container Service
    lf: Lambda Funcition
    rds: Relational DB
    asg: Auto Scaling Group

    cfn: Cloudformation
    pl: Code Pipeline
    cb: Code Build
    cc: Code Commit
Package: oa3-responses-validator
OpenAPI3 Responses ValidatorChecking if certain HTTP codes are specified in each of the responses for each routeInstallationpipinstalloa3-responses-validatorUsage:oa3-responses-validator-i/path/to/openapi.yaml-c400-c500-c2XXYou can use the 2XX code pattern to indicate that any 2XX code should be among the response codes
Package: oaas
Operation As A Service APIInstallationpipinstalloaasUsagefromtypingimportAny,Listimportoaas@oaas.client("users-get")defget_users(group:str)->List[Any]:...@oaas.client("datastore")classDataStore:defput_item(self,key:str,value:Any)->None:...defget_item(self,key:str)->None:...defremove_item(self,key:str)->None:...@oaas.service("users-get")defget_user_list(group:str)->List[Any]:...@oaas.service("datastore")classDataStoreService:defput_item(self,key:str,value:Any)->None:...defget_item(self,key:str)->None:...defremove_item(self,key:str)->None:...@oaas.service("intercept")defget_user_intercept(group:str)->List[Any]:...@oaas.service("datastore")classDataStoreIntercept:defput_item(self,key:str,value:Any)->None:...defget_item(self,key:str)->None:...defremove_item(self,key:str)->None:...
Package: oaas_grpc_compiler
oaas-grpc-compilercompiles gRPC proto files, with type information
that can be verified usingmypy, formatted withblack, with the
possibility of custom modules where the sources to be generated in.Theadd_Type_to_serverfunction is moved into the Servicer type as a
static method:Type.add_to_server, because this is how OaaS can
figure out if this is agRPCservice, or asimpleservice.UsageUsage: oaas-grpc-compiler [OPTIONS] GRPC_FILES

Options:
  --module TEXT  The module of the python package to generate
  --output TEXT  Output folder where to write the files
  --help         Show this message and exit.ExampleProto filetest.proto:syntax="proto3";messagePing{stringtext=1;}messagePong{stringtext=1;int32len=2;}serviceTestService{rpcping(Ping)returns(Pong){}rpcping_copy(Ping)returns(Pong){}rpcping_exception(Ping)returns(Pong){}}Invocation:oaas-grpc-compiler--modulesome.custom.module--outputsome/custom/moduletest.proto
Package: oaas_simple
A transport for OaaS that uses a singlegrpcfunction. It should
work out of the box for most simple scenarios.Installationpipinstalloaas_simpleUsageTo get a process that does both the client and the server:oaas.register_server_provider(OaasGrpcTransportServer(port=9000))oaas.register_client_provider(OaasGrpcTransportClient())oaas.serve()Exposing services is done via regularoaasdecorators:@oaas.service("test-service")classTestCallService:defecho_data(self,*,data:str)->str:returndataAgain for consumers:@oaas.client("test-service")classTestCallClient:defecho_data(self,*,data:str)->str:...In order to make the services find each other you need a registry. You
can fire up the embedded registry:python-moaas_simple.registryThe only requirement is that the registry listens on port 8999Minimal Clientimportoaasimportoaas_simple@oaas.client("swag")classSwag:defprint_stuff(message:str)->str:...oaas.register_client_provider(oaas_simple.OaasSimpleClient())swag=oaas.get_client(Swag)print(swag.print_stuff("abc"))Minimal Serverimportoaasimportoaas_simple@oaas.service("swag")classSwag:defprint_stuff(self,message:str)->str:print(message)returnf"from server{message}"# it needs the client to find the registry, since the registry is also an# oaas.service("oaas-registry")oaas.register_client_provider(oaas_simple.OaasSimpleClient())oaas.register_server_provider(oaas_simple.OaasSimpleServer(port=9000))oaas.serve()oaas.join()
Package: oacde
Online algorithm configuration for differential evolution algorithm (OAC-DE)Click here to read the full paper online.Click here to download the full paper in PDF file.AbstractThe performance of evolutionary algorithms (EAs) is strongly affected by their configurations. Thus, algorithm configuration (AC) problem, that is, to properly set algorithm's configuration, including the operators and parameter values for maximizing the algorithm's performance on given problem(s) is an essential and challenging task in the design and application of EAs. In this paper, an online algorithm configuration (OAC) approach is proposed for differential evolution (DE) algorithm to adapt its configuration in a data-driven way. In our proposed OAC, the multi-armed bandit algorithm is adopted to select trial vector generation strategies for DE, and the kernel density estimation method is used to adapt the associated control parameters during the evolutionary search process. The performance of DE algorithm using the proposed OAC (OAC-DE) is evaluated on a benchmark set of 30 bound-constrained numerical optimization problems and compared with several adaptive DE variants. Besides, the influence of OAC's hyper-parameter on its performance is analyzed. The comparison results show OAC-DE achieves better average performance than the compared algorithms, which validates the effectiveness of the proposed OAC. The sensitivity analysis indicates that the hyper-parameter of OAC has little impact on OAC-DE's performance.KeywordsAutomatic algorithm configuration, Differential evolution algorithm, Adaptive parameter control, Multi-armed bandit, Kernel density estimation, Machine learningAbout this repositoryHow to installpip install oacdeHow to useimport oacdeTutorialClick here to read the full tutorial.CitationYou may cite this work in a scientific context as:C. Huang, H. Bai and X. Yao, "Online algorithm configuration for differential evolution algorithm", Applied Intelligence, 2022, vol. 52, no. 8, pp. 9193–9211, doi:10.1007/s10489-021-02752-1Or copy the folloing BibTex file:@article{OACDE,
author  ={Changwu Huang and Hao Bai and Xin Yao},
title   ={Online algorithm configuration for differential evolution algorithm},
journal ={Applied Intelligence},
volume  ={52},
number  ={8},
pages   ={9193-9211},
year    ={2022},
url     ={https://link.springer.com/article/10.1007/s10489-021-02752-1},
doi     ={10.1007/s10489-021-02752-1},}Ordownload the citation in RIS file.Related workAdaptive Differential Evolution based on Exploration and Exploitation Control (AEEC-DE)ContactAsst. Prof. Changwu HUANG
Package: oactool
oactoolA tool to manipulateOpenAutoCompletedefinitions.InstallationUsing pip:pip install oactoolUsingpoetry:poetry add oactoolValidationValidate OpenAutoComplete definition:oactool validate <file>Export JSON Schema for OpenAutoComplete:oactool jsonschemaExport Docopt usages (works on a subset of definitions):oactool make-docoptExport fish autocomplete file (highly experimental!):oactool make-fish
Package: oafabrik
pyfabrikpyfabrikis a simple library created to interface with Fabrik, the data access layer component ofOpenAristos.InstallationUsepipinstalloafabrikUsageimportosfrompyfabrik.clientimportFabrikClientfrompyfabrik.dataimportDefaultDataFrameFacadefrompyfabrik.modelsimportFabrikReadRequest,FabrikReadResponseclient=FabrikClient(endpoint=os.getenv("FABRIK_HOST"),token=os.getenv("FABRIK_JWT_TOKEN"),df_facade=DefaultDataFrameFacade(),)query:str="index:ix[msci_benchmark_code='701431']>index_has_constituent>.effective.instrument_region:ir[]@axioma:a axioma.axww4_attribution_security.by_instrument_region[a,ir,price,effective_dt] e 2015-01-01 2015-02-01 b"r:FabrikReadRequest=FabrikReadRequest(definition=query,warehouse="redshift",)res:FabrikReadResponse=client.read(r)res.df.show()LicenseAGPLV3