Saravanan666/pypi-org huggingface dataset:
Package: yakinori
yakinoriJapanese REAMED is here.https://github.com/morikatron/yakinori/blob/main/README_ja.mdJapanese Converter Kanji to Hiragana, Katakana, Latin alphabet.You can get the reading and pronunciation of Japanese sentences based on mecab-unidic-NEologd.Test EnvironmentsUbuntu18.04
python==3.8.16InstallThere are two options to install.Install Mecab and mecab-unidic-NEologd in your own environmentUse DockerYour Own EnvironmentFor UbuntuInstall Mecab$sudoaptupdate
$sudoaptinstallmecablibmecab-devmecab-ipadic-utf8Install mecab-unidic-NEologd$gitclone--depth1https://github.com/neologd/mecab-unidic-neologd.git
$cdmecab-unidic-neologd
$sudo./bin/install-mecab-unidic-neologd-n-y# show installed mecab-unidic-NEologd dictionary path$echo`mecab-config--dicdir`"/mecab-unidic-neologd">/usr/local/lib/mecab/dic/mecab-unidic-neologd# If you want to make mecab-unidic-NEologd as defalut dictionary, run commands below.$echo"dicdir = `mecab-config --dicdir`/mecab-unidic-neologd"|sudotee/etc/mecabrc
$sudocp/etc/mecabrc/usr/local/etcInstall yakinori$pipinstallyakinoriYou can update the recent mecab-unidic-NEologd$sudo./bin/install-mecab-unidic-neologd-n-y
$echo"dicdir = `mecab-config --dicdir`/mecab-unidic-neologd"|sudotee/etc/mecabrc
$sudocp/etc/mecabrc/usr/local/etcUse Docker$dockerpullmorikayamada/yakinoriHow to useImport>>>fromyakinoriimportYakinoricreate InstanceInstalled on your Own EnvironmentIf you made mecab-unidic-NEologd as defalut dictionary, you don't need to add dic_path.>>>yakinori=Yakinori()If you did not make mecab-unidic-NEologd as defalut dictionary, add dic_path.>>>yakinori=Yakinori(dic_path='path/to/mecab-unidic-NEologd')Using DockerIf you use Docker, you don't need to add dic_path.>>>yakinori=Yakinori()Parse Sentence>>>sentence="幽☆遊☆白書は最高の漫画です">>>parsed_list=yakinori.get_parsed_list(sentence)Get Reading# convert to hiragana>>>hiragana_sentence=yakinori.get_hiragana_sentence(parsed_list)>>>print(hiragana_sentence)ゆうゆうはくしょはさいこうのまんがです# convert to katakana>>>katakana_sentence=yakinori.get_katakana_sentence(parsed_list)>>>print(katakana_sentence)ユウユウハクショハサイコウノマンガデス# convert to Latin alphabet>>>roma_sentence=yakinori.get_roma_sentence(parsed_list)>>>print(roma_sentence)yuuyuuhakushohasaikounomangadesuGet Pronunciation# convert to hiragana>>>hiragana_sentence=yakinori.get_hiragana_sentence(parsed_list,is_hatsuon=True)>>>print(hiragana_sentence)ゆーゆーはくしょわさいこーのまんがです# convert to katakana>>>katakana_sentence=yakinori.get_katakana_sentence(parsed_list,is_hatsuon=True)>>>print(katakana_sentence)ユーユーハクショワサイコーノマンガデス# convert to Latin alphabet>>>roma_sentence=yakinori.get_roma_sentence(parsed_list,is_hatsuon=True)>>>print(roma_sentence)yuｰyuｰhakushowasaikoｰnomangadesu
Package: yakka
YakkaYakka is a python library and platform for building data pipelines that clean datasets and train ML models with human supervision and feedback.It automatically provisions all required infrastructure and guarantees a least-privilege and privacy compliant data architecture.FeaturesTrain transformation functions (using AI) that are supervised by humans and continually improved with feedback and corrections.Orchestrate transformation with dependency graphs (DAGs)Compute data sets when new data arrives or when its dependencies changeRe-compute data sets when a transformation function is changed or improves from learningAuto-provision all required cloud infrastructureAuto-configured to be compliant with privacy regulations such as HIPAA and GDPRLeast-privilege IAM policies with auto-generated reports for regulatorsExample🔧 Note: Yakka is in active development. Not all features are implemented. Check back to see the following example grow.Below is the most simple Yakka application: a Bucket with a Function that writes to it.Your application's infrastructure is declared in code. The Yakka compiler analyzes it to auto-provision cloud resources (in this case AWS S3 Bucket and Lambda Function) with least privilege IAM Policy inference.fromyakkaimportBucket,functionvideos=Bucket("videos")@function()asyncdefupload_video():awaitvideos.put("key","value")@asset()asyncdeftranscribed_videos():...ResearchInspired by (and integrating with):https://dagster.io/https://www.llamaindex.ai/https://unstructured.io/https://docs.modular.com/mojo/roadmap.htmlNaming OptionsSmelt is available on PipYakka is not available on NPM or PipI maybe have access to alchemy on NPM but it's taken on PIP
Package: yakonfig
yakonfig========yet another config management library, or a yak on a figYakonfig parses a YAML configuration file at application startup, and makes parts of that configuration available to modules within the application.  It is intended for multi-module applications where each module needs a separate configuration.  The Yakonfig library merges application-provided default configuration, a user-provided configuration file, and command-line options to produce a unified global configuration.yakonfig API------------Applications using Yakonfig generally create an ``argparse.ArgumentParser`` object and call ``yakonfig.parse_args()``, giving it a list of configurable modules or other items.  A typical application setup looks like:```pythonimport argparseimport dbloggerimport kvlayerimport yakonfigdef main():parser = argparse.ArgumentParser()yakonfig.parse_args(parser, [yakonfig, dblogger, kvlayer])...if __name__ == '__main__':main()```The application will include ``--help``, ``--config FILE``, and ``--dump-config MODE`` flags by default; modules can provide additional command-line arguments.The module list passed to ``parse_args()`` is a list of objects that look similar to ``yakonfig.Configurable`` objects.  They can be actual objects, typically factories, or they can be classes or even Python modules that happen to include the same names.  A top-level Python module might look like:```pythonimport a_package.submodule#: Name of this module in the config fileconfig_name = 'a_package'#: Inner blocks within this configurationsub_modules = [a_package.submodule]#: Default configurationdefault_config = {'random_number': 17}```The objects contained in the ``sub_modules`` list have the same format.  Running ``./my_program.py --dump-config=default`` would print out a YAML file:```yamla_package:random_number: 17submodule: ...```A typical pattern is to create a factory object that has many configurable objects within it, such as stages in a data-processing pipeline.  The ``yakonfig.factory.AutoFactory`` class supports this pattern.  Objects built by the factory do not declare any of the configuration metadata; instead, Yakonfig determines the configuration name and default configuration by inspecting the object's constructor, or the function's argument list.  The factory class itself needs to include the standard configuration metadata.```pythonclass a_stage(object):def __init__(self, random_number=17):self.random_number = random_numberdef __call__(self):print self.random_numberclass StageFactory(yakonfig.factory.AutoFactory):config_name='stage_factory'auto_config=[a_stage]def __call__(self):stage = self.create(a_stage)stage()```The corresponding default YAML configuration:```yamlstage_factory:a_stage:random_number: 17```See [tests](src/tests/yakonfig/test_yakonfig.py) for further illustrations.
Package: yaks
The YAKS project has been merged into thezenohproject.Retrieve all the YAKS features an more in the [Eclipse zenoh](http://zenoh.io) project!zenoh service:https://github.com/eclipse-zenoh/zenohPython API:https://github.com/eclipse-zenoh/zenoh-pythonJava API:https://github.com/eclipse-zenoh/zenoh-javaGo API:https://github.com/eclipse-zenoh/zenoh-goC API:https://github.com/eclipse-zenoh/zenoh-c
Package: yak-server
Yak-totoRequisitesUbuntu 22.04MySQL 8.0.30How to build the projectDatabaseInstall and start mysql server on port 3306. Add a database namedyak_toto. In root folder, create a dotenv file named.envand fill your MySQL user name, password and database. When backend start, this configuration is automaticaly loaded.MYSQL_USER_NAME=my_user_name
MYSQL_PASSWORD=my_password
MYSQL_DB=my_database_nameYou can also set MySQL port by addingMYSQL_PORT=my_portto.envfile. If not set, it will be 3306 by default.BackendRun your project in a Python env is highly recommend. You can use venv python module using the following command:python-mvenvvenv
.venv/bin/activateFetch all packages using pip with the following command:pipinstall-rrequirements.txtBefore starting the backend, addJWT_SECRET_KEYandJWT_EXPIRATION_TIMEin.envsame as the MySQL user name and password. As
login system is using JSON Web Token, a secret key is required and an expiration time (in seconds). To generate one, you can use the python built-insecretsmodule.>>>importsecrets>>>secrets.token_hex(16)'9292f79e10ed7ed03ffad66d196217c4'JWT_SECRET_KEY=9292f79e10ed7ed03ffad66d196217c4
JWT_EXPIRATION_TIME=1800Also, automatic backup can be done throughyak_server/cli/backup_databasescript. It can be run usingyak db backup.Finally, fastapi needs some configuration to start. Last thing, for development environment, debug needs to be activated with a addditional environment variable:DEBUG=1And then start backend with:uvicorn--reloadyak_server:create_app--factoryData initializationTo run local testing, you can use the scriptcreate_database.py,initialize_database.pyandcreate_admin.pylocated inyak_server/clifolder. To select, setCOMPETITIONenvironment variable in.env. It will read data fromyak_server/data/{COMPETITION}/.TestingTo set up test, please add a MySQL database namedyak_toto_test. It will contain all the records created during unit tests. This database is cleaned everytime you run test. That's why a different database is created to avoid deleting records you use for your local testing.Yak-server is usingpytestto run tests.ProfilingYou can profile by adding this line in the.envPROFILING=1Be careful, you need to be in debug mode to activate the profiling. In production mode, adding the environment variable will have no impacts.
Package: yak-signals
A tool for auto generating libraries for different platforms to
communicate with your API.Recommended SetupCreate a new python virtual environmentpip installyak-signalsInstructionsThe script is ran fromsignals.To see a list of arguments runsignals--help.If you do not supply the required arguments when running, the script
will prompt you for them one by one.An example for running the script is:signals --schema ~/projects/your-project/api-schema.json
--datamodels ~/projects/your-project/data-model-folder/
--coredata ~/projects/your-project/core-data.xcdatamodeld
--projectname your-project --generator objciOSIf you’re running the iOS generator and writing to core data make
sure you quit xcodeRunsignals, and pass the--coredataflag
if you want to override core data.If you changed the core data models, you’ll need to have xcode auto
generate the new model filesRudy MutterLee McDoleZach GawlikBaylee Feore
Package: yakutils
yakutilsYakutils is yet another toolbox of Python helper functions.This package is available on PyPi, but its primary purpose is to allow one (me) to copy these into projects or to prevent one (me as well) from needing to Google how to write them (I'm looking at youcsv.DictReaderandcsv.DictWriter).This project is a continuous work-in-progress, and while its contents are specific to stuff that I use, pull requests are certainly welcome.InstallationTo download using pip via PyPi:$pipinstallyakutilsUsage Examples:>>>fromyakutilsimportread_csv>>>read_csv('/path/to/data.csv')[{'name':'Tomatillo','age':27},# ...]>>>importdatetimeasdt>>>fromyakutilsimportdate_to_iso8601>>>date_to_iso8601(dt.date.today())'2020-01-26T00:00:00Z'>>>fromyakutilsimportdatetime_to_iso8601>>>datetime_to_iso8601(dt.datetime.utcnow())'2020-01-26T19:04:40.219668Z'>>>fromyakutilsimportdatetime_to_unixtimestamp>>>datetime_to_unixtimestamp(dt.datetime.utcnow())1580065524>>>fromyakutilsimportiso8601_to_datetime>>>iso8601_to_datetime('2020-01-26T19:04:40.219668Z')datetime.datetime(2020,1,26,19,4,40,219668)>>>importjson>>>fromdecimalimportDecimal>>>fromyakutilsimportjson_defaults>>>json.dumps({...'now':dt.datetime.utcnow(),...'today':dt.date.today(),...'time':dt.time(1,2,3),...'num':Decimal(2.777),...},default=json_defaults)'{"now": "2020-01-28T01:10:37.599281Z", "today": "2020-01-27", "time": "01:02:03", "num": 2.777}'>>>fromyakutilsimportrandom_string>>>random_string(20)'k4a9ue7TDjOC3p3oN0dl'>>>fromyakutilsimportupdate_qs>>>update_qs('https://nickficano.com.com/?q=asdf&pi=3.14',pi=6.28)'https://nickficano.com.com/?q=asdf&pi=6.28'For complete list of utility functions, see:https://yakutils.readthedocs.io/en/latest/.
Package: yala
YALA combines many linters to improve the quality of your code. Other projects may come to your mind, but does anyone have all the features below?Works with latest lintersYala uses linters’ outputs and doesn’t break when their APIs change.Same defaultsNo changes to linters’ default configuration.Easy to configureSet any command-line option for any linter (even pylint!) in setup.cfg.FastRun linters in parallel.Current StatusCurrently supported Python tools:Flake8IsortMyPyPycodestylePydocstylePyflakesPylintRadonBlackInstallTested with Python >= 3.6. You can specify multiple linters separated by commas:yalainstalls isort, pycodestyle, and pylint (minimal install);yala[all]addsmypy,pydocstyle,pyflakes, andradon;yala[all,flake8]also addsflake8;# Minimal: isort, pycodestyle and pylintsudopip3install--upgradeyala# OR (almost) all supported linterssudopip3install--upgradeyala[all]# OR choose your linters (+isort, pycodestyle and pylint)sudopip3install--upgradeyala[mypy,radon]If you are willing to hack yala’s code, run the command below in this README’s folder:# Use pipsudopip3install--editable.[all,dev]# OR pipenvpipenvsync--devUsageJust callyalafollowed by the files and/or folders to lint.ConfigurationBesides the standard configuration files of each linter, as in their docs, you can specify any command-line option insetup.cfgwith yala.Writing command-line arguments for linters insetup.cfgis particularly useful forpylintbecause it ignoressetup.cfgand requires you to write an extra file. Now, you don’t have to.The default configuration file is inyala/setup.cfg. You can copy it to your project’s root folder and customize it. If you need other configuration for a nested directory, just create another file there.Linters’ optionsFor example, to disable a specific pylint warning and output grades C and lower for Radon Maintainability Index (default is D or worse), add the following tosetup.cfg:[yala]pylint args=--disable=TODOradon mi args=--min CBesidespylint, you can define CLI options forisort,pycodestyle,pydocstyle, etc (the names are exactly as they are called in command line).Choosing lintersAll supported and installed linters are enabled by default.You can customize the linters insetup.cfgby either:[yala]linters=isort, pycodestyleor[yala]linters=isortpycodestyleOr even a mix of both: multiple linters in multiple lines.ExampleRun pydocstyle and pylint without missing-docstring errors (besides isort,
pycodestyle, and pylint that are installed by default):pipinstall--upgradeyala[pydocstyle][pydocstyle]add-ignore=D1[yala]pylint args=--disable=C0114,C0115,C0116If you’re usingblackwithisort,pycodestyleandflake8, make sure to set options that won’t conflict, for instance:[isort]profile=black[pycodestyle]max-line-length=88[flake8]max-line-length=88Hacking: Adding a linterCheck the fileyala/linters.pyand feel free to ask for help.
Package: yalafi
This Python package extracts plain text from LaTeX documents.
The software may be integrated with a proofreading tool and an editor.
It providesmapping of character positions between LaTeX and plain text,simple inclusion of own LaTeX macros and environments with tailored
treatment,careful conservation of text flows,some parsing of displayed equations for detection of included “normal” text
and of interpunction problems,support of multi-language documents (experimental).A complete description is available at theGitHub page.The sample Python application script yalafi/shell/shell.py
integrates the LaTeX filter with the proofreading softwareLanguageTool.
It sends the extracted plain text to the proofreader,
maps position information in returned messages back to the LaTeX text,
and generates results in different formats.
You may easilycreate a proofreading report in text or HTML format for a complete
document tree,check LaTeX texts in the editors Emacs and Vim via several plug-ins,run the script as emulation of a LanguageTool server with integrated
LaTeX filtering.For instance, the LaTeX inputOnly few people\footnote{We use
\textcolor{red}{redx colour.}}
is lazy.will lead to the text report1.) Line 2, column 17, Rule ID: MORFOLOGIK_RULE_EN_GB
Message: Possible spelling mistake found
Suggestion: red; Rex; reds; redo; Red; Rede; redox; red x
Only few people is lazy.    We use redx colour. 
                                   ^^^^
