Saravanan666/pypi-org huggingface dataset:
Package: async-owoify
async-owoifySimple ext package for owoifing text.InstallSimple paste this into your terminalpipinstallasync-owoifyIf you need toupdateplease use the following:pipinstall--upgradeasync-owoifySimple UseFirstly, import the package usingimportowoifyNow, lets use theowoify.owoify()attribute toowoifyyour text!importowoifyprint(owoify.owoify("TEXT"))Wanna decode this now? Use theowoify.decode()attribute for this module.importowoifyprint(owoify.decode("TEXT"))Note: The decode attribute is still in dev, as i need to find all words that would get owoified :)Devlepoment versionTo install this, you need to install from the githubpipinstall-Ugit+https://github.com/GreenDiscord/async-owoifyThanks! Please give feedback in issues :)
Package: async-pavlov
async-pavlovAsync wrapper for pavlov RCON commandsRequirementsPython 3.7+Installpipinstallasync-pavlovUsageimportasynciofrompavlovimportPavlovRCONasyncdefmain():pavlov=PavlovRCON("127.0.0.1",9104,"password")data=awaitpavlov.send("ServerInfo")print(data)asyncio.run(main())
Package: async-payok
Installation | УстановкаWindowspip install async-payokLinuxpip3 install async-payokInformation | ИнформацияENG: The current version of AsyncPayOk is 0.3.0
RU: Актуальная версия AsyncPayOk 0.3.0Methods | ФyнкцииENGAsynchronous module for working with the Payok API

What can?
- Getting a balance
- Getting a referral balance
- Creating a payment form
- Getting up-to-date transactionsRUАсинхронный модуль для работы с API Payok

Что может?
- Получение баланса
- Получение реферального баланса
- Создание формы оплаты
- Получение актуальных транзакцийUPDATE 0.3.0 | ОБНОВЛЕНИЕ 0.3.0END:
Added new types:
- Status (PAID, WAITING);
- Webhook_status (DELIVERED, NOT_DELIVERED, DELIVERED_ERROR)

RU:
Добавлены новые типы:
- Status (PAID, WAITING);
- Webhook_status (DELIVERED, NOT_DELIVERED, DELIVERED_ERROR)
Package: asyncpd
asyncpdasynciocompatible PagerDuty REST API client withdataclass-typed response models.UsageHere is an example usage snippet for interacting with the PagerDuty API
with this package:importasynciofromasyncpdimportAPIClientasyncdefmain():client=APIClient(token="my_pagerduty_oauth_token",)print(awaitclient.abilities.list())print(awaitclient.abilities.is_enabled("sso"))if__name__=="__main__":loop=asyncio.get_event_loop()loop.run_until_complete(main())Supported APIsThe following list displays what API resources are available in this package.AbilitiesAddonsAnalyticsAuditAutomation ActionsPaused Incident ReportsBusiness ServicesCustom FieldsChange EventsEscalation PoliciesEvent OrchestrationsExtension SchemasExtensionsIncidentsIncident WorkflowsLicensesLog EntriesMaintenance WindowsNotificationsOn-CallsPrioritiesResponse PlaysRulesetsSchedulesService DependenciesServicesWebhooksStandardsStatus DashboardsTagsTeamsTemplatesUsersVendorsEventsV2
Package: asyncpg
asyncpgis a database interface library designed specifically for
PostgreSQL and Python/asyncio.  asyncpg is an efficient, clean implementation
of PostgreSQL server binary protocol for use with Python’sasyncioframework.  You can read more about asyncpg in an introductoryblog post.asyncpg requires Python 3.8 or later and is supported for PostgreSQL
versions 9.5 to 16.  Older PostgreSQL versions or other databases implementing
the PostgreSQL protocolmaywork, but are not being actively tested.DocumentationThe project documentation can be foundhere.PerformanceIn our testing asyncpg is, on average,5xfaster than psycopg3.The above results are a geometric mean of benchmarks obtained with PostgreSQLclient driver benchmarking toolbenchin June 2023 (click on the chart to see full details).Featuresasyncpg implements PostgreSQL server protocol natively and exposes its
features directly, as opposed to hiding them behind a generic facade
like DB-API.This enables asyncpg to have easy-to-use support for:prepared statementsscrollable cursorspartial iterationon query resultsautomatic encoding and decoding of composite types, arrays,
and any combination of thosestraightforward support for custom data typesInstallationasyncpg is available on PyPI and has no dependencies.
Use pip to install:$ pip install asyncpgBasic Usageimportasyncioimportasyncpgasyncdefrun():conn=awaitasyncpg.connect(user='user',password='password',database='database',host='127.0.0.1')values=awaitconn.fetch('SELECT * FROM mytable WHERE id = $1',10,)awaitconn.close()loop=asyncio.get_event_loop()loop.run_until_complete(run())Licenseasyncpg is developed and distributed under the Apache 2.0 license.
Package: asyncpgdb
# asyncpgdb`asyncpgdb`is a Python library that provides an asynchronous database interface built on top of`asyncpg`. One of its unique features is a custom query formatting style that allows you to write parameterized queries using a more readable syntax.## InstallationYou can install`asyncpgdb`using pip:

