Saravanan666/pypi-org huggingface dataset:
Package: openobject-library
Version:2.0openobject-libraryis a library to interract with the OpenERP Framework, known asOpenObjectwith NETRPCInstallationYou can installoobjlibeither via the Python Package Index (PyPI)
or from source.To install usingpip,:$ pip install openobject-libraryTo install usingeasy_install,:$ easy_install openobject-libraryIf you have downloaded a source tarball you can install it
by doing the following,:$ python setup.py build
$ sudo python setup.py installIf you want to develop a new functionnality, you can install it
by doing the following (in python 2.6 or greater),:$ python setup.py develop --useror simply:$ sudo python setup.py developQuick overviewimport sys
from oobjlib.connection import Database

try:
    db = Database(server='localhost', port=8070)
except Exception, e:
    print '%s' % repr(e)
    sys.exit(1)

for d in db.list():
    print '* %s' % dThis example retrieve all databases and print one line per databaseLicenceThis program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
Package: openoc
IntroductionOpenocis a Python package that solves optimal control problems numerically. It utilizes advanced techniques to be powerful, easy to use, and fast.Powerful: Openoc can solve basically any optimal problem. It employs a multi-phase optimal control model which allows continuous/non-continuous state and control variables, path/integral/boundary constraints, and fixed/free initial and terminal time.Easy to use: Openoc is designed to be easy to use. It provides aSymPy-based, intuitive interface for defining and solving problems.Fast: Openoc is fast. It uses various techniques to speed up the entire compilation & solution process, including symbolic differentiation (withSymPy), JIT compilation (withNumba), meta-programming, and more.InstallationThe easiest way to install openoc is usingconda:InstallAnacondaand create a new environment withPython 3.9.*Activate the environment, and run in the terminal:conda install numpy scipy sympy numba
conda install -c conda-forge cyipopt
pip install openocLicenseMIT. Feel safe to use it in your research & projects.
Package: openocd
openocdPython interface library forOpenOCD.DependenciesPython >= 3.6InstallationPrerequisites:Python 3.6 or higherhttps://www.python.org/setuptoolshttps://pypi.org/project/setuptools/To install this package, run:pythonsetup.pyinstallExamplefromopenocdimportOpenOcdwithOpenOcd()asoocd:oocd.halt()registers=oocd.read_registers(['pc','sp'])print('Program counter: 0x%x'%registers['pc'])print('Stack pointer: 0x%x'%registers['sp'])oocd.resume()LicenseThis project is licensed under theGPLv3+- see theLICENSEfile for details.
Package: openodia
openodiais a Python package which contains various tools on Odia language.The short term goal of this package is to not make state-of-the-art methods, but to make tools which work.InstallPlease install any Python 3 version. It should work. However, the library is tested in python 3.9 version.pipinstallopenodiaIf you want to directly build from the binary, please clone the repo and runsetup.py.gitclonehttps://github.com/soumendrak/openodia.gitUsageFor usage and further documentation please visit theDocumentationpage.LicenseCautionThanks for being an early visitor.The library is in active development phase and not for production use.
Package: openoffice-python
The library is designed to supports both writing macros (called by OOo) and
interacting with OOo from an external Python programm (using the UNO bridge).The “UNO bridge” side is meant to implement a more Pythonic and high-level
interface than Danny Bewers OOoLib. While the “Makro” side is meant to support
writing macros. Well, there will be a big intersection between these parts :-)Sample scripts include
- a simple OpenOffice-Server
- odf2pdf to convert ODF-Files to PDF
Package: openoligo
OpenOligoOpenOligo is an open-source platform for programmatically interacting with and managing DNA synthesis processes.Getting StartedpipinstallopenoligoA simple Exampleimportasynciofromopenoligo.instrumentimportInstrumentfromopenoligo.protocols.dna_synthesisimportsynthesizefromopenoligo.seqimportSeqinst=Instrument()try:asyncio.run(synthesize(inst,Seq("ATCGAAATTTTT")))exceptKeyboardInterrupt:print("Keyboard interrupt received, exiting...")FirmwareThe firmware for OpenOligo is composed ofOpenOligo LibraryAPI server (part of OpenOligo Library)In a minimal linux image (OligoOS)
Package: openolt
openolt quickstartopenolt is a collection of programs for managing Optical Line Terminals (OLTs) that support the VOLTHA project's Openolt api.Install and start Confluent KafkaTODO - Add help and links to Confluent docsInstall openoltGet the codegit clone git@github.com:shadansari/openolt.gitCreate the virtual envAll commands needs to run in a virtual env with PYTHONPATH set.cd openolt
pipenv shell
export PYTHONPATH=$PYTHONPATH:$PWD:$PWD/protos/third_partyConnect to OLT and publish events to KafkaFetch openolt indications from the device and publish to Kafkapython openolt/sb_grpc.py localhost:9092 10.90.0.114:9191Read openolt indications from kafkaconfluent-kafka/consumer.py localhost:9092 foo openolt.ind-10.90.0.114
Package: openomics
This Python package provide a series of tools to integrate and query the genomics, transcriptomics, proteomics, and
clinical data (aka multi-omics data). With scalable data-frame manipulation tools, OpenOmics facilitates the common
data wrangling tasks when preparing data for RNA-seq bioinformatics analysis.Documentation (Latest|Stable)
|OpenOmics at a glanceFeaturesOpenOmics assist in integration of heterogeneous multi-omics bioinformatics data. The library provides a Python API as well as an interactive Dash web interface.
It features support for:Genomics, Transcriptomics, Proteomics, and Clinical data.Harmonization with 20+ popular annotation, interaction, disease-association databases.OpenOmics also has an efficient data pipeline that bridges the popular data manipulation Pandas library and Dask distributed processing to address the following use cases:Providing a standard pipeline for dataset indexing, table joining and querying, which are transparent and customizable
for end-users.Providing Efficient disk storage for large multi-omics dataset with Parquet data structures.Integrating various data types including interactions and sequence data, then exporting to NetworkX graphs or data generators for down-stream machine learning.Accessible by both developers and scientists with a Python API that works seamlessly with an external Galaxy tool interface or the built-in Dash web interface (WIP).Installation via pip:$ pip install openomicsCitationsThe journal paper for this scientific package is currently being reviewed. In the meanwhile, the current package version can be cited with:# BibTeX
@software{nhat_jonny_tran_2021_4552831,
  author       = {Nhat Tran and
                  Jean Gao},
  title        = {{BioMeCIS-Lab/OpenOmics: Bug fixes from pyOpenSci
                   Reviewer 2}},
  month        = feb,
  year         = 2021,
  publisher    = {Zenodo},
  version      = {v0.8.5},
  doi          = {10.5281/zenodo.4552831},
  url          = {https://doi.org/10.5281/zenodo.4552831}
}CreditsThis package was created withCookiecutterand thepyOpenSci/cookiecutter-pyopensciproject template, based offaudreyr/cookiecutter-pypackage.
Package: openorg-timeseries
This is an implementation of the OpenOrgtime-series API specificationas a Django application.FeaturesStores data in a compact binary format for quick retrievalArchives data in CSV format to negate format-based lock-inTime-zone awareCustomisable aggregation (e.g. for daily and weekly averages, minima and maxima)Implements an API used by other time-series implementationsAllows creation, modification and updating of time-series from a RESTful web serviceHas a fine-grained permissions model for administering time-seriesFeatures yet to be implementedAdministration interface is still somewhat human-unfriendlyCustomisable alerts for when series haven’t been updated for some period of timeGauge and counter-based series (currently only period-based series)Virtual time-series (i.e. time-series which are some function of other time-series)ArchitectureThis project comprises a Django application that you can include in an existing
Django project by adding'openorg_timeseries'to yourINSTALLED_APPSvariable in your Django settings file.openorg_timeseries.longlivingcontains athreading.Threadwhich mediates access to the underlying data, and which prevents …Demonstration applicationThis project comes with a demonstration web service which you can use to quickly evaluate its usefulness.RunningFirst, install the necessary dependencies using pip:$ pip install -r requirements.txtNext, start the demonstration server using the following:$ django-admin.py rundemo –settings=openorg_timeseries.demo.settings –pythonpath=.Give it a few seconds, after which you can point a web browser athttp://localhost:8000/ <http://localhost:8000/to see it in action.DetailsThe demo site performs the following steps on start-up:Creates ademo-datadirectory in the current directory to store data used by the demoRuns thesyncdbDjango management command to create asqlite3database in thedemo-datadirectoryStarts a long-living process which manages the data storage and retrievalCreates a new time-series and loads in some example dataRuns therunservermanagement command (without the auto-reloader) to start the Django development server
Package: openpack
openpackprovides base functionality for working with theOpen
Office XML (OOXML)format in Python.IntroductionOpenpack is a base library for OpenXML documents. It is used by theparadocxandXlsXcessive.UtilitiesOpenpack includes two utilities for working with OpenXML documents from the
command-line,part-editandzip-listdir.These commands are additionally exposed as modules and may be invoked
usingpython-m, e.g.python-mopenpack.part-edit.zip-listdirzip-listdirisn’t specific to OpenXML, and will work on any zip file.
Since OpenXML documents are themselves zip files, however, it is useful to have
when working with OpenXML:> zip-listdir ../paradocx/data.docx
  [Content_Types].xml
d _rels
d wordzip-listdirlists the files and directories and can be used to list
sub-directories as well:> zip-listdir ../paradocx/data.docx/word
d _rels
  document.xmlpart-editWhilezip-listdirenables inspecting the structure of the zip content of
an OpenXML document,part-editfacilitates editing the various parts of
those documents using the client’s text editor. For example, to edit theword/document.xmlas found in data.docx from the previous example, simply
invoke part-edit:> part-edit ../paradocx/data.docx/word/document.xmlThe program will attempt to use the default text editor to edit the file. If
the default editor is not sufficient, the user may specify an editor by
setting either XML_EDITOR or EDITOR environment variables.part-editwill parse the zip file, locate the content within the zip file,
extract that content to a temporary file, and then open that content in an
editor. After the editor is closed, if the file was changed, the zip file
will be updated with the new content.The user may pass the optional--reformat-xml, in which case the XML will
be pretty-formatted for easier human readability.
Package: openpack-toolkit
OpenPack Dataset Toolkit (optk)"OpenPack Dataset"is a new large-scale multi modal dataset of manual packing process.
OpenPack is an open access logistics-dataset for human activity recognition, which contains human movement and package information from 16 distinct subjects.
This repository provide utilities to explore our exciting dataset.Dataset Release NoteOpenPack Dataset (v1.0.0)For preliminary analysis, please start frompreprocessed-IMU-with-operation-labels.zipinzenodo.
This preprocessed dataset include IMU data (acc, gyro, quaternion) assosiated with operatopn labels because you don't need to combine data and label.DocsDatasetSubjects & Recording ScenariosActivity Class DefinitionModalityData Split (Train/Val/Test/Submission)Task & Activity Recognition ChallengeWork Operation RecognitionOpenPack Challenge 2022Sample DataSampleInstallWe provide some utility functions as python package. You can install via pip with the following command.
Note that the supported dataset version is>=1.0.0.# Pippipinstallopenpack-toolkit# Poetrypoetryaddopenpack-toolkitExamplesTutorialDownload and Visualization (Notebook)Work Activity Recognition (PyTorch)PyTorch code samples for work operation prediction task is available.
Seeopenpack-torchfor more dietail.TimestampEach data point is associated with a millisecond-precision unix timestamp.
The following is a snippet that converts a timestamp (anintvalue) into adatatime.datetime()object with timezone.importdatetimedeftimestamp_to_datetime(ts:int)->datetime.datetime:"""Convert unix timestamp (milli-second precision) into datatime object. """timezone_jst=datetime.timezone(datetime.timedelta(hours=9))dt=datetime.datetime.fromtimestamp(ts/1000).replace(tzinfo=timezone_jst)returndtdefdatetime_to_timestamp(dt:datetime.datetime)->int:"""Convert a datetime object into a milli-second precision timestamp."""returnint(dt.timestamp()*1000)ts=1634885786000dt_out=timestamp_to_datetime(ts)ts_out=datetime_to_timestamp(dt_out)print(f"datetime:{dt_out}")# datetime: 2021-10-22 15:56:26+09:00print(f"timestamp:{ts_out}")# timestamp: 1634885786000assertts_out==tsDownload DatasetFrom Zenodo (w/o Depth Images)bashtools/download/dl_from_zenodo.sh<pathtoadatasetrootdirectory># Example:bashtools/download/dl_from_zenodo.sh./data/datasetsLinksHomepage(External Site)OpenPack Challenge 2022(External Site)zenodoAPI DocsPyPIopenpack-torchLicenseopenpack-toolkit has a MIT license, as found in theLICENSEfile.NOTE:OpenPack Datasetitself is available underCreative Commons Attribution Non Commercial Share Alike 4.0 Internationallicense.
However,OpenPack Dataset (+RGB) Licenseis applied to "OpenPack Dataset (+RGB)" which includs RGB data.
Package: openpack-torch
openpack-torchPyTorch utilities to work around withOpenPack Dataset.SetupYou can install via pip with the following command.# Pippipinstallopenpack-torch# Poetrypoetryaddopenpack-torchDocsDataset PageAPI DocsPyPI - openpack-torchExamplesSee./examples/README.mdOperation Recognition (Semantic Segmentation)IMUAccelerationU-Net(PyTorch Model)DeepConvLSTM(PyTorch Model)VisionKeypointsST-GCN(PyTorch Model)Scores of Baseline Moodel (Preliminary Experiments)Split: Pilot ChallengeModelF1 (Test Set)F1 (Submission Set)DateCodeUNet0.34510.37472022-06-28run_unet.pyDeepConvLSTM0.70810.76952022-06-28run_dcl.pyST-GCN0.70240.61062022-07-07run_stgcn.pyNOTE: F1 = F1-measure (macro average)Split: OpenPack Challenge 2022This split is defined for OpenPack Challenge 2022.ModelF1 (Test Set)F1 (Submission Set)DateCodeUNetTBATBA--DeepConvLSTMTBATBA--ST-GCNTBATBA--OpenPack Challenge 2022 @ PerCom2023 WS BirdWe are hosting an activity recognition competition, using the OpenPack dataset at aPerCom 2023 Workshop!
The task is very simple: Recognize 10 work operations from the OpenPack dataset.
Please join this exciting opportunity. For more information about the competition, clickhere.TutorialsTrain a baseline model and make submission file.Change input modalities.LICENCEThis software (openpack-torch) is distributed underMIT Licence.
For the license of "OpenPack Dataset", please checkthis site (https://open-pack.github.io/).
Package: openpathsampling-cli
OpenPathSampling CLIThe command line interface to OpenPathSamplingOpenPathSampling is a powerful and flexible library for path sampling
simulations. However, many users would prefer to interact with an executable on
the command line, instead of writing everything in their own Python script.
Here is that command line tool, including some useful scripts for dealing with
OPS output files.The CLI is used as a single executable,openpathsampling, with multiple
subcommands. We recommend aliasingopenpathsamplingto something simpler (maybeops?) to save typing!Current categories of subcommands are for simulation running, and for
miscellaneous operations on OPS output files.Simulation Commands:visit-all:     Run MD to generate initial trajectoriesmd:            Run MD for fixed time or until a given ensemble is satisfiedequilibrate:   Run equilibration for path samplingpathsampling:  Run any path sampling simulation, including TIS variantsMiscellaneous Commands:contents:         List named objects from an OPS .nc fileappend:           add objects from INPUT_FILE  to another fileFull documentation is athttps://openpathsampling-cli.readthedocs.io/; a brief
summary is below.InstallationThe OPS CLI can be installed with eithercondaorpip:conda-cconda-forgeinstallopenpathsampling-cli# orpipinstallopenpathsampling-cliNote that installing the CLI will also install OpenPathSampling, if you don't
already have it.WorkflowSet up,thensimulate!The overall idea is that you will first set up your
simulation, and then use these scripts to run the resulting simulation setup
files. Currently, writing a Python script (or better, using a Jupyter notebook
to set things up interactively) is the best way to do that. Save the necessary
simulation objects to asetup.ncfile, and then use these scripts to run the
simulation.Creating your own commandsCreating your own commands is extremely easy. The OPS CLI uses a plug-in
architecture so that installing your own commands is as easy as putting a
Python file in your~/.openpathsampling/cli-plugins/directory.
We provide a standard set of parameters as decorators, which can (and should)
be re-used to load things from storage. The CLI is built onclick, so additional arguments are
easily added using functionality fromclick. See our developer documentation
for details.
Package: openpd
OpenPD: Opened Peptide Dynamics packageIntroductionOpenPD, standing forOpenPeptideDynamics, is a python package, distributed freely under the terms of
GNU Public License Version 3 (GPLv3), for peptide dynamics simulation. It was designed to simulate the folding dynamics of protein efficiently with the assistance ofPeptideDynamicsForceField (PDFF), which is a solvent considered, high-level coarse-grained force field focusing on the peptide interaction.OpenPD is developed and maintained by Zhenyu Wei (zhenyuwei99@gmail.com), from Yunfei Chen's group in Southeast University. As a newly developed program, we always welcome developers to contact us.The OpenPD distribution includes following files and folders:NameDescriptionREADMEThis fileLICENSEMIT LicensedocsDocumentationopenpdSource code of openpd python moduletutorialsFolder contains tutorial notebooksetup.pyBuild script for setuptoolsNeed help?To get more information, please check out the projectdocumentation.
Package: openpdfsign-configurator
open-pdf-sign-configuratorThis package can be used to install the open-pdf-sign server to sign all PDFs on your Nginx server
After you install this and activate it, all PDFs served by your Nginx server will automatically be signed by your
SSL certificate for your domain being used by NginxFor more details please go tohttps://openpdfsign.org/RequirementsJava 8 or higherpython 3.9 or highInstallIn order to install the configurator runapt-getinstalldefault-jrepython3python3-pip
pipinstallopenpdfsign-configurator
opsconfigIf you want to remove, remove relevant blocks in your Nginx config and runrm/etc/systemd/system/openpdfsign.service
rm-rf/etc/openpdfsignDevelopmentFor releasing the python package run:python -m buildtwine upload -r testpypi dist/*twine upload -r pypi dist/*
Package: openpdi
OpenPDIOpenPDI is an unofficial effort to document and standardize data submitted to
thePolice Data Initiative(PDI). The goal is to make the data more accessible
by addressing a number of issues related to a lack of
standardization—namely,File types: While some agencies make use if theSocrata Open Data API, many provide their data
in raw.csv,.xlsx, or.xlsfiles of varying structures.Column names: Many columns that represent the same data (e.g., the race
police officer) are named differently across departments, cities, and states.Value formats: Dates, times, and other comparable fields are submitted in
many different formats.Column availability: It's currently very difficult to identify data
sources that contain certain columns—e.g.,Use of Forcedata
specifying the hire date of the involved officer(s).Getting StartedInstallation$pipinstallopenpdiUsageDatasetIDSourceUse of Forceuofhttps://www.policedatainitiative.org/datasets/use-of-force/importcsvimportopenpdi# The library has a single entry point:dataset=openpdi.Dataset(# The dataset ID (see the table above)."uof",# Limit the data sources to a specific state using its two-letter code.## Default: `scope=[]`.scope=["TX"],# A list of columns that must be provided in every data source included in# this dataset. See `openpdi/meta/{ID}/schema.json` for the available# columns.## Default: `columns=[]`.columns=["reason"],# If `True`, only return the user-specified columns -- i.e., those listed# in the `columns` parameter.## Default: `strict=False`.strict=False)# The names of the agencies included in this dataset:print(dataset.agencies)# The URLs of the external data sources inlcuded in this dataset:print(dataset.sources)# `gen` is a generator object for iterating over the CSV-formatted dataset.gen=dataset.download()# Write to a CSV file:withopen("dataset.csv","w+")asf:writer=csv.writer(f,delimiter=",",quoting=csv.QUOTE_ALL)writer.writerows(gen)DatasetsIn an attempt to avoid unnecessary bloat (in terms of GBs), we don't actually store any PDI data in this repository. Instead, we store small, JSON-formatted descriptions of externally hosted datasets—for example,uof/CA/meta.json:[{"url":"https://www.norwichct.org/Archive.aspx?AMID=61&Type=Recent","type":"csv","start":1,"columns":{"date":{"index":0,"specifier":"%m/%d/%Y"},"city":{"raw":"Richmond"},"state":{"raw":"CA"},"service_type":{"index":1},"force_type":{"index":10},"light_conditions":{"index":8},"weather_conditions":{"index":7},"reason":{"index":2},"officer_injured":{"index":6},"officer_race":{"index":9},"subject_injured":{"index":5},"aggravating_factors":{"index":3},"arrested":{"index":4}}}]This file describes a Use of Force (uof) dataset from Richmond, CA. Each entry in thecolumnsarray maps a column from the externally-hosted data to a column in the dataset's schema file (uof/schema.json).Theschema.jsonfile assigns aformatto every possible column in a particular dataset, which is a Python function tasked with standardizing a raw column value (seeopenpdi/validators.py).
Package: openpecha
OpenPecha ToolkitDescription•Owner•Install•DocsDescriptionOpenPecha Toolkit allows state of the art solution for distributed standoff annotations on moving texts, in which Base layer can be edited without affecting annotations. This is made possible by our OpenPecha Native Format calledopf(OpenPecha Format) and our collection ofimporterswhich can parse existing text intoopfandexporterswhich can exportopftext into any format (.epub,.docx,.pdf, etc)Owner@10zinten:floppy_disk: InstallStable version:pip install openpechaDaily development version:pip install git+https://github.com/OpenPecha/Openpecha-ToolkitDocsDocumentation:docsIf you have any problems withopenpecha-toolkit, please openissuesDeveloper Installation.gitclonehttps://github.com/OpenPecha-dev/openpecha-toolkit.gitcdopenpecha-toolkit
pipinstall-rrequirements-dev.txt
pipinstall-e.
pre-commitinstallTestingPYTHONPATH=.:$PYTHONPATHpytesttests