Saravanan666/pypi-org huggingface dataset:
Package: athenaSql
athenaSQLathenaSQL is Athena SQL query builder, inspired by sparkSQL. It borrow some sparkSQL's conceptsparkSQL.It was initially designed to eliminate the need for hard-coding SQL queries as strings within Python scripts and as an alternative to any bespoke SQL query templating. However, it offers the flexibility to be used in various ways as needed.QuickstartInstalling athenaSQL$pipinstallathenaSQLUsageUsing athenaSQL is stright forward. First we create a table abstraction class then building a query is just calling chain methods on top of it.fromathenaSQLimportAthena# creating athena table instance from databasetable=Athena('database_name').table('table_name')# creating athena table instance from databasequery=table.select()query.show_query()SELECT
    *
FROM "database_name"."table_name"
Package: athena-udf
athena-udfAthena User Defined Functions(UDFs) in Python made easy!This library implements the Athena UDF protocol in Python so you don't have to use Java and you can use any Python library you wish including numpy/pandas!InstallationInstall this library usingpip:pip install athena-udfUsageSimply install the package, create a lambda handler Python file, subclassBaseAthenaUDFand implement thehandle_athena_recordstatic method with your required functionality like this:import athena_udf


class SimpleVarcharUDF(athena_udf.BaseAthenaUDF):

    @staticmethod
    def handle_athena_record(input_schema, output_schema, arguments):
        varchar = arguments[0]
        return varchar.lower()


