Saravanan666/pypi-org huggingface dataset:
Package: openimis-be-payment-cycle
openIMIS Backend payment_cycle reference moduleThis repository holds the files of the openIMIS Backend Payment Cycle reference module.
It is dedicated to be deployed as a module ofopenimis-be_py.ORM mapping:payment_cycle_paymentcycle, payment_cycle_historicalpaymentcycle > IndividualGraphQl QueriespaymentCycleGraphQL Mutations - each mutation emits default signals and return standard error lists (cfr. openimis-be-core_py)processBenefitPlanPaymentCycleServicesPaymentCycleService - Generic service containing workflow for payment cycle calculationBenefitPlanPaymentCycleService - Service customized for Benefit Plan payment cycle calculationConfiguration options (can be changed via core.ModuleConfiguration)gql_query_payment_cycle_perms: required rights to query PaymentCycle (default: ["200001"])gql_create_payment_cycle_perms: required rights to create PaymentCycle (default: ["200002"])gql_update_payment_cycle_perms: required rights to update PaymentCycle (default: ["200003"])gql_delete_payment_cycle_perms: required rights to delete PaymentCycle (default: ["200004"])gql_mutation_process_payment_cycle_perms: required rights to call processBenefitPlanPaymentCycle GraphQL Mutation (default: ["200005"])openIMIS Modules Dependenciescoresocial_protectioncontribution_plancalculationPayment Cycle ServicePayment cycle service specifies generic workflow for performing a calculation of periodical payments
for any king of business object connected to payment plans. This service includes a service specific
to BenefitPlan objects. To trigger a calculation The service requires a user reference, year, and month.
Any additional keyword arguments can be passed to theprocess()method to be used in calculations.result=BenefitPlanPaymentCycleService(user).process(year=year,month=month)the result is a dict containing status of the operation, indicating if the operation completed successfully
or not, message and details of an error if occurred and any additional data that was returned from psecific implementation
of the services and calculation rules grouped by the id of main queryset entry (BenefitPlan id in this case).
Package: openimis-be-tasks-management
openIMIS Backend tasks_management reference moduleThis repository holds the files of the openIMIS Backend Task Managemet reference module.
It is dedicated to be deployed as a module ofopenimis-be_py.ORM mapping:task_management_task, task_management_historicaltask > Tasktask_management_taskgroup, task_management_historicaltaskgroup > TaskGrouptask_management_taskexecutor, task_management_historicaltaskexecutor > TaskExecutorGraphQl Queriestask, taskGroup, taskExecutorServicesTaskcreateupdatedeletecomplete_taskresolve_taskTaskGroupcreateupdatedeleteTaskExecutorcreateupdatedeleteCheckerLogicServiceMixincreateupdatedeleteon_task_complete_service_handlerConfiguration options (can be changed via core.ModuleConfiguration)gql_task_group_search_perms: 190001gql_task_group_create_perms: 190002gql_task_group_update_perms: 190003gql_task_group_delete_perms: 190004gql_task_search_perms: 191001gql_task_create_perms: 191002gql_task_update_perms: 191003gql_task_delete_perms: 191004default_executor_event: defaultopenIMIS Modules DependenciescoreCreating execution action handlers and business event handlersWhen user action specified by the task is being passed to backend, the task service sendstask_service.resolve_tasksignal. The approach for handler is to bind toaftersignal and check the specificexecutor_action_eventof the
task. The same approach is used for business event handlers, being required to bind ontask_service.complete_task.# in signals.py in any moduledefbind_service_signals():bind_service_signal('task_service.resolve_task',handler_hook,bind_type=ServiceSignalBindType.AFTER)defhandler_hook(**kwargs):passCreating tasks for BaseService implementationsCheckerLogicServiceMixin allows implementations ofcore.services.BaseServiceto generate tasks for create, update
and delete actions. this adds create__task methods to the service, with the same API as the  methods.
Additionally theon_task_complete_service_handlerservice method allows to generatecomplete_taskhandlers forcore.services.BaseServiceimplementations.# In service definitionclassExampleService(BaseService,CheckerLogicServiceMixin):...# to create a task instead of performing create operation, instead of:# ExampleService(user).create(data)ExampleService(user).create_create_task(data)`#in signals.py (any module, but the same module as service preferred)defbind_service_signals():bind_service_signal('task_service.complete_task',on_task_complete_service_handler(ExampleService),bind_type=ServiceSignalBindType.AFTER)
Package: openimis-be-workflow
openIMIS Backend workflow reference moduleThis repository holds the files of the openIMIS Backend Workflow reference module.
It is dedicated to be deployed as a module ofopenimis-be_py.ServicesWorkflow serviceregisterget systems/groups/workflowsRegistering workflow systemsWorkflow service can be extended with custom adaptors to integrate with new workflow systems. Any adaptor have to
extendworkflow.systems.base.WorkflowAdaptorand return triggers as implementations ofworkflow.systems.base.WorkflowHandler.WorkflowService.register_system_adaptor(CustomWorkflowAdaptor)Querying workflowsQuerying available workflows can be done usingWorkflowService.get_workflowsservice. All registered workflow systems
have to implement filtering workflows by group and name.workflows_result=WorkflowService.get_workflows(group='default',name='example')ifworkflows_result['success']:workflow_handlers=workflows_result['data']['workflows']Executing workflowsWorkflow handlers are self contained triggers for a specific workflow in a given system. theWorkflowHandler.runmethod allows perform a workflow run with a given payload.payload={...}result=handler.run(payload)Depending on the system, workflow runs can be synchronous and will return result of the workflow, or asynchronous and
will return necessary info to check workflow status in a given workflow system.
Package: openimu-test
python-openimuPython driver for Aceinna OpenIMU Series Inertial Products.  Includes local and cloud file logging, and WebSocket serverpip install:pyserialtornadoazure-storage-blob
psutil
pathlib
requestsopenimu.pyThis is core driver for OpenIMU.  It can do the following functions:automatically discover an OpenIMU connected to serial portlog data to local file or azure cloudparse various ouput packetsread/write and get/set EEPROM fieldsupgrade firmware of devicerun as a thread in websocket server see belowserver.pyCreate a web socket server on wss://localhost:8000 that bridges ANS to a locally running openimu serial port driver.  Places openimu driver in a threadautomatically sends data out on wss://localhost:8000 every 33mS encoding packet as JSON.receives messages via on_message handler from ANS currently messages are - status, start_log, stop_log and cmd.file_storage.pyThese file store parsed packet data to CSV either locally or on Azure cloud.  Uses Azure Python SDK to write to Azure.commands.pyCommand Line Interface to access OpenIMU devicedata/ directoryLog files .csv are saved under the directoryapp_config/apps/openimuapps' json
Package: openimu-test10
python-openimuPython driver for Aceinna OpenIMU Series Inertial Products.  Includes local and cloud file logging, and WebSocket serverpip install:pyserialtornadoazure-storage-blob
psutil
pathlib
requestsopenimu.pyThis is core driver for OpenIMU.  It can do the following functions:automatically discover an OpenIMU connected to serial portlog data to local file or azure cloudparse various ouput packetsread/write and get/set EEPROM fieldsupgrade firmware of devicerun as a thread in websocket server see belowserver.pyCreate a web socket server on wss://localhost:8000 that bridges ANS to a locally running openimu serial port driver.  Places openimu driver in a threadautomatically sends data out on wss://localhost:8000 every 33mS encoding packet as JSON.receives messages via on_message handler from ANS currently messages are - status, start_log, stop_log and cmd.file_storage.pyThese file store parsed packet data to CSV either locally or on Azure cloud.  Uses Azure Python SDK to write to Azure.commands.pyCommand Line Interface to access OpenIMU devicedata/ directoryLog files .csv are saved under the directory
Package: openimu-testa
python-openimuPython driver for Aceinna OpenIMU Series Inertial Products.  Includes local and cloud file logging, and WebSocket serverpip install:pyserialtornadoazure-storage-blob
psutil
pathlib
requestsopenimu.pyThis is core driver for OpenIMU.  It can do the following functions:automatically discover an OpenIMU connected to serial portlog data to local file or azure cloudparse various ouput packetsread/write and get/set EEPROM fieldsupgrade firmware of devicerun as a thread in websocket server see belowserver.pyCreate a web socket server on wss://localhost:8000 that bridges ANS to a locally running openimu serial port driver.  Places openimu driver in a threadautomatically sends data out on wss://localhost:8000 every 33mS encoding packet as JSON.receives messages via on_message handler from ANS currently messages are - status, start_log, stop_log and cmd.file_storage.pyThese file store parsed packet data to CSV either locally or on Azure cloud.  Uses Azure Python SDK to write to Azure.commands.pyCommand Line Interface to access OpenIMU devicedata/ directoryLog files .csv are saved under the directoryapp_config/apps/openimuapps' json
Package: openimu-testb
python-openimuPython driver for Aceinna OpenIMU Series Inertial Products.  Includes local and cloud file logging, and WebSocket serverpip install:pyserialtornadoazure-storage-blob
psutil
pathlib
requestsopenimu.pyThis is core driver for OpenIMU.  It can do the following functions:automatically discover an OpenIMU connected to serial portlog data to local file or azure cloudparse various ouput packetsread/write and get/set EEPROM fieldsupgrade firmware of devicerun as a thread in websocket server see belowserver.pyCreate a web socket server on wss://localhost:8000 that bridges ANS to a locally running openimu serial port driver.  Places openimu driver in a threadautomatically sends data out on wss://localhost:8000 every 33mS encoding packet as JSON.receives messages via on_message handler from ANS currently messages are - status, start_log, stop_log and cmd.file_storage.pyThese file store parsed packet data to CSV either locally or on Azure cloud.  Uses Azure Python SDK to write to Azure.commands.pyCommand Line Interface to access OpenIMU devicedata/ directoryLog files .csv are saved under the directoryapp_config/apps/openimuapps' json
Package: open-inference-grpc
Open Inference Protocol gRPC Clientopen-inference-grpcis a generated client library based on the gRPC protocol definition tracked in theopen-inference/open-inference-protocol/repository.InstallationThis package requires Python 3.8 or greater.Install with your favorite tool from pypi.org/project/open-inference-grpc/$pipinstallopen-inference-grpc$poetryaddopen-inference-grpcA REST-based python client (open-inference-openapi) also exists for the Open Inference Protocol, and can be installed alongside this gRPC client, as both are distributed asnamespace packages.Example# These dependencies are installed by open-inference-grpcimportgrpcfromgoogle.protobuf.json_formatimportMessageToDictfromopen_inference.grpc.serviceimportGRPCInferenceServiceStubfromopen_inference.grpc.protocolimport(ServerReadyRequest,ModelReadyRequest,ModelMetadataRequest,ModelInferRequest,)withgrpc.insecure_channel("localhost:8081")aschannel:client=GRPCInferenceServiceStub(channel)# Check that the server is live, and it has the iris model loadedclient.ServerReady(ServerReadyRequest())client.ModelReady(ModelReadyRequest(name="iris-model"))# Make an inference requestpred=client.ModelInfer(ModelInferRequest(model_name="iris-model",inputs=[{"name":"input-0","datatype":"FP64","shape":[1,4],"contents":{"fp64_contents":[5.3,3.7,1.5,0.2]},}],))print(MessageToDict(pred))# {#     "modelName": "iris-model",#     "parameters": {"content_type": {"stringParam": "np"}},#     "outputs": [#         {#             "name": "output-1",#             "datatype": "INT64",#             "shape": ["1", "1"],#             "parameters": {"content_type": {"stringParam": "np"}},#             "contents": {"int64Contents": ["0"]},#         }#     ],# }Async versions of the same APIs are also available, usegrpc.aioinstead to create a channel thenawaitand requests made.asyncwithgrpc.aio.insecure_channel('localhost:8081')aschannel:stub=GRPCInferenceServiceStub(channel)awaitstub.ServerReady(ServerReadyRequest())DependenciesTheopen-inference-grpcpython package relies only ongrpcio, the underlying transport implementation of gRPC.ContributeThis client is largely generated automatically bygrpc-tools, with a small amount of build post-processing inbuild.py.Runpython build.pyto build this package, it will:Ifproto/open_inference_grpc.protois not found, download it fromopen-inference/open-inference-protocol/Run grpcio_tools.protoc to create the python clientPostprocess filenames and importsPrepend the Apache 2.0 License preambleFormat withblackIf you want to contribute to the open-inference-protocol itself, please create an issue or PR in theopen-inference/open-inference-protocolrepository.LicenseBy contributing to Open Inference Protocol Python client repository, you agree that your contributions will be licensed under its Apache 2.0 License.
Package: open-inference-openapi
Open Inference Protocol OpenAPI Clientopen-inference-openapiis a generated client library based on the OpenAPI protocol definition tracked in theopen-inference/open-inference-protocol/repository.InstallationThis package requires Python 3.8 or greater.Install with your favorite tool from pypi.org/project/open-inference-openapi/$pipinstallopen-inference-openapi$poetryaddopen-inference-openapiA gRPC-based python client (open-inference-grpc) also exists for the Open Inference Protocol, and can be installed alongside this gRPC client, as both are distributed asnamespace packages.Examplefromopen_inference.openapi.clientimportOpenInferenceClient,InferenceRequestclient=OpenInferenceClient(base_url='http://localhost:5002')# Check that the server is live, and it has the iris model loadedclient.check_server_readiness()client.read_model_metadata('mlflow-model')# Make an inference request with two examplespred=client.model_infer("mlflow-model",request=InferenceRequest(inputs=[{"name":"input","shape":[2,4],"datatype":"FP64","data":[[5.0,3.3,1.4,0.2],[7.0,3.2,4.7,1.4],],}]),)print(repr(pred))# InferenceResponse(#     model_name="mlflow-model",#     model_version=None,#     id="580c30e3-f835-418f-bb17-a3074d42ad21",#     parameters={"content_type": "np", "headers": None},#     outputs=[#         ResponseOutput(#             name="output-1",#             shape=[2, 1],#             datatype="INT64",#             parameters={"content_type": "np", "headers": None},#             data=TensorData(__root__=[0.0, 1.0]),#         )#     ],# )Async versions of the same APIs are also available. ImportAsyncOpenInfereClientinstead, thenawaitand requests made.fromopen_inference.openapi.clientimportAsyncOpenInferenceClientclient=AsyncOpenInferenceClient(base_url="http://localhost:5002")awaitclient.check_server_readiness()DependenciesTheopen-inference-openapipython package relies on:pydantic- Message formatting, structure, and validation.httpx- Implementation of the underlying HTTP transport.ContributeThis client is largely generated automatically byfern, with a small amount of build post-processing inbuild.py.Runpython build.pyto build this package, it will:Iffern/openapi/open_inference_rest.yamlis not found, download it fromopen-inference/open-inference-protocol/Runfern generateto create the python client (fern-api must be installednpm install --global fern-api)Postprocess to correctly implement the recursive TensorData model.Prepend the Apache 2.0 License preambleFormat withblackIf you want to contribute to the open-inference-protocol itself, please create an issue or PR in theopen-inference/open-inference-protocolrepository.LicenseBy contributing to Open Inference Protocol Python client repository, you agree that your contributions will be licensed under its Apache 2.0 License.
Package: opening_hours
## OpeningHours (python)This module is a parser between the excellent [OpenStreetMap Opening Hour format](https://wiki.openstreetmap.org/wiki/Key:opening_hours) and python datetime objects.### Installation```pip install opening_hours```### Usage```from opening_hours import OpeningHoursfrom datetime import datetimeimport pytzoh = OpeningHours("2016 Mar: Mo-Sa 08:00-13:00,14:00-17:00")oh.is_open(datetime.now(pytz.timezone('Europe/Paris')))```
Package: opening-hours-py
Python bindings forOSM Opening HoursUsageThe package is published for Python 3.7 and above, but you might be able to install it
with older version of Python if you install the Rust toolchain.Installopening-hours-pyfrom PyPI, for example using pip:pipinstall--useropening-hours-pyThen, the main object that you will interact with will beOpeningHours:fromopening_hoursimportOpeningHoursoh=OpeningHours("Mo-Fr 10:00-18:00; Sa-Su 10:00-12:00")print("Current status is",oh.state())print("This will change at",oh.next_change())The API is very similar to Rust API but you can find a Python specific
documentationhere.DeveloppementTo build the library by yourself you will require a recent version of Rust,rustupis usually the recommanded
tool to manage the installation.Then you can use poetry to install Python dependancies and runmaturin(the
building tool used to create the binding) from a virtualenv.gitclonehttps://github.com/remi-dupre/opening-hours-rs.gitcdopening-hours-rs# Install Python dependanciespoetryinstall# Enter the virtualenvpoetryshell# Build developpement bindings, add `--release` for an optimized versionmaturindevelop# Now the library is available as long as you don't leave the virtualenvpython
>>>fromopening_hoursimportOpeningHours
>>>oh=OpeningHours("24/7")>>>oh.state()"open"
Package: open-in-mpv
Open in mpvThis browser extension displays a context menu itemOpen in mpvfor links. When clicked it will
pass the URL of the link to mpv (which must bePATH).If you have yt-dlp installed and inPATH, then mpv will try to use it to resolve URLs it cannot
handle. This means you can right-click on any YouTube video page or link, chooseOpen in mpvand
view the video with mpv.InstallationFirst,install the extension.
Quit your browser.There are many ways to perform the next step. Below is the most basic, assuming you have Pip
installed. Before running the commands below, quit your browser.Gentoo users can simply installmedia-video/open-in-mpvfrommy overlay.pipinstall--useropen-in-mpv
open-in-mpv-install--userThe above will install the native host JSON file to supported Chromium-based browsers whose paths are
known, but only if the browser has created the directories before. If you want to force the
installation you can pass--force.Seeopen-in-mpv-install --helpfor more options. Linux users can pass the--systemoption to
install the native host part of the extension system-wide.Uninstallationopen-in-mpv-uninstall
pipremove--useropen-in-mpvUninstall the extension from your browser.Known issuesLinux: mpv is launched with--gpu-api=openglbecause with Vulkan it starts but fails to open a
window.At this time, Windows is not supported by theopen-in-mpvPython script. It may work, but it is
not supported.
Package: openioc-to-stix
Generates STIX Indicator Output from an OpenIOC v1.0 XML File.Source:https://github.com/STIXProject/openioc-to-stixDownload:https://pypi.python.org/pypi/openioc-to-stixOverviewTheopenioc-to-stixscript generates STIX Indicators from an OpenIOC v1.0
XML file.Compatible with OpenIOC v1.0Generates STIX v1.2 and CybOX v2.1 content.Please refer to the following websites for more information about the Structured Threat Information Expression (STIX),
Cyber Observable eXpression (CybOX), and OpenIOC efforts.STIX -https://stixproject.github.io/CybOX -https://cyboxproject.github.io/OpenIOC -http://www.openioc.orgRequirementsPython 2.6, 2.7, 3.4, 3.5, 3.6mixbox >= v1.0.1python-stix >= v1.2.0.2python-cybox >= 2.1.0.13NOTEVersion 1.0.1 of openioc-to-stix requires python-stix < 1.2.0.0,
python-cybox 2.1.0.12, and does not require mixbox.InstallationExtract included files into your directory of choice. Please refer to therequirements.txtfile for dependencies.Install dependencies with pip:$ pip install -r requirements.txtYou can also installopenioc-to-stixinto yoursite-packagesandPATHby usingpip:$ cd /path/to/cloned/openioc-to-stix/repo/
$ pip install .UsageThere are two main command line parameters for this script:-i: the path to the input OpenIOC XML file
-o: the path to the output STIX XML fileTo use the script, run the following command:$ python openioc-to-stix.py -i <OpenIOC XML file> -o <STIX XML file>Unsupported indicator items or those that error out during translation will be
translated into an empty Observable with a description of the error in order
to retain structural consistency between the input OpenIOC document and
output STIX document.Package ContentsREADME: This file.openioc-to-stix.py: OpenIOC XML to STIX XML Python script.openioc-to-cybox.py: OpenIOC XML to CybOX XML Python converter script
which this script wraps.openioc2stix/: Top-level API package.LICENSE.txt: Terms of use for this script.examples/*.xml: Sample input and output XML files.TERMSBY USING OPENIOC-TO-STIX YOU SIGNIFY YOUR ACCEPTANCE OF THE TERMS AND CONDITIONS
OF USE. IF YOU DO NOT AGREE TO THESE TERMS, DO NOT USE OPENIOC-TO-STIX.For more information, please refer to the LICENSE.txt file
Package: openirisapi
OpenIRIS APIA simple API foropeniris.io. OpenIRIS is a free platform permitting the publishing and management of resources form microscopy units.This API was developped as part of a France BioImaging project and is offered for use to anyone in the scientific community.At the moment, there is no REST API published by the site's developpers. This package aims to provide a functional solution that permits PROVIDER ardministration to download data directly from the website's backend.To get your cookie you have to use the Dev tools of your browser, Network > Cookie script > Cookie. You must then format it into a python dictionary and store it in a .txt file.Currently in Alpha, more features are scheduled to be added alongside a complete documentation.Here's a small example of some basic usage of the library# Import libaryimportopenirisapi.openirisapiasoi# Add cookie from text filecookie=oi.utilities.get_cookie('cookies.txt')# Download all bookings in a specific timeframe in dataframe formdf=oi.getBookings(cookie,start='2002-03-07',end='2024-03-07')# Download all users associated to the Provider and the groups that you administer# and save to csvusers_df=oi.getUsers(cookies,start='2021-03-07',end='2023-03-08',to_csv=True):# Download all resiources associated to the Provider(s) that you administer# and skip save to csvresources_df=oi.getAllResources(cookies,to_csv=False)
Package: openitcr
openitcrDescriptionOpen Information Technology Classroom. (In fact, it's just some unities,
I do nothing, thank you to the developers of all relevant projects),
❤️ 🐧.Software ArchitectureSoftware architecture descriptionInstallationxxxxxxxxxxxxInstructionsxxxxxxxxxxxxContributionFork the repositoryCreate Feat_xxx branchCommit your codeCreate Pull RequestGitee FeatureYou can use Readme_XXX.md to support different languages, such as
Readme_en.md, Readme_zh.mdGitee blogblog.gitee.comExplore open source project [https://gitee.com/explore]
(https://gitee.com/explore)The most valuable open source projectGVPThe manual of Giteehttps://gitee.com/helpThe most popular members  [https://gitee.com/gitee-stars/]
(https://gitee.com/gitee-stars/)