Saravanan666/pypi-org huggingface dataset:
Package: opendr-toolkit-skeleton-based-action-recognition
The aim of OpenDR is to develop a modular, open and non-proprietary toolkit for core robotic functionalities by harnessing deep learning to provide advanced perception and cognition capabilities, meeting in this way the general requirements of robotics applications in the applications areas of healthcare, agri-food and agile production. The term toolkit in OpenDR refers to a set of deep learning software functions, packages and utilities used to help roboticists to develop and test a robotic application that incorporates deep learning. OpenDR will provide the means to link the robotics applications to software libraries (deep learning frameworks, e.g., Tensorflow) and to link it with the operating environment (ROS). OpenDR focuses on the AI and Cognition core technology in order to provide tools that make robotic systems cognitive, giving them the ability to a) interact with people and environments by developing deep learning methods for human centric and environment active perception and cognition, b) learn and categorise by developing deep learning tools for training and inference in common robotics settings, and c) make decisions and derive knowledge by developing deep learning tools for cognitive robot action and decision making (WP5). As a result, the developed OpenDR toolkit will also enable cooperative human-robot interaction as well as the development of cognitive mechatronics where sensing and actuation are closely coupled with cognitive systems thus contributing to another two core technologies beyond AI and Cognition. OpenDR will develop, train, deploy and evaluate deep learning models that improve the technical capabilities of the core technologies beyond the current state of the art. It will enable a greater range of robotics applications that can be demonstrated at TRL 3 and above, thus lowering the technical barriers within the prioritised application areas. OpenDR aims to an easily adopted methodology to adapt the provided tools in order to solve any robotics task without restricting it to any specific application.
Package: opendr-toolkit-speech-recognition
The aim of OpenDR is to develop a modular, open and non-proprietary toolkit for core robotic functionalities by harnessing deep learning to provide advanced perception and cognition capabilities, meeting in this way the general requirements of robotics applications in the applications areas of healthcare, agri-food and agile production. The term toolkit in OpenDR refers to a set of deep learning software functions, packages and utilities used to help roboticists to develop and test a robotic application that incorporates deep learning. OpenDR will provide the means to link the robotics applications to software libraries (deep learning frameworks, e.g., Tensorflow) and to link it with the operating environment (ROS). OpenDR focuses on the AI and Cognition core technology in order to provide tools that make robotic systems cognitive, giving them the ability to a) interact with people and environments by developing deep learning methods for human centric and environment active perception and cognition, b) learn and categorise by developing deep learning tools for training and inference in common robotics settings, and c) make decisions and derive knowledge by developing deep learning tools for cognitive robot action and decision making (WP5). As a result, the developed OpenDR toolkit will also enable cooperative human-robot interaction as well as the development of cognitive mechatronics where sensing and actuation are closely coupled with cognitive systems thus contributing to another two core technologies beyond AI and Cognition. OpenDR will develop, train, deploy and evaluate deep learning models that improve the technical capabilities of the core technologies beyond the current state of the art. It will enable a greater range of robotics applications that can be demonstrated at TRL 3 and above, thus lowering the technical barriers within the prioritised application areas. OpenDR aims to an easily adopted methodology to adapt the provided tools in order to solve any robotics task without restricting it to any specific application.
Package: opendr-toolkit-speech-transcription
The aim of OpenDR is to develop a modular, open and non-proprietary toolkit for core robotic functionalities by harnessing deep learning to provide advanced perception and cognition capabilities, meeting in this way the general requirements of robotics applications in the applications areas of healthcare, agri-food and agile production. The term toolkit in OpenDR refers to a set of deep learning software functions, packages and utilities used to help roboticists to develop and test a robotic application that incorporates deep learning. OpenDR will provide the means to link the robotics applications to software libraries (deep learning frameworks, e.g., Tensorflow) and to link it with the operating environment (ROS). OpenDR focuses on the AI and Cognition core technology in order to provide tools that make robotic systems cognitive, giving them the ability to a) interact with people and environments by developing deep learning methods for human centric and environment active perception and cognition, b) learn and categorise by developing deep learning tools for training and inference in common robotics settings, and c) make decisions and derive knowledge by developing deep learning tools for cognitive robot action and decision making (WP5). As a result, the developed OpenDR toolkit will also enable cooperative human-robot interaction as well as the development of cognitive mechatronics where sensing and actuation are closely coupled with cognitive systems thus contributing to another two core technologies beyond AI and Cognition. OpenDR will develop, train, deploy and evaluate deep learning models that improve the technical capabilities of the core technologies beyond the current state of the art. It will enable a greater range of robotics applications that can be demonstrated at TRL 3 and above, thus lowering the technical barriers within the prioritised application areas. OpenDR aims to an easily adopted methodology to adapt the provided tools in order to solve any robotics task without restricting it to any specific application.
Package: opendssdirect.py
OpenDSSDirect.pyOpenDSSDirect.py is a cross-platform Python package implements a "direct" library interface toour customized implementationofOpenDSSusingDSS-Python.
OpenDSS is an open-source distribution system simulator. SeeOpenDSSDirect.jlfor a similar package in Julia, and for more context about this project and its components (including alternatives in MATLAB, C++ and C#/.NET), please checkhttps://dss-extensions.org/and our hub repository atdss-extensions/dss-extensionsfor more documentation, discussions and theFAQ.As a reminder, although very compatible, this project is not supported by EPRI.This package is available for Windows, Mac and Linux, including ARM and x86 variants.DocumentationThe documentation for this package can be foundhere.InstallationRecommended: Install Python using Miniconda or AnacondaOpen a command line interface and type the following.pipinstall'OpenDSSDirect.py[extras]'See theinstallationinstructions for more information.Updating from pre-v0.9 versions?See the upgrade guide for recommendations.TroubleshootingIt is recommended to usecondato install pandas, which is currently a dependency of this package.
This package interfaces with OpenDSS using the "direct" library interface, so a good understanding of OpenDSS will help troubleshooting.If you are having issues using this Python interface, feel free to open an Issue on GitHubhere.ThanksThanks to @tshort, Davis, @temcdrm, @GordStephen, @Muxelmann and @PMeira for their contributions, as well as all the users for their valuable feedback.See also our repositories forDSS-Pythonfor the underlying Python package used in this package, andDSS C-APIfor the modified and extended OpenDSS codebase used in DSS-Extensions.
Package: opendt
Make a data augmentation with tensorflow and pythonWrite your own data augmentation with tensorflow2 and python 3Librairies used:Python 3.6Tensorflow 2.1.0Matplotlib 3Tensorflow_docsPILBrain :)How to have itmake sure that you have tensorflow installed on your machine(Laptop). For my case, I have it on ubuntu 18.04.
The best way for you to install dependencies, it is virtualenvwrapper. How to install it in 1 minute ->VIDEO#for dependencies:
pip install -r requirements.txt

