Saravanan666/pypi-org huggingface dataset:
Package: rak811v2
pyrak811v2RAK811v2 Python 3 library for use with the Raspberry Pi LoRa pHAT.The library exposes the AT commands as described in the RAK811 Lora AT Command User Guide V1.0 found in the DOCS folder of this repository. This applies to LoRa modules with firmware version V3.0.0.13.T3 or later.The AT command structure is signifficantly different from that in previous versions of the firmware.This library is based heavily on pyrak811https://github.com/AmedeeBulle/pyrak811but doesn't include the command line interface (CLI) functionality.Peripheral Requirements
A Raspberry Pi!
A RAK811 LoRa module (PiSupply IoT LoRa Node pHAT for Raspberry Pi )
On the Raspberry Pi the hardware serial port must be enabled and the serial console disabled (use raspi-config)
The user running the application must be in the dialout and gpio groups (this is the default for the pi user)The Python script loraTest.py is an eaxmple of a script that when configured with appropriate identifiers will execute a number of AT commands including joining to the network (OTA or ABP) and sending some data and waiting for confirmaton.You may use the Python logging module to control logging by the library.
Currently setting the log level to DEBUG will display the AT commands sent to the module and the raw respnse received from the module. See loraTest.py for an example of enabling logging DEBUG level output to the console. For further information regards configuring Python logging see the online documentation for the logging library.Install the rak811v2 package
The package is installed from PyPI:sudo pip3 install rak811v2
The pip3 command is part of the python3-pip package. If it is missing on your system, run:sudo apt-get install python3-pipPiSupply provides detailed instructions for configuring your Raspberry Pi.This represents my first foray into both git and Python so appologies in advance for anything missing etc that is normally provided.
Package: rake
A Python implementation of the Rapid Automatic Keyword Extraction (RAKE) algorithm as described in: Rose, S., Engel, D., Cramer, N., & Cowley, W. (2010). Automatic Keyword Extraction from Individual Documents. In M. W. Berry & J. Kogan (Eds.), Text Mining: Theory and Applications: John Wiley & Sons.The source code is released under the MIT License.
Package: rake-keyword
RAKE-KeywordRAKE-Keyword is a Python library that can extract keywords from any document or a piece of text. It is based on RAKE algorithm. Rapid Automatic Keyword Extraction (RAKE) is a keyword extraction method that is extremely efficient and operates on individual documents. It tries to determine the key phrases in a text by calculating the co-occurrences of every word in a key phrase and also its frequency in the entire text.Link to Research Paper!Installationpip install rakeQuick StartfromrakeimportRaketext="Black grapes are famous for their use in making alcohol."rake=Rake()raje.exec(text)# Returns keywords with scores in reverse sorted order: [('black grapes', 4.0), ('making alcohol', 4.0), ('famous', 1.0)]Development Setup1. git clone https://github.com/u-prashant/RAKE.git
2. cd RAKE
3. pip install -r requirements.txt
4. make test-allContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMIT LicensePermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.Copyright (c) 2020 Prashant Upadhyay
Package: rake-new2
rake_new2rake_new2 is a Python library that enables simple and fast keyword extraction from any text. As the name implies, this library works on the RAKE(Rapid Automatic Keyword Extraction) algorithm.It tries to determine the key phrases in a text by calculating the co-occurrences of every word in a key phrase and also its frequency in the entire text.New in this versionHandles repetitive keywords/key-phrasesHandles consecutive punctuations.Handles HTML tags in text : The user is allowed an option to choose if they want to keep HTML tags as keywords too.InstallationUse the package managerpipto install rake_new2.pipinstallrake_new2Quick Startfromrake_new2importRaketext="Red apples are good in taste."text2="<h1> Hello world !</h1>"rk,rk_new1,rk_new2=Rake(),Rake(keep_html_tags=True),Rake(keep_html_tags=False)# Case 1# Initializerk.get_keywords_from_raw_text(text)kw_s=rk.get_keywords_with_scores()# Returns keywords with degree scores : {(1.0, 'taste'), (1.0, 'good'), (4.0, 'red apples')}kw=rk.get_ranked_keywords()# Returns keywords only : ['red apples', 'taste', 'good']f=rk.get_word_freq()# Returns word frequencies as a Counter object : {'red': 1, 'apples': 1, 'good': 1, 'taste': 1}deg=rk.get_kw_degree()# Returns word degrees as defaultdict object : {'red': 2.0, 'apples': 2.0, 'good': 1.0, 'taste': 1.0}# Case 2 : Sample case for testing the 'keep_html_tags' parameter. Default = Falseprint("\nORIGINAL TEXT :{}".format(text))# Sub Case 1 : Keeping the HTMLtagsrk_new1.get_keywords_from_raw_text(text2)kw_s1=rk_new1.get_keywords_with_scores()kw1=rk_new1.get_ranked_keywords()print("Keeping the tags : ",kw1)# Sub Case 2 : Eliminating the HTML tagsrk_new2.get_keywords_from_raw_text(text2)kw_s2=rk_new2.get_keywords_with_scores()kw2=rk_new2.get_ranked_keywords()print("Eliminating the tags : ",kw2)'''OUTPUT >>ORIGINAL TEXT : <h1> Hello world !</h1>Keeping the tags :  {'h1', 'hello'}Eliminating the tags :  {'hello world'}'''DebuggingYou might come across a stopwords error.It implies that you do not have the stopwords corpus downloaded from NLTK.To download it, use the command below.python-c"import nltk; nltk.download('stopwords')"ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMIT
Package: rake-nltk
RAKE short for Rapid Automatic Keyword Extraction algorithm, is a domain
independent keyword extraction algorithm which tries to determine key
phrases in a body of text by analyzing the frequency of word appearance
and its co-occurance with other words in the text.FeaturesRidiculously simple interface.Configurable word and sentence tokenizers, language based stop words etcConfigurable ranking metric.SetupUsing pippipinstallrake-nltkDirectly from the repositorygitclonehttps://github.com/csurfer/rake-nltk.gitpythonrake-nltk/setup.pyinstallQuick Startfromrake_nltkimportRake# Uses stopwords for english from NLTK, and all puntuation characters by# defaultr=Rake()# Extraction given the text.r.extract_keywords_from_text(<texttoprocess>)# Extraction given the list of strings where each string is a sentence.r.extract_keywords_from_sentences(<listofsentences>)# To get keyword phrases ranked highest to lowest.r.get_ranked_phrases()# To get keyword phrases ranked highest to lowest with scores.r.get_ranked_phrases_with_scores()Debugging SetupIf you see a stopwords error, it means that you do not have the corpusstopwordsdownloaded from NLTK. You can download it using command below.python-c"import nltk; nltk.download('stopwords')"ReferencesThis is a python implementation of the algorithm as mentioned in paperAutomatic keyword extraction from individual documents by Stuart Rose,
Dave Engel, Nick Cramer and Wendy CowleyWhy I chose to implement it myself?It is extremely fun to implement algorithms by reading papers. It is
the digital equivalent of DIY kits.There are some rather popular implementations out there, in python(aneesha/RAKE) and
node(waseem18/node-rake) but neither seemed to use the power ofNLTK. By making NLTK
an integral part of the implementation I get the flexibility and power to extend it in other
creative ways, if I see fit later, without having to implement everything myself.I plan to use it in my other pet projects to come and wanted it to be
modular and tunable and this way I have complete control.ContributingBug Reports and Feature RequestsPlease useissue trackerfor reporting bugs or feature requests.DevelopmentCheckout the repository.Make your changes and add/update relavent tests.Install`poetry`using`pip install poetry`.Run`poetry install`to create project’s virtual environment.Run tests using`poetry run tox`(Any python versions which you don’t have checked out will fail this). Fix failing tests and repeat.Make documentation changes that are relavant.Install`pre-commit`using`pip install pre-commit`and run`pre-commit run –all-files`to do lint checks.Generate documentation using`poetry run sphinx-build -b html docs/ docs/_build/html`.Generate`requirements.txt`for automated testing using`poetry export –dev –without-hashes -f requirements.txt > requirements.txt`.Commit the changes and raise a pull request.Buy the developer a cup of coffee!If you found the utility helpful you can buy me a cup of coffee using
Package: raknet
raknet-pythonPython bindings for theRakNetnetworking library🛠 Installation📦 From PyPipipinstallraknetor🎯 Build locallygitclonehttps://github.com/wu-vincent/raknet-python.gitcdraknet-python
pipinstallconan
conanexportraknet--version4.081
conaninstall.--build=missing-ctools.cmake.cmaketoolchain:generator=Ninja
pipinstall.🚀 UsageWe are working on making this project ready and will drop the usage documentation soon. Stay tuned! ⏳
Package: raknet-python
raknet-pythonPython bindings to rust-raknet native library.Installpip install raknet-pythonPrebuilds are provided for 64-bit Windows 10, Linux. If a prebuild does not work, please create an issue.BuildThe RaknetClient and RaknetServer classes are JS wrappers for the internal RaknetSocket and RaknetListener classes implemented in Rust in src/. All methods use asynchronous wrappers.fromraknet_pythonimportRaknetServer,RaknetClientserver=RaknetServer("127.0.0.1:19132")client1=RaknetClient("127.0.0.1:19132")client2=server.accept()client1.send([0xfe,0x01,0x01,0x01])buf=client2.recv()assertbuf==[0xfe,0x01,0x01,0x01]
Package: rakomon
rakomon is designed for simplest, most stupid monitoring tasks when logging, caching, etc. isn't required.It simply encapsulates some of tornado and apscheduler functionality to run simple tasks periodically, store results in memory and serve them in application/json.You can use both monitor and endpoint modules to serve your metrics automagically, or instantiate the `monitor.Monitor` class on your own to use it however you see fit.### Disclaimer: though I use this code in my projects, it's rather raw. I set up this repository mainly to learn how to maintain an open-source project. It's up to you to evaluate if rakomon is production ready.# Dependenciesrakomon is Python 3 only. It also requires tornado and apscheduler.# InstallationUse pip:```sh$ pip install rakomon```Or clone repository to your machine and use easy_install:```sh$ easy_install setup.py```# Basic usagerakomon is ready out of the box. All you need is get default `Monitor` instance, then define your metrics as functions and decorate them with the `Monitor.metric` decorator.A metric function should return either a number or a string. Iterables support is planned for future.After you define your metrics, call `endpoint.run()` to launch a simple tornado server to serve them. It will bind to port 80 on localhost by default.```pythonimport psutilfrom rakomon import monitor, endpointm = monitor.default()@m.metricdef cpu():return psutil.cpu_percent(interval=1)@m.metricdef ram():return psutil.virtual_memory().percentendpoint.run()``````sh$ curl http://127.0.0.1/rakomon{"cpu": 2.3, "ram": 33.1}```# ConfigurationBoth `monitor.Monitor` and `endpoint.run` are configurable. You can pass configuration as keyword arguments. If kwargs are not provided, rakomon uses default values.## monitor.Monitor* `scheduler` - a class that inherits from `apscheduler.schedulers.base.BaseScheduler`. Useful when you want to utilize Monitor on its own, without the included endpoint. See [apscheduler docs](http://apscheduler.readthedocs.io) for more info on schedulers. Defaults to `TornadoScheduler`.* `metric_interval` - number of idle seconds between metric runs. Defaults to `5`.* `round_ndigits` - number of digits when rounding metric values. Naturally, applies to number values only. Defaults to `2`.## endpoint.run* `monitor` - an instance of `monitor.Monitor`. Defaults to `monitor.default()`.* `address` - address to bind the tornado endpoint to. Defaults to `'127.0.0.1'`.* `port` - port to bind the tornado endpoint to. Defaults to `80`.* `url_path` - defaults to `r'/rakomon'`.
Package: raku-scraper
RakuScraperRakuScraperis a powerful yet easy-to-use Python library for automated web scraping. The name "Raku" is inspired by the Japanese word that means "easy." True to its name,RakuScraperis devoted to simplifying the automation and scraping of websites. With a clean and intuitive API, you can collect the data you need without the hassle.InstallationYou can easily installRakuScrapervia pip:pipinstallraku-scraperFeaturesEase of Use: A user-friendly API that makes web scraping a breeze.Flexibility: Easily customizable for a wide range of web scraping tasks.Robust: Built to handle errors gracefully and continue the scraping process.Quick StartHereâ€™s a quick example that demonstrates the simplicity and power ofRakuScraper. In this example, we will automate the process of accepting cookies on a webpage, then scrape the title of the webpage before and after changing the language of the webpage.# Import the necessary classes from RakuScraperfromraku_scraperimportScrapingTask,RakuScraper# Create a scraping task for a specific URLtask=ScrapingTask(url="https://www.example.com",title="Example Page",description="A test page")# Add steps to the scraping tasktask.add_action(step_id="accept_cookies",selector="#cookie_accept",action="click",description="Accept cookies")task.add_selector(step_id="page_title",selector="h1.title",attribute="text",description="Get the title of the page")task.add_action(step_id="change_language",selector="#language_toggle",action="click",description="Change language")task.add_selector(step_id="page_title_after_language_change",selector="h1.title",attribute="text",description="Get the title of the page after language change")# Create a RakuScraper instance and execute the scraping taskscraper=RakuScraper(task,headless=False)# Set headless to True for headless moderesults=scraper.scrape()# Print the scraped dataprint("Results:",results)ContributingWe welcome contributions from the community. If you'd like to contribute, feel free to open an issue or create a pull request. For major changes, please open an issue first to discuss what you would like to change.
Package: rakuten
## python_rakuten_apiPython API for Rakuten API.## UsageCreate a client.```from rakuten import RakutenClientclient = RakutenClient("API_KEY")```### Travel APIAvailable methods:* `simple_hotel_search````response = client.travel.simple_hotel_search(middle_class_code="akita",large_class_code="japan",small_class_code="tazawa")```* `vacant_hotel_search````response = client.travel.vacant_hotel_search(checkin_date="2014-10-01",checkout_date="2014-10-01",middle_class_code="akita",large_class_code="japan",small_class_code="tazawa")```* `get_area_class````response = client.travel.vacant_hotel_search()```* `keyword_hotel_search````response = client.travel.keyword_hotel_search('keyword')```* `get_hotel_chain_list````response = client.travel.get_hotel_chain_list()```
Package: rakutenma
Rakuten MA PythonRakuten MA Python (morphological analyzer) is a Python version of Rakuten MA (word segmentor + PoS Tagger) for Chinese and Japanese.For details about Rakuten MA, Seehttps://github.com/rakuten-nlp/rakutenmaSee alsohttp://qiita.com/yukinoi/items/925bc238185aa2fad8a7(In Japanese)Contributions are welcome!Installationpip install rakutenmaExamplefromrakutenmaimportRakutenMA# Initialize a RakutenMA instance with an empty model# the default ja feature set is set alreadyrma=RakutenMA()# Let's analyze a sample sentence (from http://tatoeba.org/jpn/sentences/show/103809)# With a disastrous result, since the model is empty!print(rma.tokenize("彼は新しい仕事できっと成功するだろう。"))# Feed the model with ten sample sentences from tatoeba.com# "tatoeba.json" is available at https://github.com/rakuten-nlp/rakutenmaimportjsontatoeba=json.load(open("tatoeba.json"))foriintatoeba:rma.train_one(i)# Now what does the result look like?print(rma.tokenize("彼は新しい仕事できっと成功するだろう。"))# Initialize a RakutenMA instance with a pre-trained modelrma=RakutenMA(phi=1024,c=0.007812)# Specify hyperparameter for SCW (for demonstration purpose)rma.load("model_ja.json")# Set the feature hash function (15bit)rma.hash_func=rma.create_hash_func(15)# Tokenize one sample sentenceprint(rma.tokenize("うらにわにはにわにわとりがいる"));# Re-train the model feeding the right answer (pairs of [token, PoS tag])res=rma.train_one([["うらにわ","N-nc"],["に","P-k"],["は","P-rj"],["にわ","N-n"],["にわとり","N-nc"],["が","P-k"],["いる","V-c"]])# The result of train_one contains:#   sys: the system output (using the current model)#   ans: answer fed by the user#   update: whether the model was updatedprint(res)# Now what does the result look like?print(rma.tokenize("うらにわにはにわにわとりがいる"))NOTEAdded APIAs compared to original RakutenMA, following methods are added:RakutenMA::load(model_path)
- Load model from JSON fileRakutenMA::save(model_path)
- Save model to pathmiscAs initial setting, following values are set:rma.featset = CTYPE_JA_PATTERNS  # RakutenMA.default_featset_jarma.hash_func = rma.create_hash_func(15)rma.tag_scheme = “SBIEO”  # if using Chinese, set “IOB2”LICENSEApache License version 2.0CopyrightRakuten MA Python
(c) 2015- Yukino Ikegami. All Rights Reserved.Rakuten MA (original)
(c) 2014 Rakuten NLP Project. All Rights Reserved.CHANGES0.3.3 (2017-05-22)Bug fix about training0.3.2 (2017-02-01)Use ujson when possibleEnable POS to MeCab styleSupport Python 3.5 and 3.60.3 (2016-04-10)Add CUI ($ rakutenma)0.2.2 (2016-04-09)Bundle model files (model_ja.json, model_ja_min.json)Support Windows0.2 (2015-01-10)Support Python 2.6 and 2.70.1.1 (2015-01-08)Slightly improve performance0.1 (2015-01-01)First release.
Package: rakuten-ws
Unofficial Python Client for Rakuten Web ServiceFree software: MIT licenseDocumentation:https://rakuten-ws.readthedocs.io.Supported APIsRakuten Ichiba APIRakuten Ichiba RMS Item APIRakuten Ichiba RMS Product APIRakuten Ichiba RMS Order APIRakuten Ichiba RMS RakutenPayOrder APIRakuten Ichiba RMS Inventory APIRakuten Ichiba RMS Cabinet APIRakuten Ichiba RMS Navigation APIRakuten Ichiba RMS Category APIRakuten Books APIRakuten Travel APIRakuten Auction APIRakuten Kobo APIRakuten GORA APIRakuten Recipe APIRakuten Other APIsInstallationRequirements:python >= 2.7python-lxmlYou can install, upgrade, uninstall rakuten-ws with these commands:$ pip install [--user] rakuten-ws
$ pip install [--user] --upgrade rakuten-ws
$ pip uninstall rakuten-wsDevelopmentkonchprovides a useful development environment. To execute it, run the command:konchThe old solution was to useptpythonin interactive mode. To execute it, run the command:webservicePython Rakuten Web Service changelogVersion 0.5.2Release on January 20th 2023Add python 3.11 compatibilityRemove python 2 compat codeBlack codeVersion 0.5.1Release on August 22th 2020Fixed the recording of the response by scrubbing more informationVersion 0.5.0Release on August 22th 2020Added the new API RakutenPayOrderVersion 0.4.4Release on November 6th 2019Fixed the parameters forRmsService.items.updateUpdated the API version of some endpointsVersion 0.4.3Released on April 19th 2017SetRmsOrderAPI.getOrder.isOrderNumberOnlyFlgto False by default.Version 0.4.3.dev0unreleasedVersion 0.4.2Released on March 31st 2017FixedRmsOrderAPI.getOrderandRmsOrderAPI.updateOrderVersion 0.4.1Released on March 29th 2017Retrieve inventory information about multiple items at once (RmsInventoryAPI)Version 0.4.0Released on March 27th 2017Added support for RmsInventoryAPIVersion 0.3.0Released on March 21st 2017Added support for RMS Category APIVersion 0.2.1Released on February 28th 2017Dropped upload_images function to keep the project as close as possible to Rakuten APIsSorted xml keys recursivelyVersion 0.2.0Released on February 22nd 2017Added support for RMS Cabinet APIAdded support for RMS Navigation APIAdded support for Python 3.6Version 0.1.1Released on January 13th 2017Included WSDL files in the Pypi packageVersion 0.1.0Released on January 03rd 2017First release on PyPI.
Package: ralc
Rate Calculator for multiplicate spent hours with rate per hour to find out how
many money you earned.RequirementsPython2.6+InstallationAs easy as:# pip install ralcLicenseralcis licensed under the terms ofBSD LicenseUsageusage: ralc [-h] HH[:MM[:SS]] RATE

Rate Calculator

positional arguments:
  HH[:MM[:SS]]  Spent hours, e.g.: "30", "120:40", "10:55:30"
  RATE          Rate per hour. Should be decimal value.

optional arguments:
  -h, --help    show this help message and exitChangelog0.1 (2014-01-16)Initial release
Package: ralf
ralfRotation Angle Limit FinderOnline DocumentationClick here to read the documentationUsageralfincludes a single functionget_rotation_limit, which can be imported and used as shown below:from ralf import get_rotation_limit

limit = get_rotation_limit(
  r"test/data/segphos.pdb",
  23,
  6,
  cutoff_distance=1.8,
)Arguments are as follows:pdb_path (str): PDB file for molecule.axis_atom_1 (int): ID of first atom bound in chiral axis.axis_atom_2 (int): ID of second atom bound in chiral axis.cutoff_distance (float, optional): Distance considered overlapping, in Angstrom. Defaults to 1.6.get_rotation_limitreturns the maximum rotation angle in degrees.