lambda_handler = SimpleVarcharUDF().lambda_handlerThis very basic example takes avarcharinput, and returns the lowercase version.varcharis converted to a python string on the way in and way out.input_schemacontains aPyArrowschema representing the schema of the data being passedoutput_schemacontains aPyArrowschema representing the schema of what athena expects to be returned.argumentscontains a list of arguments given to the function. Can be more than 1 with different types.If you package the above into a zip, with dependencies and name your lambda functionmy-kambdayou can then run it from the athena console like so:USINGEXTERNALFUNCTIONmy_udf(col1varchar)RETURNSvarcharLAMBDA'athena-test'SELECTmy_udf('FooBar');Which will yield the resultfoobarSee other examples in theexamplesfolder of this repo.Important information before using.Each lambda instance will take multiple requests for the same query. Each request can contain multiple rows,athena-udfhandles this for you and your implementation will receive a single row.Athena will group your data into around 1MB chunks in a single request. The maximum your function can return in 6MB per chunk.This library usesPyArrow. This is a large library so the Lambdas will be around 50MB zipped.Timestamps seem to be truncated into Pythondateobjects missing the time.Functions can return one value only. To return more complex data structures consider returning a JSON payload and parsing on athena.DevelopmentTo contribute to this library, first checkout the code. Then create a new virtual environment:cd athena-udf
python -m venv venv
source venv/bin/activateNow install the dependencies and test dependencies:pip install -e '.[test]'To run the tests:pytest
Package: athentoimaging
# Athento-imagingAthento-Imaging is a package developed using Python and OpenCV to improve OCR in
documents. Among the documents tested using this package are: passports, bills,
delivery notes, budgets, and other common documents.This package includes several functions to transform images:Remove coloured background.Remove “salt and pepper” noise.Line detection in documents (two approachs).Remove lines in documents.Simple line analysis (which lines are horizontal and vertical, distance between lines, etc.Template matching improved using pyramid transformations.You can check everything out here: [Athento-Imaging Summary](<docs/SUMMARY.md>)The quality of the output and it’s OCR performance will depend on:The quality of the source document, as the quality value increases so does the OCR.The amount of noise in the document and where it’s located.The location of the document’s watermarks (if any).The colour of the document. Clear colours are easier to remove than darker colours due to the proximity of the pixel values between the background and the text.Your personal experience in image transformation. As you might need to perform  a combination of operations or change the parameters values significantly.
Package: atheris-libprotobuf-mutator
Libprotobuf-mutator: Python bindings for AtherisStructure-aware Fuzzing with Protocol BuffersAtheris supports custom mutators(as offered by LibFuzzer)to produce grammar-aware inputs.Protocol buffers are an example of structured types that are hard to fuzz with
generic mutation-based fuzzers. Libprotobuf-mutator bindings for Atheris allow
to generate protocol buffer inputs for your fuzzing targets using custom
mutators.Apart from fuzzing targets that take protocol buffers as input, it's also
possible to use protocol buffers as an intermediate representation for fuzzing
complex input types. See the docs on usingProtocol Buffers As Intermediate Format for fuzzing.Getting StartedPrerequisiteInstallAtherispip3 install atherisInstallInstalling libprotobuf-mutator for Atheris from source requiresbazel. Visithttps://docs.bazel.build/versions/master/install.htmlfor installation
instructions.Then run:pip3install.Example usageUsing Atheris with Libprotobuf-mutator is similar to using plain Atheris. The
main difference is that the function under test will receive a proto of the
given format, instead of a bytes array.You can specify the proto format using theatheris_libprotobuf_mutator.Setup()function, which substitutes the regularatheris.Setup()function.importatherisimportatheris_libprotobuf_mutatorimportsysimportexample_proto_pb2@atheris.instrument_funcdefTestOneProtoInput(msg):# msg will be an ExampleMessage as specified in the Setup() function below.ifmsg.example_value==13371337:raiseRuntimeError('Crash!')if__name__=='__main__':atheris_libprotobuf_mutator.Setup(sys.argv,TestOneProtoInput,proto=example_proto_pb2.ExampleMessage)atheris.Fuzz()
Package: athina-evals
Overviewathina-evalsis an framework to help you quickly set up evaluations and monitoring for your LLM-powered applicationIt's difficult to know if your LLM response is good or bad. Most developers start out by simply eyeballing the responses. This is fine when you're building a prototype and testing on 5-10 examples.But once you optimize for reliability in production, this method breaks down.Evals can help you:Detect regressionsMeasure performance of model (as defined by your goals)A/B test different models and prompts rapidlyMonitor production data with confidenceRun quantifiable experiments against ambiguous conversationsThink of evals like unit tests for your LLM app.DocumentationSeehttps://docs.athina.aifor the complete documentation.Quick Start1. Install the packagepip install athina-evals2. Get an Athina API keySign up atathina.aito get an API key.(free, and only takes about 30 seconds)3. Set API keysfromathina.keysimportAthinaApiKey,OpenAiApiKeyOpenAiApiKey.set_key(os.getenv('OPENAI_API_KEY'))AthinaApiKey.set_key(os.getenv('ATHINA_API_KEY'))4. Run evals# Load the data from CSV, JSON, Athina or Dictionarydataset=RagLoader().load_json(json_file)# Run the DoesResponseAnswerQuery evaluator on the datasetDoesResponseAnswerQuery().run_batch(data=dataset)Why should I use Athina's Evals instead of writing my own?You could build your own eval system from scratch, but here's why Athina might be better for you:Athina provides you with plug-and-play preset evals that have been well-testedAthina evals can run on both development and production, giving you consistent metrics for evaluating model performance and drift.Athina removes the need for your team to write boilerplate loaders, implement LLMs, normalize data formats, etcAthina offers a modular, extensible framework for writing and running evalsAthina calculate analytics like pass rate and flakiness, and allows you to batch run evals against live production data or dev datasetsNeed Production Monitoring and Evals? We've got you covered...Athina eval runs automatically write into Athina Dashboard, so you can view results and analytics in a beautiful UI.Athina track your experiments automatically, so you can view a historical record of previous eval runs.Athina calculates analytics segmented at every level possible, so you can view and compare your model performance at very granular levels.About AthinaAthina is building an end-to-end LLM monitoring and evaluation platform.Website|Demo VideoContact us athello@athina.aifor any questions about the eval library.
Package: athletes-unlimited-py
athletes-unlimited-pyPython package for the Athletes Unlimited sports organization, and for the various sports it hosts.How to installThis package is is advalible through thepippackage manager, and can be installed through one of the following commands in your terminal/shell:pip install athletes_unlimited_pyORpython -m pip install athletes_unlimited_pyIf you are using a Linux/Mac instance, you may need to specifypython3when installing.python3 -m pip install athletes_unlimited_pyAlternatively,athletes-unlimited-pycan be installed from this GitHub repository with the following command through pip:pip install git+https://github.com/armstjc/athletes-unlimited-pyORpython -m pip install git+https://github.com/armstjc/athletes-unlimited-pyORpython3 -m pip install git+https://github.com/armstjc/athletes-unlimited-py
Package: athom-api
python-athom-apiPython module for acessing the Athom Homey Web-APIAPI DocumentationThis API implementation follows the same naming convention as the official Javascript API client. So for usage see:https://api.developer.athom.com/API coverageCurrently the following managers are implemented:AppsDevicesImagesSessionsspeechInputspeechOutputUsersAPI usageSee the examples directory.
Package: ati18n
基本用法Usage: cli.py [OPTIONS] PATH

  Console script for ati18n.

  用来检查国际化是否有问题或可疑点的工具，支持Java应用、Vue应用、Flask应用中的多语言功能，检查其中是否有些可能的问题点，方便研发人员快速解决问题。

Arguments:
  PATH    应用路径  [required]

Options:
  -t, --type [Java|Vue|Flask]     specify the app type. 指定应用类型  [default:
                                  Java]
  --install-completion [bash|zsh|fish|powershell|pwsh]
                                  Install completion for the specified shell.
  --show-completion [bash|zsh|fish|powershell|pwsh]
                                  Show completion for the specified shell, to
                                  copy it or customize the installation.
  --help                          Show this message and exit.Feature 特性基于规则的检查模式，方便扩充可以检查三个范围可能的问题，翻译文件级别、单个翻译项级别、多个关联翻译项级别统一的规则定义、错误信息定义，方便使用基于python实现，可跨平台运行支持检查多种应用检查Design Notes 概要设计使用方法说明本工具的目标是更实用为多语言类应用提供支持，提升这方面的效率。主要的使用方法有三类：命令行调用直接检查，直观的输出结果命令行调用，输出数据结果文件，方便不同工具之间的衔接可以集成到各类IDE中，方便在IDE中交互式使用结果数据在第二种方式中，ati18n会根据检查结果生成一个检查结果数据文件，实际的数据结果文件是检查信息数据结构的一个数组，举例如下：{"tools":"ati18n","version":"0.1.0","app_path":"/xxx/xxx","app_type":"Java","datetime":"1990-01-01 12:12:12","result":[{"No":"1001","Level":"错误","Scope":"整体翻译","Name":"翻译条目数不匹配","Data":{"type":"file","file_path":"/xxx.properties"},"Comment":""},{"No":"1002","Level":"错误","Scope":"整体翻译","Name":"文件名指定的语言种类和文件内容不匹配","Data":{"type":"file","file_path":"/xxx.properties"},"Comment":""},{"No":"2001","Level":"警告","Scope":"单个翻译项","Name":"翻译项和指定的语言类型不匹配","Data":{"type":"item","key_name":"xxxx","key_value":"xxxx","lang_code":"zh_CN","info":"翻译项全是英文，没有中文字符","file_path":"/xxx.properties"},"Comment":""}]}检查信息数据结构针对应用的多语言检查，会发现相应的问题，这里定义一下返回问题的可能情况级别：错误、警告、提示范围：整体翻译，单个翻译项，多个翻译项编号 No级别 Level范围 Scope错误名称 Name详细信息 Data备注 Comment1001错误整体翻译翻译条目数不匹配检查的数据文件和相关信息1002错误整体翻译文件名指定的语言种类和文件内容不匹配检查的数据文件和相关信息2001警告/错误单个翻译项翻译项和指定的语言类型不匹配检查的数据项和相关信息2002错误单个翻译项翻译项在 item 级别为空检查的数据项和相关信息2003错误单个翻译项源代码中有的 item 没有对应的翻译检查的数据项和相关信息3001警告/错误多个翻译项多个相同 key ，但是 value 不一致检查的数据项和关联所有翻译项信息3002警告/错误多个翻译项同一个语言的value，对应的其他语言翻译不一样检查的数据项和关联所有翻译项信息检查规则汇总在应用中的多语言检查，会有各种规则，这里列出来可能适合的规则规则编号范围规则名称关联检查信息备注G1001整体翻译检查翻译文件中翻译项数量是否匹配1001G1002整体翻译翻译文件语言种类和文件名称不匹配1002G2001单个翻译条目翻译文件语言种类和待翻译项名称不匹配2001G2002单个翻译条目检查 item 级别的空规则2002G2003单个翻译条目源代码中有的 item，但是没有对应的翻译2003G3001多个翻译条目多个相同 key ，但是 value 不一致3001G3002多个翻译条目同一个语言的value，对应的其他语言翻译不一样3002ReferenceOnline Documentation 在线文档ati18n · PyPIHistory0.3.2 (2022-05-13)增加文档和设计信息初步支持dockerfile0.3.0 (2022-05-05)实现新的检查规则更新Github Action0.2.1 (2022-04-27)适配发布流程0.2.0 (2022-04-27)功能有更新，可以用在某系基本场景里了.0.1.0 (2022-04-18)First release on PyPI.
Package: atiiaftt
Python interface to ATI-IA force-torque transform (ATIDAQ) C library, v1.0.7. For use with ATI Industrial Automation force-torque sensors.This package does not read from hardware. Another package, such as NI-DAQmx,
must be used for that purpose.ATIDAQ C Library is available athttps://www.ati-ia.com/library/software/daq_ft/ATIDAQ%20C%20Library.zipInstallationpip install atiiafttDependenciesCFFI and platform appropriate build tools are required to build the C source
that is included with the package.For Linux distributions, install the developer package group.For Windows, seehttps://wiki.python.org/moin/WindowsCompilersDocumentationModule help for the python classes is available via docstrings. Documentation
for the wrapped functions is available inATIDAQ_c_lib/readme.txtUsage examplesHigh level usage is as follows:import atiiafttCreate an instance of theatiiafft.FTsensorclassLoad calibration data, either passing the calibration file path as a string during class instantiation or as a parameter while callinginstance.createCalibration(‘./FT18766cal’).Optionally, set the tool transform, bias values and units as needed, eg)instance.setToolTransform([0,0,20,45,0,0],atiiaftt.FTUnit.DIST_MM,atiiaftt.FTUnit.ANGLE_DEG)instance.bias([0.254,-1.027,0.025,0.7422.0.9302,-0.230,0.082])Call the force-torque conversion function:instance.convertToFt([0.042,1.004,0.952,-0.235,0.091,1.091,0.054]); this returns the forces and torques as a list[F.x,F.y,F.z,T.x,T.y,T.z]. The last transformed values are stored in the instance variableinstance.ft_vectorfor later access.CFFI and python class examples found in ‘atiiaftt/samples/ftconvert.py’
Package: atiim
atiimThe Area Time Inundation Index ModelPurposeatiimis the Area-Time Inundatation Index Model which was created to address the challenge of rapidly characterizing spatiotemporally-complex inundation patterns in dynamic systems, such as estuarine tidal-fluvial environments.InstallatiimpipinstallatiimCheck out a quickstart tutorial to runatiimRunatiimusing the quicktart tutorial:atiimQuickstarterGetting startedNew toatiim?  Get familiar with whatatiimis all about in ourGetting Starteddocs!User guideOur user guide provides in-depth information on the key concepts ofatiimwith useful background information and explanation.  See ourUser GuideContributing toatiimWhether you find a typo in the documentation, find a bug, or want to develop functionality that you think will makeatiimmore robust, you are welcome to contribute! See ourContribution GuidelinesAPI referenceThe reference guide contains a detailed description of theatiimAPI.  The reference describes how the methods work and which parameters can be used.  It assumes that you have an understanding of the key concepts.  SeeAPI Reference
Package: atila-atlas
AtlasA search engine for the internet.Atlas stands for Atila's Tool for Learning any Subject.
To start, Atlas will be focused on effectively indexing and searching crypto and web3 related
content with plans to add other subjects in the future.
However, you're welcome to use Atlas to index and search any type of content you want.Installationpip install atila-atlasSet your environment variables:exportATLAS_ALGOLIA_APPLICATION_ID=""exportATLAS_ALGOLIA_API_KEY=""exportATLAS_ALGOLIA_INDEX_NAME=""Development Installationsourceinstall.sh
pipinstall-e.Quickstartatlasinitialize_index
atlasadd_content--filedata/urls_to_parse.txt
atlasadd_content--urlshttps://ethereum.org/en/nft,https://en.wikipedia.org/wiki/Ethereum
atlassearch"what is an nft"atlasget_inbound_links--min-inbound-links=2fromatlas.content_parserimportContentParser,ContentIndexsample_urls=["https://ethereum.org/en/nft","https://en.wikipedia.org/wiki/Ethereum","https://linda.mirror.xyz/df649d61efb92c910464a4e74ae213c4cab150b9cbcc4b7fb6090fc77881a95d","https://chain.link/education/nfts","https://medium.com/superrare/no-cryptoartists-arent-harming-the-planet-43182f72fc61","https://andrewsteinwold.substack.com/p/-quick-overview-of-the-nft-ecosystem","https://medium.com/superrare/no-cryptoartists-arent-harming-the-planet-43182f72fc61"]content_bot=ContentParser(urls=sample_urls)content_bot.parse_all_content()content_bot.save_to_file()content_index=ContentIndex()content_index.initialize_index()results=content_index.search("what is an nft")Development QuickstartNote: Make sure you've put your environment variables into the newly created.envfile that was taken fromshared.env# 1. Parse and index your content:pythonatlas/content_parser.py# 2. Initialize your content:pythonatlas/content_index.py# 3. Run the APIpythonapi/api.py# 4. Send a GET request to your apicurl--location--requestGET'http://127.0.0.1:8080/api/search?q=what+is+an+NFT'# or open your browser to `http://127.0.0.1:8080/api/search?q=<your_search_term>`Publishing Package to PyPipython -m buildUploading to test PYPi server first to practice:python -m twine upload --repository testpypi dist/*Note the use of no-dependencies flag:--no-deps. This is because the dependencies might not be in the TestPyPiSet your username to__token__Set your password to the token value, including the pypi- prefixTest:https://test.pypi.org/manage/account/#api-tokensProd:https://pypi.org/manage/account/#api-tokensUpload to the real PyPI server:python -m twine upload dist/*TroubleshootingModuleNotFoundError: No module named 'atlas'Set your $PYTHONPATH. See thisSO answer
Package: atilla
AtillaAtilla (the API Utilities Library) contains a number of useful functions that are common between flask projects for
HTTP API applications. This includes types, validators, functions for creating applications,
etc. This library will make setting up new projects a lot faster.InstallationpipinstallatillaDocumentationDetailed python API you can find in thedocumentation.ContactIf you have questions, bug reports, suggestions, etc. please create an issue on
theGitHub project page.LicenseThis software is licensed under theMIT licenseSeeLicense file© 2015 Paylogic International and others.Changelog1.2.6Fix vnd_error_response returning aResponsewith wrongResponse.headerstype (youtux)Require flask version < 0.11, otherwise atilla won’t work.Make a test pass also with the latest halogen version1.2.4accept remote address as host name if not passed by config (bubenkoff)1.2.3handle unauthorized requests correctly (bubenkoff)1.2.2correctly handle exception message (bubenkoff)1.2.1python3 support fixes (bubenkoff)1.2.0Initial public release (bubenkoff)Use flask-cache for request rate logging (bubenkoff)Add well-defined configuration defaults (bubenkoff)Code readability improvements (bubenkoff)Better test coverage (bubenkoff)1.1.10Amended the previous fix and made the status code for commits configurable (hvdklauw)1.1.9Fixed transaction only being committed on 200 OK responses (olegpidsadnyi, hvdklauw)1.1.8Wider catch of werkzeug exceptions for halogen URI type deserialization (bubenkoff)1.1.7Correctly handle deserialization errors inatilla.ext.halogen.types.URI(bubenkoff)1.1.6Initial release
Package: atilo
python-atiloInstall linux on termux.atilowritten in python.InstallationpipinstallatiloUsageShow available releases$atilolist
nameversionalpine2.73.9centos7debianjessiestretchbusterfedora30kaliparrotubuntutrustyxenialbionicShow installed releases$atilolist--installed
alpine3.9
debianbusterInstall a release# Install the latest debian releaseatiloinstalldebian# Install specified debian releaseatiloinstalldebianjessieRun a release# Start the debian jessie releasestartdebianjessieRemove a releaseatilodebianbusterClean temp filesatilocleanContributePrerequisitePython >= 3pipenvRequirementspipenvinstall--devRunpythonrun.pyGenerate Changelog (For Maintainers Only)Install python toolauto-changelogto generate changelog.sudopip3installgit+https://github.com/Michael-F-Bryan/auto-changelogGenerate and write changelog toCHANGELOG.md.auto-changelogBump Version (For Maintainers Only)sudopip3installcommitizenUsingcommitizentool to generate semantic version number.$czbump[NO_VERSION_SPECIFIED]Checkifcurrentversionisspecifiedinconfigfile,like:version=0.4.3Edit theatilo/__init__.py, set the__version__value to'0.4.3'(semantic version generated above).ChangelogUnreleasedNew Featuresadd command listadd command removeadd command cleanadd atilo.pyFixesprint help when no subcommand specifiedfix extracting errorfix --link2symlink optionfix typoadd --link2symlink option for prootfix dependenciesremove stable version for debianfix check_arch & unarchive
Package: atimer
atimerlibrary implements asynchronous timer Python coroutine based on
POSIX timers. The coroutine can be used with Pythonasynciomodule API.The main features of the timer implemented by the library areexpires at regular intervalsallows to track number of expirations if a long running task causes
overrunstarts synchronized with system clock at the edge of an intervalmeasures time while system is suspendedTheatimerlibrary is licensed under terms of GPL license, version 3, seeCOPYINGfile for details.
Package: atinline
This is a Python hack to let you specify functions as “inline” in much the
same way you’d do in C.  You save the cost of a function call by inlining
the code of the function right at the call site.  Of course, being Python,
the inlining is done at runtime.WARNING:  Don’t use this in any real code.  Seriously.  It’s just a fun hack.Now then, suppose you have some code like this:def calculate(x):
    return 3*x*x - 2*x + (1/x)