#clone it by typing:
git clone https://github.com/bm777/Data_augmentation.git
cd Data_augmentation

#run it by typing:
python3 Data_augment.pyResult of augmentationView of original imageCredictTF: tensorflow
Package: opendv
An Open-Source Framework for Shapley-based value intened intended for data valuation.Overview•Installation•How To UseWhat's New?TBD $\text{\color{red}{!in progress}}$OverviewShapley-based valuesare prevalent data valuation approaches, which are attractive for its fair properties (axioms).The approaches are planned to support including Shapley-based values and some other famous values for data valuation.Shapley-based values:Shapley valueBeta Shapley valueKNN Shapley valueAsymmetric Shapley valueRobust Shapley valueCosine gradient Shapley valueCS-Shapley valueBanzhaf valueVolumn-based Shapley valueOthers:LOODVRLData-OOBWhat Can You Do via OpenDV?Use the implementations of current Shapley-based values.* We have implemented various of Shapley-based values and corresponding SOTA computation techniques. You can easily call and understand these methods.Design your own data valuation work. With the extensibility of OpenDV, you can quickly practice your data valuation ideas.InstallationNote: Please use Python 3.10+ for OpenDVUsing PipOur repo is tested on Python3.10+, install OpenDV using pip as follows:pipinstallopendvTo play with the latest features, you can also install OpenDV from the source.Using GitClone the repository from github:gitclonehttps://github.com/ZJU-DIVER/OpenDV.gitcdopendv
pipinstall-rrequirements.txt
pythonsetup.pyinstallModify the codepythonsetup.pydevelopUse OpenDVTBDBase ConceptsTBD
Package: openean
OpenEANLibrary to use the api of the Open EAN/GTIN Databaseserves as API wrapper for the api ofthis EAN/GTIN database serviceGetting startedInstall the library from pypi viapip install openeanThen you need an user_id for the service;more info how you get thatThere is also an id for small tests: "400000000" as described herehttps://opengtindb.org/faq.php#gfromopenean.OpenEANimportOpenEANuserID=400000000#user your own id hereopenean=OpenEAN(userID)barcode_num=1111#barcode number of you productitems=openean.parse(barcode_num)#items is a list of possible products associated with the code# the properties of each item are described here https://opengtindb.org/api.php#only to show you structure of working results#not needed for usefrompprintimportpprintforiteminitems:pprint(vars(item))Thanks toThe creators of the API for making this possible and please consider donating to"Kueste gegen Plastik"if you like this service to help the creators of the database running it.
Package: openeats-recipe-scraper
## Recipe scrapers[![Build Status](https://travis-ci.org/hhursev/recipe-scraper.svg?branch=master)](https://travis-ci.org/hhursev/recipe-scraper)A simple web scraping tool for recipe sites I use in a project of mine that makes sense to live as
a separate package.No Python 2 support.pip install git+git://github.com/hhursev/recipe-scraper.gitthen:from recipe_scrapers import scrap_me# give the url as a string, it can be url from any site listed below
scrap_me = scrap_me(’http://allrecipes.com/Recipe/Apple-Cake-Iv/Detail.aspx’)scrap_me.title()
scrap_me.total_time()
scrap_me.ingredients()
scrap_me.instructions()### ContributePart of the reason I want this open sourced is because if a site makes a design change, the scraper
for it should be modified.If you spot a design change (or something else) that makes the scrapers unable to work for the given
site - please fire an issue asap.If you are programmer PRs with fixes are warmly welcomed and acknowledged with a virtual beer:beer:.### Scrapers available for:[http://101cookbooks.com/](http://101cookbooks.com/)[http://allrecipes.com/](http://allrecipes.com/)[http://bbc.co.uk/](http://bbc.co.uk/food/recipes/)[http://bbcgoodfood.com/](http://bbcgoodfood.com/)[http://bonappetit.com/](http://bonappetit.com/)[http://closetcooking.com/](http://closetcooking.com/)[http://cookstr.com/](http://cookstr.com/)[http://epicurious.com/](http://epicurious.com/)[http://finedininglovers.com/](https://www.finedininglovers.com/)[http://foodrepublic.com/](http://foodrepublic.com)[http://jamieoliver.com/](http://www.jamieoliver.com/)[http://mybakingaddiction.com/](http://mybakingaddiction.com/)[http://paninihappy.com/](http://paninihappy.com/)[http://realsimple.com/](http://www.realsimple.com/)[http://simplyrecipes.com/](http://www.simplyrecipes.com)[http://steamykitchen.com/](http://steamykitchen.com/)[http://tastykitchen.com/](http://tastykitchen.com/)[http://thepioneerwoman.com/](http://thepioneerwoman.com/)[http://thevintagemixer.com/](http://www.thevintagemixer.com/)[http://twopeasandtheirpod.com/](http://twopeasandtheirpod.com/)[http://whatsgabycooking.com/](http://whatsgabycooking.com/)
Package: openeditor
openeditorEdit files with your$EDITOR, like git commit does.UsageInstall with:pip install openeditor# Let user edit file
s = openeditor.edit_file("path/to/my/file.txt")
print("The file now contains:\n" + s)

# Use a temp file
s = openeditor.edit_file(
    "# Please edit this file, save and close editor when done", 
    "path/to/my/file.txt"
)
print("The file now contains:\n" + s)The editor is obtained from, in order of precedence:$VISUAL$EDITORIf neither of these provide a useful editor, an exception will be thrown.Limitationsopeneditorexpects an editor string similar toEDITOR=cmdsuch that:cmd file.txt(filename as the final argument) is a correct way of editingfile.txt.cmdis not too complex. Simple things like space-separated flags (eg.EDITOR="vim -n") are fine but advanced shell magic may break.If yourcmddoesneed to be more complex, one possible workaround is to write a wrapper script that presents a compatible command-line interface toopeneditorand invokes the full command as appopriate.
Package: openedoo
# WELCOME TO OPENEDOO## openedoo-beta in pip```pip install openedooand run in your terminalopenedoo install```## how to use```bashgit clone https://github.com/openedoo/openedoopip install -r requirements.txt```### Migrate Database```bashpython manage.py db initpython manage.py db migratepython manage.py db upgradepython manage.py --help```### Create New Module```bashpython manage.py module create -n "module_name"``````bashpython manage.py module create -n "module_name" --remote "github_repo_url"```### Runserver```bashpython manage.py run```## Docker Compose### Setup```bash$ docker-compose up -d$ curl```### Stop Services```bash$ docker-compose stop```### Run And Play```bash$ docker-compose start```### Create Module```bash$ docker-compose exec od python manage.py create "test"```### Manage Module```bash$ docker-compose stop od$ docker-compose run od bash[from_od]$ openedoo module create -n "test"[from_od]$ opendoo module remove test[from_od]$ opendoo module install https://github.com/openedoo/module_hello```
Package: openedx2zim
openedx2zimGet the best courses :books: powered by openedx offline :arrow_down:An offliner to create ZIM :package: files from openedx powered coursesOpenedx is one of the most popular open source MOOC platforms which revolves around the idea of xblocks. It makes e-learning more accessible by providing an easy way to create courses for teachers, universities and others. It is used by many e-learning services as such as edX as a tool to create, organize and manage MOOCs quite easily.This project is aimed at creating a tool to make openedx based MOOCs more accessible by creating ZIM files providing the same course materials and resources offline.Getting started :rocket:Install the dependenciesMake sure that you havepython3,unzip,ffmpeg,wget,jpegoptim,gifsicle,pngquant,advdef, andcurlinstalled on your system before running the scraper (otherwise you'll get a warning to install them).Enroll into the MOOCYou must be enrolled into the mooc you want to offline. Ensure that you do not open the openedx instance in the browser with the same account while the scraper runs. Also, this scraper must be used only with a MOOC with a free license.Setup the packageOne can eaisly install the PyPI version but let's setup the source version. Firstly, clone this repository and install the package as given below.pip3install-rrequirements.txtpython3setup.pyinstallThat's it. You can now runopenedx2zimfrom your terminalopenedx2zim--course-url[URL]--email[EMAIL]--name[NAME]For the full list of arguments, seethisfile or run the followingopenedx2zim--helpExample usageopenedx2zim--course-url="https://courses.edx.org/courses/course-v1:edX+edx201+1T2020/course/"--publisher="edx201"--email="example@example.com"--name="sample"--tmp-dir="output"--output="output"--debug--keep--format="mp4"This project can also be run with docker. Use the providedDockerfileto run it with docker. See stepshere.Features :robot:You can create ZIMs for MOOCs powered by the openedx platform (find a list of openedx powered instanceshere), choose between different video formats (webm/mp4), different compression rates, and even use an S3 based cache.Limitations :exclamation:The answers can be extracted only for "multiple choice question" type problems with single answer correct and multiple answer correct (only if the number of options in that case is at most 5). This is due to large number of requests required to extract answers for other types of answers. For more information, referhere.License :book:GPLv3or later, seeLICENSEfor more details.
Package: openedx-course-export
Course Export S3 PluginA django app plugin to add a new API to Open edX to export courses to S3 buckets.InstallationYou can install this plugin into any Open edX instance by using the following method:Install from PyPIpip install openedx-course-exportConfiguration1) edx-platform configurationFor testing, you might need to add the following configuration values to the config file in Open edX. For any release after Juniper, that config file is/edx/etc/studio.yml.AWS_ACCESS_KEY_ID: <your aws access id>
AWS_SECRET_ACCESS_KEY: <your api access key>
COURSE_IMPORT_EXPORT_BUCKET: <bucket name to export the courses to>How To UseThe API supports a POST API call that accepts the list of course Ids and returns the uploaded paths of the courses on S3To call the API, Send a POST request to<STUDIO_BASE>/api/courses/v0/export/with the a payload with a list of course IDs that might look like:{
   "courses": ["course-v1:edX+DemoX+Demo_Course"]
}The successful response would look like:With 200

{
    "successful_uploads": {
        "course-v1:edX+DemoX+Demo_Course": "https://bucket_name.s3.amazonaws.com/course-v1:edX+DemoX+Demo_Course.tar.gz",
        "course-v1:edX+Test+Test_Course": "https://bucket_name.s3.amazonaws.com/course-v1:edX+Test+Test_Course.tar.gz"
    },
    "failed_uploads": {}
}

With 400

{
    "successful_uploads": {
        "course-v1:edX+DemoX+Demo_Course": "https://bucket_name.s3.amazonaws.com/course-v1:edX+DemoX+Demo_Course.tar.gz",
    },
    "failed_uploads": {
        "course-v1:edX+Test+Test_Course": "Error message"
    }
}The response will contain either the s3 bucket url for successful uploads and/or an error message for failed uploads.Change LogUnreleased[0.1.0] - 2023-02-24AddedFirst release on PyPI.
Package: openedx-django-pyfs
A Django module which extends pyfilesystem2 with several methods to
make it convenient for web use. Specifically, it extends pyfilesystem2
with two methods:fs.get_url(filename, timeout=0)This will return a externally-usable URL to the resource. If
timeout>0, the URL may stop working after that period (in
seconds). Details are implementation-dependent. On Amazon S3, this is
a secure URL, which is only available for that period. For a static
filesystem, the URLs are unsecure and permanent.fs.expire(filename, seconds, days, expires=True)This allows us to create temporary objects. Our use-case was that we
wanted to generate visualizations to users which were .png images. The
lifetime of those images was a single web request, so we set them to
expire after a few minutes. Another use case was memoization.Note that expired files are not automatically removed. To remove them,
callexpire_objects(). In our system, we had a cron job do
this for a while. Celery, manual removals, etc. are all options.To configure a openedx-django-pyfs to use static files, set a parameter in
Django settings:DJFS = {'type' : 'osfs',
        'directory_root' : 'djpyfs/static/djpyfs',
        'url_root' : '/static/djpyfs'}Here,directory_rootis where the files go.url_rootis the URL
base of where your web server is configured to serve them from.To use files on S3, you needbotoinstalled. Then,DJFS = {'type' : 's3fs',
        'bucket' : 'my-bucket',
        'prefix' : '/pyfs/' }bucketis your S3 bucket.prefixis optional, and gives a base
within that bucket.To get your filesystem, call:def get_filesystem(namespace)Each module should pass a unique namespace. These will typically
correspond to subdirectories within the filesystem.The openedx-django-pyfs interface is designed as a generic (non-Django
specific) extension to pyfilesystem2. However, the specific
implementation is very Django-specific.Good next steps would be to:Allow Django storages to act as a back-end for pyfilesystemAllow openedx-django-pyfs to act as a back-end for Django storagesSupport more types of pyfilesystems (esp. in-memory would be nice)State: This code is tested and has worked well in a range of settings,
and is currently deployed on edx.org.