```bash
pip install asyncpgdbFeaturesAsynchronous database operations.Connection pooling for efficient resource management.Simplified query execution and result handling.Custom query formatting style for better readability.UsageDatabase ConnectionTo establish a connection to your PostgreSQL database, create an instance of theDatabaseclass:fromasyncpgdbimportDatabasedb=Database(dsn="your_database_dsn_here")awaitdb.connect()Executing QueriesYou can execute queries using theexecutemethod. The library supports a custom query formatting style that allows you to parameterize your queries using named variables, enclosed in$( ):query="SELECT name, age FROM users WHERE name = $(name) AND age > $(age)"result=awaitdb.execute(query,vars={"name":"John","age":30})# For SELECT queries, you can fetch the results in various formatsrows=awaitresult.fetch_all()Connection Managementasyncpgdbprovides automatic connection management, so you don't need to worry about acquiring and releasing connections manually:asyncwithdb.acquire_connection()asconn:# Use the connection for queries within this blockpass# Connection is automatically released after this blockConnection Poolasyncpgdbmanages a connection pool by default, so you can specify the minimum and maximum number of connections in the pool when creating aDatabaseinstance:db=Database(dsn="your_database_dsn_here",min_size=2,max_size=10)ExamplesSelecting Dataquery="SELECT name, age FROM users WHERE age > $(age)"results=awaitdb.execute(query,vars={"age":30})users=awaitresults.fetch_all()Inserting Dataquery="INSERT INTO products (name, price) VALUES ($(name), $(price))"awaitdb.execute(query,vars={"name":"Widget","price":19.99})Updating Dataquery="UPDATE orders SET status = $(status) WHERE id = $(id)"awaitdb.execute(query,vars={"status":"shipped","id":123})DocumentationFor more details and advanced usage, refer to thedocumentation.LicenseThis library is licensed under the MIT License.Please replace `"your_database_dsn_here"` with your actual database DSN, and ensure that you have the required dependencies installed to use `asyncpgdb`. You can find detailed documentation and usage examples in the official documentation.
Package: asyncpg-dev
asyncpgis a database interface library designed specifically for
PostgreSQL and Python/asyncio.  asyncpg is an efficient, clean implementation
of PostgreSQL server binary protocol for use with Python’sasyncioframework.  You can read more about asyncpg in an introductoryblog post.asyncpg requires Python 3.7 or later and is supported for PostgreSQL
versions 9.5 to 15.  Older PostgreSQL versions or other databases implementing
the PostgreSQL protocolmaywork, but are not being actively tested.DocumentationThe project documentation can be foundhere.PerformanceIn our testing asyncpg is, on average,3xfaster than psycopg2
(and its asyncio variant – aiopg).The above results are a geometric mean of benchmarks obtained with PostgreSQLclient driver benchmarking toolbenchin November 2020 (click on the chart to see full details).Featuresasyncpg implements PostgreSQL server protocol natively and exposes its
features directly, as opposed to hiding them behind a generic facade
like DB-API.This enables asyncpg to have easy-to-use support for:prepared statementsscrollable cursorspartial iterationon query resultsautomatic encoding and decoding of composite types, arrays,
and any combination of thosestraightforward support for custom data typesInstallationasyncpg is available on PyPI and has no dependencies.
Use pip to install:$ pip install asyncpgBasic Usageimportasyncioimportasyncpgasyncdefrun():conn=awaitasyncpg.connect(user='user',password='password',database='database',host='127.0.0.1')values=awaitconn.fetch('SELECT * FROM mytable WHERE id = $1',10,)awaitconn.close()loop=asyncio.get_event_loop()loop.run_until_complete(run())Licenseasyncpg is developed and distributed under the Apache 2.0 license.
Package: asyncpg-engine
asyncpg-engineSmall wrapper aroundasyncpgfor specific experience and transactional testing.Basic usagefromasyncpg_engineimportEngineengine=awaitEngine.create("postgres://guest:guest@localhost:5432/guest?sslmode=disable")asyncwithengine.acquire()ascon:# https://magicstack.github.io/asyncpg/current/api/index.html#asyncpg.connection.Connectionassertawaitcon.fetchval("SELECT 1")==1Custom type conversionsYou can specifycustom encoder/decoderby subclassingEngine:fromasyncpg_engineimportEngineimportorjsonclassMyEngine(Engine):@staticmethodasyncdef_set_codecs(con:Connection)->None:# https://magicstack.github.io/asyncpg/current/api/index.html#asyncpg.connection.Connection.set_type_codecawaitcon.set_type_codec("json",encoder=orjson.dumps,decoder=orjson.loads,schema="pg_catalog")Pytest pluginLibrary includes pytest plugin with support for transactional testing.To start using it installpytest, enable plugin in your rootconftest.pyand definepostgres_urlfixture that returns database connection string:pytest_plugins=["asyncpg_engine"]@pytest.fixture()defpostgres_url()->str:return"postgres://guest:guest@localhost:5432/guest?sslmode=disable"Now you can use two fixtures:dbthat returnsEngineinstance:asyncdeftest_returns_true(db):asyncwithdb.acquire()ascon:assertawaitcon.fetchval("SELECT true")conthat returns already acquired connection:asyncdeftest_returns_true(con):assertawaitcon.fetchval("SELECT true")By defaultEngineis configured for transactional testing, so every call todb.acquireorconusage will return the same connection with already started transaction. Transaction is rolled back at the end of test, so all your changes in db are rolled back too.You can override this behaviour withasyncpg_enginemark:@pytest.mark.asyncpg_engine(transactional=False)asyncdeftest_returns_true(con):assertawaitcon.fetchval("SELECT true")@pytest.mark.asyncpg_engine(transactional=False)asyncdeftest_returns_true_too(db):asyncwithdb.acquire()ascon:assertawaitcon.fetchval("SELECT true")If you want to use your own customEnginesubclass in tests you can defineasyncpg_engine_clsfixture that returns it:fromasyncpg_engineimportEngineclassMyPrettyEngine(Engine):pass@pytest.fixture()defasyncpg_engine_cls()->typing.Type[MyPrettyEngine]:returnMyPrettyEngineasyncdeftest_returns_my_pretty_engine(db:MyPrettyEngine)->None:assertisinstance(db,MyPrettyEngine)Development and contributionFirst of all you should installPoetry.install project dependenciesmakeinstallrun lintersmakelintrun testsmaketestfeel free to contribute!
Package: asyncpg-listen
asyncpg-listenThis library simplifies usage of listen/notify withasyncpg:Handles loss of a connectionSimplifies notifications processing from multiple channelsSetups a timeout for receiving a notificationAllows to receive all notifications/only last notification depending on ListenPolicy.importasyncioimportasyncpgimportasyncpg_listenasyncdefhandle_notifications(notification:asyncpg_listen.NotificationOrTimeout)->None:print(f"{notification}has been received")asyncdefmain():listener=asyncpg_listen.NotificationListener(asyncpg_listen.connect_func(user="postgres"))listener_task=asyncio.create_task(listener.run({"simple":handle_notifications},policy=asyncpg_listen.ListenPolicy.LAST,notification_timeout=5))awaitasyncio.sleep(1)connection=awaitasyncpg.connect(user="postgres")try:foriinrange(42):awaitconnection.execute(f"NOTIFY simple, '{i}'")finally:awaitconnection.close()awaitasyncio.sleep(1)listener_task.cancel()asyncio.run(main())v0.0.6 (2022-11-02)Add support of python 3.11v0.0.5 (2022-05-23)Wait for tasks cancellationv0.0.4 (2022-01-24)Reset failed attempts counter on successful connectionv0.0.3 (2022-01-23)Support python 3.8v0.0.2 (2021-11-02)Support async-timeout 4.0+v0.0.1 (2021-10-27)A first version
Package: asyncpgpromise
AsyncPGPromiseMotivationThe creation of AsyncPGPromise was primarily driven by an aspiration to bring the clean API and named arguments support, common in Node.js' `pg-promise``, to the Python ecosystem. The lack of such an approach in Python became more pronounced upon transitioning from Node.js, sparking the motivation to develop a solution. With Python's ultra-fast writing mold being a major encouraging factor, this tiny wrapper, AsyncPGPromise, was brought into existence to fill this gap and to provide a sleek and efficient means of handling PostgreSQL database operations.FeaturesSimplicity: By using named arguments in your SQL queries, you can keep your code clean and readable.Flexibility: All the power of theasyncpglibrary is still at your fingertips, with additional convenience provided by AsyncPGPromise.InstallationpipinstallasyncpgpromiseGetting StartedYou can create a newAsyncPGPromiseinstance with an existingasyncpgconnection object:fromasyncpgpromiseimportAsyncPGPromiseimportasyncpg# First create an asyncpg connectionconn=awaitasyncpg.connect(user='user',password='password',database='database',host='127.0.0.1')# Then pass it to AsyncPGPromisepg=AsyncPGPromise(conn)UsageQueryingYou can perform SQL queries with named arguments:rows=awaitpg.query('SELECT * FROM users WHERE name = $name',name='John')Thequerymethod returns a list of dictionaries, each representing a row from the SQL query.Fetching One RowIf you're only expecting a single row result, you can use theonemethod:row=awaitpg.one('SELECT * FROM users WHERE id = $id',id=1)NoteThis is a new project and may still have some rough edges. Contributions are very welcome!To-DoParsing of fields with JSON dataLicenseAsyncPGPromise is available under the MIT license. See the LICENSE file for more info.
Package: asyncpg-rkt
asyncpg-rktis a fork ofasyncpg, a database interface library designed specifically for
PostgreSQL and Python/asyncio.  asyncpg is an efficient, clean implementation
of PostgreSQL server binary protocol for use with Python’sasyncioframework.  You can read more about asyncpg in an introductoryblog post.asyncpg-rktextendsasyncpgas follows:Backward compatible with the origin.It is possible to set the numpy dtype for the fetched query.Such “typed” queries return numpy arrays instead of lists of Record objects.We construct numpy arrays directly from the low-level PostgreSQL protocol, without materializing any Python objects.Although, we supportobjectfields, too.The time from receiving the response from PostgreSQL server untilConnection.fetch()returns is ~20x less. This is because we avoid the overhead of dealing with Python objects in the result.We returnravel()-ed indexes of nulls while writing NaN-s/NaT-s at the corresponding places in the array.There is an option to return data by column vs. by row.asyncpg-rktprovides the best performance when there are thousands of rows returned and the field types map to numpy.Read the blog post with the introduction.asyncpg-🚀 requires Python 3.8 or later and is supported for PostgreSQL
versions 9.5 to 14.  Older PostgreSQL versions or other databases implementing
the PostgreSQL protocolmaywork, but are not being actively tested.DocumentationThe project documentation can be foundhere.See below about how to use the fork’s special features.PerformanceIn our testing asyncpg is, on average,3xfaster than psycopg2
(and its asyncio variant – aiopg).The above results are a geometric mean of benchmarks obtained with PostgreSQLclient driver benchmarking toolbenchin November 2020 (click on the chart to see full details).Further improvement from writing numpy arrays is ~20x:Featuresasyncpg implements PostgreSQL server protocol natively and exposes its
features directly, as opposed to hiding them behind a generic facade
like DB-API.This enables asyncpg to have easy-to-use support for:prepared statementsscrollable cursorspartial iterationon query resultsautomatic encoding and decoding of composite types, arrays,
and any combination of thosestraightforward support for custom data typesInstallationasyncpg-🚀 is available on PyPI and requires numpy 1.21+.
Use pip to install:$ pip install asyncpg-rktBasic Usageimportasyncioimportasyncpgfromasyncpg.rktimportset_query_dtypeimportnumpyasnpasyncdefrun():conn=awaitasyncpg.connect(user='user',password='password',database='database',host='127.0.0.1')dtype=np.dtype([("a",int),("b","datetime64[s]"),])array,nulls=awaitconn.fetch(set_query_dtype('SELECT * FROM mytable WHERE id = $1',dtype),10,)awaitconn.close()loop=asyncio.get_event_loop()loop.run_until_complete(run())Licenseasyncpg-🚀 is developed and distributed under the Apache 2.0 license, just like the original project.
Package: asyncpg_simpleorm
asyncpg-simpleormSimple orm for asyncpg.Free software: Apache Software License 2.0Documentation:https://asyncpg-simpleorm.readthedocs.io.FeaturesSimplifies generating database queries.Not-Featured (yet)Nested queriesRelationship queriesDependenciesasyncpgCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2017-07-03)First release on PyPI.
Package: asyncpg-stubs
asyncpg-stubsThis package contains type stubs to provide more precise static types and type inference forasyncpg.Installationpipinstallasyncpg-stubsDevelopmentMake sure you havepoetryinstalled.poetryinstall
poetryrunpre-commitinstall--hook-typepre-commitVersion numbering schemeThemajorandminorversion numbers ofasyncpg-stubswill match themajorandminorversion numbers of theasyncpgrelease the stubs represent. For
instance, if you are usingasyncpgversion0.25.0, you would useasyncpg-stubsversion0.25.XwhereXis the latestpatchversion of the stubs. Using semver
dependencty specifications,asyncpg-stubsversion~0.25is designed to work withasyncpgversion~0.25.In addition,asyncpg-stubswill indicate which versions of the runtime library are compatible through its dependency information (as suggested in PEP-561).
Package: asyncpg-trek
asyncpg-trek: simple migrations for asyncpgA simple library for managing migrations.Target audienceMe.
But maybe if you use [asyncpg] and prefer to write migrations as raw SQL (i.e. you're not using SQLAlchemy/Alembic) then you as well.Featuresasync: migrations usually don't benefit from being async, but you benefit from using the same database driver in as your application uses (only [asyncpg] is supported).simple: you just create.sqlor Python files in a folder of your choosing and point this tool at that folder. No need to fight a new API to write migrations in.API centric: there is no CLI to figure out,youdecide how migrations get called,youcontrol how the database connection gets created. This makes it trivial to run migrations in tests, wrap them in a CLI or run them via an exposed HTTP endpoint.declarative: just specify the version you want and the library figures out if it needs an upgrade, downgrade or no action.Example usagefrompathlibimportPathimportasyncpgfromasyncpg_trekimportplan,execute,Directionfromasyncpg_trek.asyncpgimportAsyncpgBackendMIGRATIONS_DIR=Path(__file__).parent/"migrations"asyncdefmigrate(conn:asyncpg.Connection,target_revision:str,)->None:backend=AsyncpgBackend(conn)asyncwithbackend.connect()asconn:planned=awaitplan(conn,backend,MIGRATIONS_DIR,target_revision=target_revision,direction=Direction.up)awaitexecute(conn,backend,planned)You could make this an entrypoint in a docker image, an admin endpoint in your API or a helper function in your tests (or all of the above).
How you run your migrations depends on the complexity of your system.
For example, for simple systems it may be easy to run migrations on app startup based on a hardcoded revision.
For more complex systems you may want to run migrations manually or via an admin API.See this release on GitHub:v0.3.1
Package: asyncpgw
asyncpgwこれはdiscord.pyとasyncpgを使用し、POSTTGRESQLにデータを保存する処理があるBOTを作ってる日本人向けに作成したものです。使い方asyncpgwをインストールpython3 -m pip install asyncpg基本的な使い方ソースコードがかなり長くなってしまうので、testsフォルダーにまとめてあります。尚、このコードはCOGを使用しています。テキストチャットで発言するとユーザーのレベルがあがるコードを例にしてます。変更ログ0.0.1・テスト0.0.2・descriptionの変更0.0.3・カラムが空だった場合に対応0.0.4・bug fix0.0.5・bug fix0.0.6・bug fix0.0.7・bug fix0.0.8・　ListpgクラスのTypeErrorが出るバグを直した。0.0.9・　Listpgクラスの)の位置を直した0.1.0・　Listpgクラスのbugを直した0.1.1・limit_fetchsのbugを直した0.1.2・同じ0.1.3・ListPgをPgにまとめた
・sortfetchとlimitfetchを追加0.1.4・sort_fetchのバグを直した0.1.5・sort_fetchのバグを直した0.1.6・sort_fetchのバグを直した0.1.7 ~ 0.2.5・カラムが指定されない時に対応した。0.2.6・カラムの追加削除関数を追加0.2.7・カラム削除関数のバグを直した
Package: asyncpgx
asyncpgxExtensions for asyncpg.Based on theasyncpgand highly inspired by thesqlxpackageThis package supports 3.6+ python versionsSetupUsepip install asyncpgxPurposeThis is a thin wrapper on theasyncpgpackage.
Our purpose is to provide convenient extensions to the original package.
We're trying to delegate as much work as we can to the asyncpg (basically our extension methods are high-level proxies to the underlying ones)
and make only converting job.
Original asyncpg API stays the same, you can see it in theasyncpg documentation.Functionalityqueries with named parameters, i.e.importasyncpgxconnection=awaitasyncpgx.connect('postgresql://127.0.0.1:5432')awaitconnection.named_fetch('''SELECT field FROM some_table WHERE id <= :id;''',{'id':1})prepared statements with named parameters, i.e.importasyncpgxconnection=awaitasyncpgx.connect('postgresql://127.0.0.1:5432')prepared_statement=awaitconnection.named_prepare('''SELECT field FROM some_table WHERE id <= :id;''')awaitprepared_statement.named_fetch({'id':1})DocumentationYou can find project documentationhereChangelogYou can find all releases descriptionhere
Package: asyncpipe
asyncpipeThis is a little module to help you chain together subprocess pipelines, a bit
more nicely than python natively lets you. The key element here is the support
for asyncio.OS CompatibilityThis will only work on versions of python that support async/await syntax
I've only tested this on Linux. I don't see any reason why it wouldn't work on
OSX/BSD, but it's possible. I doubt this works on Windows at all.Python compatibilityThis requires 'async' and 'await' keywords, so Python 3.5+ only.MotivationWhen you use aPIPEfor stdout in the native asyncio.subprocess module, you
don't get back a value that can be passed to another Popen like you do in the
subprocess module. Instead you get a wrapper. Sometimes you can resolve that by
just using the 'shell' execution model, but sometimes that's not a great fit.The solution is to do an error-prone set of operations with os.pipe and linking
up various subprocesses stdin/stdout. This gets especially ugly when you've got
a chain of 3+ shell commands.UseSynchronousThe synchronous form is pretty straightforward:import asyncpipe
pipe = asyncpipe.PipeBuilder('ls')
# you can chain it
pipe.chain('grep', '^S')
# or use the 'or' operator
pipe | 'wc -l'
results = pipe.call()
matches = int(results[-1].stdout.strip())All of those return the underlying object, and the starting arguments are
optional, so this is equivalent:import asyncpipe
pipe = asyncpipe.PipeBuilder().chain('ls') | 'grep ^s' | ['wc' '-l']
results = pipe.call()
matches = int(results[-1].stdout.strip())AsyncronousAsync code is similar, except you need to pass the event loop as the 'loop'
value to the PipeBuilder, or set it any time before callingcall_async():import asyncpipe
import asyncio
loop = asyncio.new_event_loop()
# if you don't do this, you will get errors from asyncio 
asyncio.set_event_loop(loop)
pipe = asyncpipe.PipeBuilder(loop=loop)
pipe.chain('ls') | 'grep ^s' | ['wc' '-l']
results = loop.run_until_complete(pipe.call_async())
matches = int(results[-1].stdout.strip())If you were doing more in your event loop, you would of course justawait pipe.call_async()!