2.) Line 3, column 1, Rule ID: PEOPLE_VBZ[1]
Message: If 'people' is plural here, don't use the third-person singular verb.
Suggestion: am; are; aren
Only few people is lazy.    We use redx colour. 
                ^^This is the corresponding HTML report:
Package: yalafi-ls
YaLafi LSP ServerAnLSPserver for proofreading LaTeX documents usingYaLafi (yet another LateX filter)andLanguageToolin different editors.
It serves as a basis for the correspondingvscode extension.The server is written in Python usingpyglsandlsprotocol.
The current implementation is very basic and just calls YaLafi on save.InstallationYaLafi-LS is available onPyPIand can be installed withpython -m pip install YaLafi-LS.
This will automatically also installYaLafi.
However, you may need to installLanguageTool, see theinstallation guide for YaLafi.
Package: yalambda
yalambdaYalambda lets you write Yanex.Cloud Functions with less boilerplateFeatures:everything is type-annotated, so you'll get autocompletion in IDEsbase64 de/encoding and other details are handled for youautomatically parse JSON usingdataclass-factoryEcho server examplefromyalambdaimportfunction,YaRequest,YaResponse@function()asyncdefhandler(req:YaRequest)->YaResponse:returnYaResponse(200,req.body)Automatically parse dataclassesfromdataclassesimportdataclassfromyalambdaimportfunction,YaResponse@dataclassclassPoint:x:floaty:float@function()asyncdefhandler(point:Point)->YaResponse:dist=(point.x**2+point.y**2)**0.5returnYaResponse(200,{"distance_to_origin":dist})Access both the dataclass and the requestfromdataclassesimportdataclassfromyalambdaimportfunction,YaRequest,YaResponse@dataclassclassPoint:x:floaty:float@function()asyncdefhandler(point:Point,req:YaRequest)->YaResponse:ifreq.http_method!="POST":returnYaResponse(405,"Only POST requests are allowed")dist=(point.x**2+point.y**2)**0.5returnYaResponse(200,{"distance_to_origin":dist})Initialize something asynchronously on first callfromyalambdaimportfunction,YaRequest,YaResponseasyncdefinit():globalansweranswer=42@function(init)asyncdefhandler(req:YaRequest)->YaResponse:returnYaResponse(200,"Answer:{}".format(answer))Routingfromdataclassesimportdataclassfromyalambdaimportdispatch,YaRequest,YaResponse@dataclassclassPoint:x:floaty:floatasyncdefget_all_points(req:YaRequest)->YaResponse:points=[{"x":3.0,"y":4.0},{"x":-1.0,"y":3.27}]returnYaResponse(200,points)asyncdefcompute_distance(point:Point)->YaResponse:dist=(point.x**2+point.y**2)**0.5returnYaResponse(200,{"distance_to_origin":dist})handler=dispatch({"GET":get_all_points,"POST":compute_distance,})Full exampleThis function acts as a GitHub webhook and sends a pretty embed on Discord webhook when an issue is opened or closed. See the source codeon GitHub.Development serverYou can installaiohttpand run your function locally.
It's not the same as the real thing, but it should be enough for simple functions.$python-myalambdayour_module========Runningonhttp://0.0.0.0:55710========(PressCTRL+Ctoquit)Condition DSLWe can modify our GitHub->Discord example so that it doesn't error out on the initial ping event:fromyalambdaimportwhen...asyncdefhandle_issue_events(event:IssueEvent)->YaResponse:embed=create_embed(event)ifembedisnotNone:awaitclient.post(DISCORD_WEBHOOK,json={"embeds":[embed]})returnYaResponse(200,"")asyncdefhandle_ping(req:YaRequest)->YaResponse:returnYaResponse(200,"")handler=when.dispatch(when.header_is("x-github-event","ping",handle_ping),when.header_is("x-github-event","issues",handle_issue_events),init=init)
Package: yalchemy
DocumentationView the yalchemy docs here.Installationyalchemy can be installed with:pip3 install yalchemyPrimary AuthorsWes Kendall <wesleykendall@gmail.com>Chris Hartfield <chris.hartfield@cloverhealth.com>Other contributors can be found in the AUTHORS fileContributing GuideFor information on setting up yalchemy for development and contributing changes, viewCONTRIBUTING.rst.
Package: yald
Deployer of AWS LambdasSimple script for deploying code for a Lambda.Free software: Apache Software License 2.0Documentation:https://lambda-deployer.readthedocs.io.FeaturesDeploy code through direct uploadDeploy code via S3Assume a role before doing the aboveCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2020-11-25)First release on PyPI.
Package: yaleclient
Yale ClientYale client is a python client for interacting with the Yale APIs.This project is largely taken fromhttps://github.com/domwillcode/yale-smart-alarm-clientThere exists a cli and programming interface to interact with the yale apis.Supported functions:alarm api:Arm full (away)Arm partial (away/night)DisarmGet alarm statuslock apiget statuslockunlockPython versionTested with the following python versionsPython 3.7Python 3.6CLIThe cli can be used as a standalone python program.  Just instsall the client as you usually would
by doing a pip install:pipinstallyaleclientThe cli optionally reads these variables from envrionment, so you do not have to
specify them as arguments.YALE_USERNAMEYALE_PASSWORDLOCK_PIN_CODEUsage>exportYALE_USERNAME=foo
>exportYALE_PASSWORD=bar
>exportLOCK_PIN_CODE=123456>yaleclient--api=LOCK--operation=STATUS--lock_id=mydoor
mydoor[YaleLockState.LOCKED]>yaleclient--api=LOCK--operation=STATUS
mydoor[YaleLockState.LOCKED]mydoor2[YaleLockState.LOCKED]>yaleclient--api=LOCK--operation=OPEN
mydoor[YaleLockState.OPEN]mydoor2[YaleLockState.OPEN]>yaleclient--api=LOCK--operation=CLOSE
mydoor[YaleLockState.LOCKED]mydoor2[YaleLockState.LOCKED]>yaleclient--api=LOCK--help
>yaleclient--api=ALARM--helpProgramming apiUsageCreate a client with:from yaleclient import YaleClient
client = YaleClient(username="", password="")where username and password are your Yale credentials.LocksIterate the connected locksfor lock in client.lock_api.locks():
    print(lock)lock a single locklock = client.lock_api.get(name="myfrontdoor"):
lock.close()unlock:lock = client.lock_api.get(name="myfrontdoor"):
lock.open(pin_code="1234566")AlarmChange the alarm state with:client.alarm_api.arm_full()
client.alarm_api.arm_partial()
client.alarm_api.disarm()orclient.alarm.set_alarm_state(<mode>)where 'mode' is one of:from yaleclient.alarm import (YALE_STATE_ARM_PARTIAL,
                              YALE_STATE_DISARM,
                              YALE_STATE_ARM_FULL)Is the alarm armed fully or partially:client.alarm_api.is_armed() # == Trueor return alarm status. eg.client.alarm_api.get_armed_status() is YALE_STATE_ARM_FULL
Package: yale-dhlab-keras-preprocessing
Keras Preprocessing is the data preprocessing
and data augmentation module of the Keras deep learning library.
It provides utilities for working with image data, text data,
and sequence data.Read the documentation at:https://keras.io/Keras Preprocessing may be imported directly
from an up-to-date installation of Keras:` from keras import preprocessing `Keras Preprocessing is compatible with Python 2.7-3.6
and is distributed under the MIT license.