def aggregate(items):
    total = 0
    for item in items:
        total += calculate(item)
    return totalThis code pays the overhead of a function call for every item in the collection.
You can get substantial speedups by inlining the calculate function like so:def aggregate(items):
    total = 0
    for x in items:
        total += 3*x*x - 2*x + (1/x)
    return totalBut now you’re paying the costs in terms of code quality and re-use.  To get
the best of both worlds simply declare that the calculate function should be
inlined:from atinline import inline

@inline
def calculate(x):
    return 3*x*x - 2*x + (1/x)

def aggregate(items):
    total = 0
    for item in items:
        total += calculate(item)
    return totalNow the first time the aggregate() function runs, it will detect that the
calculate() function should be inlined, make the necessary bytecode hacks
to do so, then continue on its way.  Any subsequent calls to aggregate()
will avoid the overhead of many function calls.Currently only plain calls of top-level functions are supported; things won’t
work correctly if you try to inline methods, functions looked up in a dict,
or other stuff like this.  It also doesn’t work with keyword arguments.
These limitations might go away in future.The heavy-lifting of bytecode regeneration is done by the fantastic “byteplay”
module, which is atinline’s only dependency.
Package: ativ03-ex
ativ03_exativ03_ex Ã© um simples pacote para armazenar e consultar dados de usuarios (nome, cpf e endereco) adquiridos, feitos para uma atividade.DependenciasPython 3.6 ou posteriorFuncaoModulo interacao: inter(), retorna uma tupla contento as informacoes pedidasModulo armazenamento: armazenar(), armazena as informacoes da tupla retornada da funcao inter do modulo interacao em um arquivo de texto chamado dados_usuario.txtModulo consulta: consultar(), mostra os dados gravados no arquivo dados_usuario.txt
Package: atividades-algoritmos
Este projeto criado para implementação dos algorimos propostos em atividades para a disciplina “Estrutura de Dados e Complexidade de Algoritmos” turma de 2019.1.Abaixo algumas informações de como utilizar este pacote.<br>## Table of Contents[Requisitos](#requisitos)[Instalação](#instalação)[Utilização](#utilização)# Requisitos
# Instalação
# Utilização