Saravanan666/pypi-org huggingface dataset:
Package: laika-lib
Laikalaikais a business reporting library that allows you to request data from different sources and send it to someone or save it at some destination. For example: you can query your database, send the result as an excel attachment via email and save it on Google Drive or Amazon S3.Check out the documentation atreadthedocs.Laika was tested on Python 2.7 and 3.5 or higher.InstallationYou can install it directly usingpip:$pipinstalllaika-libYou can specify extra dependencies. To find out what dependencies you need to install, check out reports and results documentation. For example, to install libraries to use Google Drive and Amazon S3 in your reports you must run:$pipinstalllaika-lib[drive,s3]Usagelaika.pyis a script that lets you use laika library. You can run it like this:$laika.pysome_reportThis command will run the report namedsome_report. This report must be defined in some configuration file. By default laika looks forconfig.jsonin the same directory. You can specify a custom config passing-cparameter:$laika.py-cmy_config.jsonPath to configuration file can also be specified with theLAIKA_CONFIG_FILE_PATHenvironment variable:$exportLAIKA_CONFIG_FILE_PATH='/home/me/my_config.json'$laika.pymy_reportAnother parameter you can use is--pwdwhich serves for specifying working directory. It can also be specified in configuration file orLAIKA_PWDenvironment variable.ArgumentsYou can check all the predefinedlaika.pyarguments with--help.Undefined arguments will be added to report's definition overwriting default values. Thus, if for example the configuration formy_reportdefines fieldmy_fieldwith valuefoo, if you execute it like this:$laika.pymy_report--my_fieldbarmy_fieldconfiguration will containbaras value.TestingTo run test, you must install test dependencies:$pipinstalllaika-lib[test]Then, run test from laika directory:$cdpath/to/laika
$python-munittestdiscover
Package: laileoulacuisse
# The Wing or the ThighThis app creates a tray icon for an easy access to information
about this week’s menus of user’s favourite restaurants.It is written in Python 3, GUI is powered by GTK+ 3.## Installation$ pip install –egg [–user] laileoulacuisse(unfortunately fails without–egg)Then you can find the app in your applications menu (Internet section),
or run it manually as$ laileoulacuisse.## Under the hoodFetching algorithms are written as plugins in thefetcherdirectory.
They make use ofurllib.request, so fetching online data is easy,
cookie-aware connection is used by default.
Fetchers parse HTML, XML and even Word (using external program Antiword)
documents usinglxml.etree, mainly by the means of XPath.
New/modified XPath queries can be easily tested online athttp://videlibri.sourceforge.net/cgi-bin/xidelcgi.
Package: lain
lainlain is a DevOps solution, but really, it just helps you with kubectl / helm / docker.Installation / AdoptionThe recommended way to use lain is tomaintain an internal fork for your team, this may be too much, you can still try out lain with the following steps:Install from PyPI:pip install -U lainWrite cluster values, according to docshere, and exampleshere, so that lain knows how to talk to your Kubernetes clusterSetCLUSTER_VALUES_DIRto the directory that contains all your cluster valuesStart using lainLinksDocumentation (Chinese):lain-cli.readthedocs.io
Package: lain-shorten
lain.la-link-shortenerURL Shortener using s.lain.la API.Requirementsrequestsis used to send the API request.pyperclipis used to copy the link to the clipboard.If you want to build this on your own, you can install the requirements withpipinstall-rrequirements.txtor install the package by runningpipinstalllain-shortenPython's nativere(used to check validity of the url),argparse(parse return request and set command argument) andsetuptools(used to build the script) packages are also used.How it workss.lain.lacan shorten URLs using curl. I tend to forget the curl syntax and arguments quite easily, so I made a Python package to streamline things. Below is the aforementioned curl command.curl -X POST -d 'url=https://yoururlhere.com' https://s.lain.laI just wrapped it inside Python and added validation to check for links and copied the return address to clipboard for ease of use.You can run the script withlain-shorten<your-url-here>I added support for links not starting with http/https as well.
Package: lain-upload
lain.la-pomf-uploaderpomf.lain.la uploader.Requirementsrequestsis used to upload the file.pyperclipis used to copy the link to the clipboard.If you want to build this on your own, you can install the requirements withpipinstall-rrequirements.txtor install the package by runningpipinstalllain-uploadPython's nativeos(used to check for file size),argparse(parse return request and set command argument) andsetuptools(used to build the script) packages are also used.How it worksFiles below the file size 1GB can be uploaded topomf.lain.laandpomf2.lain.lamaking necessary API calls tohttps://pomf.lain.la/upload.phpendpoint.I just wrapped it inside said API calls inside Python and added validation to check for size. Links are printed on the terminal and copied to clipboard for ease of use.You can run the script withlain-upload<file-path>You can not upload files bigger than 1 gigabyte.
Package: lair
lairis a small lightweight helper to create eggs
for flask based microservices.Installpip install lairFor details and extra helpers, read the
documentation: https://lair.readthedocs.io/en/latest/In the docs:CLI usagebuilt-in decoratorsbuilt-in BlueprintsExample usage:# This will generate a project directory
# for your new microservice with Flask
lair --project-name my-shiny-project

# This will generate a  project directory
# for your new microservice with Flask and SqlAlchemy,
# and place an example modell in
# project-dir/project_name/models/example.txt
#  to use this as a model just rename from .txt to .py
lair --project-name my-shiny-project --with-db
Package: lairgpt
LairGPTA Python package in Pytorch byLightOn AI Researchthat allows to perform inference
withPAGnol models.
You can test the generation capabilities of PAGnol on ourinteractive demo website.InstallRequirementsThe package is tested with Python 3.9. After cloning this repository, you can create acondaenvironment
with the necessary dependencies from its root byconda env create --file=environment.ymlIf you prefer control on your environment, the dependencies arepytorch==1.8.1
tokenizers==0.10
python-wget==3.2pipSimply runpip install .from the root of this repository.Text generationThe simplest way to generate text with PAGnol usinglairgptisfrom lairgpt.models import PAGnol

pagnol = PAGnol.small()
pagnol("Salut PAGnol, comment ça va ?")We include a demo scriptmain.pyin this repository that takes the path to models and tokenizers, and an input text, and generates sentences from it.
To use it:python main.py --size large --text "LightOn est une startup technologique"To generate text we rely on theinfermethod of theTextGeneratorclass that takes the usual parameters:mode: (default:"nucleus")"greedy": always select the most likely word as its next word."top-k":  filter to the K most likely next words and redistribute the probability mass among only those K next words."nucleus": filter to the smallest possible set of words whose cumulative probability exceeds the probabilitypand redistribute the probability mass among this set of words.temperature: a control over randomness. As this value approaches zero, the model becomes more deterministic. (default:1.0)k: size of the set of words to consider for "top-k" sampling (default:5)p: a control over diversity in nucleus sampling. A value of 0.5 means that half of the options are considered. (default:0.9)max_decoding_steps: number of tokens to generate. (default:32)skip_eos: whenTrue, generation does not stop at end of sentence. (default:True)More on LightOnLightOn is a company that produces hardware for machine learning.
To lease a LightOn Appliance, please visit:https://lighton.ai/lighton-appliance/To request access to LightOn Cloud and try our photonic co-processor, please visit:https://cloud.lighton.ai/For researchers, we also have a LightOn Cloud for Research program, please visithttps://cloud.lighton.ai/lighton-research/for more information.CitationWe will soon have a preprint on arXiv, stay tuned ;)
Package: laituri
laituri — Docker Toolkit for Pythonlaituriis a set of Docker-related Python snippets used atValohai.
You can use it with Python >= 3.7.UsageConfigurationYou can configure your used Docker command if it is not the defaultdocker, using laituri settings.Example:laituri.settings.DOCKER_COMMAND = 'docker'Docker Credential ManagerLaituri contains a docker credentials manager which can be used for example when pulling images.
It logs in and out using the Docker CLI.Example:from laituri.docker.credential_manager import get_credential_manager

my_credentials = {
    'username': 'SmolShark1',
    'password': 'sharksWithLazers',
}

with get_credential_manager(
    image='python:latest',
    registry_credentials=my_credentials,
    log_status=print  # Any callable
):
    # Do your docker things!DevelopmentInstalling editable library version in the current virtual environment.# install this package and all development dependenciespipinstall-e.-rrequirements-dev.txtpip-toolspre-commit&&pre-commitinstall# manually run lint and type checkspre-commitrun--all-files# manually run testspytest--cov

python
>>>importlaituri;print(laituri.__version__)Making a ReleaseA new release build is released by the CI when a new tag is pushed to the repository:# bump version number in "laituri/__init__.py"vimlaituri/__init__.py# pushing a new tag will trigger a new release buildgitadd.
gitcommit-m"Become to X.Y.Z"gittag-avX.Y.Z-m"Version X.Y.Z"gitpush--follow-tagsIf a manual release is needed, you can follow up the above steps with:pipinstallbuildtwine
gitclean-fdx-e.idea/
python-mbuild.
twineuploaddist/*
Package: laiye-python-third-proto
# laiye-python-third-proto
laiye use third proto## 用于第三方的所有的proto打包用于python
目前所需要的第三方有这些
- google/protobuf
- google/api
- github.com/mwitkow/go-proto-validators
- github.com/envoyproxy/protoc-gen-validate/validate
- github.com/grpc-ecosystem/grpc-gateway/protoc-gen-swagger/options## 需要添加在仓库中的有
- github.com/mwitkow/go-proto-validators
- github.com/envoyproxy/protoc-gen-validate/validate
- github.com/grpc-ecosystem/grpc-gateway/protoc-gen-swagger/options其余两个在requirements安装如下
- protobuf==3.6.1
- google-api==0.1.12## 生成第三方的proto的命令` docker run-ti-v`pwd`:/im-saas-msgs-protos-v`pwd`/pbout/python:/im-saas-protos-pythonregistry.cn-beijing.aliyuncs.com/im-saas/protobuf:self-build-latestpython/im-saas-msgs-protos/ci/compile/compile_python_test.py--conf=/im-saas-msgs-protos/ci/env/env_gitlab.json--thirdproto=thirdprotos`生成目录为pbout/python/thirdprotos
Package: laji-auth-client
Laji-auth clientA Python client for Laji-auth authentication portal.Usagefrom laji_auth_client import LajiAuthClient 

client = LajiAuthClient(<laji_auth_url>, <system_id>)
login_url = client.get_login_url()
authentication_info = client.get_authentication_info(<token>)

success = client.log_out(<token>)
Package: lajobsparser
lajobsparserParser for Los Angeles city jobs bulletinsSource code -GithubThe city of Los Angeles (LA) is running aKaggle competionthat uses the
job bulletins for the city of LA jobs.The content, tone, and format of job bulletins can influence the quality of the
applicant pool. Overly-specific job requirements may discourage diversity. The
Los Angeles Mayor’s Office wants to reimagine the city’s job bulletins by using
text analysis to identify needed improvements.The goal is to convert a folder full of plain-text job postings into a single
structured CSV file and then to use this data to:identify language that can negatively bias the pool of applicantsimprove the diversity and quality of the applicant poolmake it easier to determine which promotions are available to employees in
each job classThis project helps parse the job bulletins and associated files.MiscellaneousTo install from github using pipenvpipenv install -e git+https://github.com/gavinln/lajobsparser.git#egg=lajobsparserPush a new version to PyPIChange version number in setup.pyRun testsmake testBuild a distributionmake sdistOpen a browser to PyPI:https://pypi.org/project/lajobsparser/Run twinemake twine
Package: lakai
lakaiLakai is a wrapper aroundLarkthat provides a convenient API.Installation$ pip install lakaiUsageimportlakaigrammar=r"""%ignore /\s+/%import common.INT?atom: INT?!product: atom | product "*" atom | product "/" atom?!sum: product | sum "+" product | sum "-" product"""parser=lakai.from_string(grammar,start="sum")tree=parser.parse("1 + 3 * 2 + 4 / 2")lakai.pprint(tree)Givessum
    sum
        INT: '1'
        PLUS: '+'
        product
            INT: '3'
            STAR: '*'
            INT: '2'
    PLUS: '+'
    product
        INT: '4'
        SLASH: '/'
        INT: '2'To evaluate the expression, you can use alakai.Transformer:importoperatorclassComputer(lakai.Transformer):operators={"/":operator.truediv,"*":operator.mul,"-":operator.sub,"+":operator.add}defvisit_INT(self,leaf:lakai.Leaf)->int:returnint(leaf.value)defvisit_product(self,node:lakai.Node[Any])->int:returnself.operators[node.children[1].value](node.children[0],node.children[2])visit_sum=visit_productassertComputer().visit(tree)==9To use Lakai with a Lark standalone parser:importlakaifrom._standaloneimportLark_Standaloneparser=lakai.Lakai(Lark_Standalone())
Package: lake-aha
lakelake is a framework for generating synthesizable memory modules from a high-level behavioral specification and widely-available memory macros. lake also comprises a library of generalized hardware modules aimed at memory controller designs.Installgit clone github.com/StanfordAHA/lakecd lake && pip install -e .Run a testTo run a test, you can simply generate the verilog and push through your favorite verilog simulator. Alternatively, lake uses the pytest framework for unit tests of constituent modules. These tests leveragefaultandverilatorfor open source simulation. Tests should run and pass on Linux and MacOS.DocumentationCheck out thewikiof this github repo.
Package: lakeapi
Lake APIAPI for accessing Lake crypto market data.Lake is a service providinghistorical cryptocurrency market datain high detail, includingorder book data, tick trades and 1m trade candles. It is tuned for convenient quant and machine-learning purposes and so offers high performance, caching and parallelization.Web:https://crypto-lake.com/Documentation:https://lake-api.readthedocs.io.Online example – executable collab notebook:https://colab.research.google.com/drive/1E7MSUT8xqYTMVLiq_rMBLNcZmI_KusK3UsageIf you don’t have a paid plan with AWS credentials, you can access sample data:importlakeapilakeapi.use_sample_data(anonymous_access=True)df=lakeapi.load_data(table="book",start=None,end=None,symbols=["BTC-USDT"],exchanges=["BINANCE"],)With paid access, you can query any data:importlakeapi# Downloads SOL-USDT depth snapshots for last 2 days from Kucoin exchangedf=lakeapi.load_data(table="trades",start=datetime.datetime.now()-datetime.timedelta(days=2),end=None,symbols=["SOL-USDT"],exchanges=["KUCOIN"],)We recommend putting .lake_cache directory into .gitignore, because Lake API stores cache into this directory in the
working directory.History0.12.0 (2023-11-18)option to disable cacheimproved warnings handling0.11.2 (2023-11-09)fix order book data loading (KeyError: side)0.11.1 (2023-11-06)minor optimizations and fixes in cloudfront transfer0.10.0 (2023-11-06)more efficient optional data transfer implemented via aws cloudfront0.9.1 (2023-11-03)awswrangler dependency removed, pandas 2 support addedpython3.12 support0.8.0 (2023-09-18)grow default cache size limitnicer error messages when data are missingpass and print warning when file is corrupted0.7.0 (2023-09-18)let user specify max cache size vialakeapi.set_cache_size_limit()0.6.4 (2023-08-05)too many open files bugfix0.6.3 (2023-08-03)logging fixes0.6.2 (2023-08-18)fix dependency constraints causingTypeError: _path2list() got an unexpected keyword argument ‘boto3_session’0.6.1 (2023-08-15)fix path2list bugfix type hints0.6.0 (2023-08-14)support for python3.110.5.0 (2023-05-21)support for funding, open_interest and liquidations list_dataimprove data type typing0.4.5 (2023-01-09)grow default cache size limit from 3 GB to 10 GB0.4.3 (2022-12-09)small documentation improvements0.4.2 (2022-12-09)fix trades_mpid issue0.4.1 (2022-12-05)fix warning messages in anonymous mode0.4.0 (2022-11-19)level_1 data added to typings3 user agent set to lakeapi0.3.0 (2022-11-04)Typing bugfixLast modified filters for list_data0.2.0 (2022-10-26)New feature for listing available data.0.1.3 (2022-10-13)Corrupted cache bugfix0.1.2 (2022-10-10)Caching and requirements improvements.0.1.1 (2022-10-09)Python2.7 support and documentation improvements.0.1.0 (2022-10-08)First release on PyPI.
Package: lakeapi2sql
LakeApi 2 SQLThis is a simple library that has currently there methods:insert_http_arrow_stream_to_sqlMake a HTTP Request to an Endpoint from theLake APIand inserts the data via bulk insert into MS SQL Server. In Theory you could also get the data from some other HTTP Endpoint which returns an Arrow Stream and is authenticated using Basic Auth.
It does not guarantee atomicity at sql server level, therefore you will usually want to use a global temp table as target.insert_record_batch_to_sqlSame as above, but the input is a generic RecordBatchReader from pyarrowIt's meant to be used from Python, the Logic is written in Rust.FeaturesYou can specifyAuthentication=ActiveDirectoryMSI|ActiveDirectoryDefault|ActiveDirectoryInteractivein the connection string similar to .Net/ODBC SQL Driver. This requires theazure-identitypackage to be installedRoadmapThere is still a lot todo:Allow passing more flexible HTTP Authentication optionsAdd option to read from database and write to a flat fileDocumentTestAlternativesThis would not have been possible without the excellentarrow-odbc-pylibrary. Use it whenever SQL Server is not the only possible target, or you need to read from a database or you just need something better ;)
Package: lakefs
lakeFS High-Level Python SDKlakeFS High Level SDK for Python, provides developers with the following features:Simpler programming interface with less configurationInferring identity from environmentBetter abstractions for common, more complex operations (I/O, transactions, imports)RequirementsPython 3.9+Installation & Usagepip installpipinstalllakefsImport the packageimportlakefsGetting StartedPlease follow theinstallation procedureand afterward refer to the following example snippet for a quick start:importlakefsfromlakefs.clientimportClient# Using default client will attempt to authenticate with lakeFS server using configured credentials# If environment variables or .lakectl.yaml file existrepo=lakefs.repository(repository_id="my-repo")# Or explicitly initialize and provide a Client objectclt=Client(username="<lakefs_access_key_id>",password="<lakefs_secret_access_key>",host="<lakefs_endpoint>")repo=lakefs.Repository(repository_id="my-repo",client=clt)# From this point, proceed using the package according to documentationmain_branch=repo.create(storage_namespace="<storage_namespace>").branch(branch_id="main")...ExamplesPrint sizes of all objects in lakefs://repo/main~2ref=lakefs.Repository("repo").ref("main~2")forobjinref.objects():print(f"{o.path}:{o.size_bytes}")Difference between two branchesforiinlakefs.Repository("repo").ref("main").diff("twig"):print(i)You can also use theref expressions here, for instance.diff("main~2")also works.  Ref expressions are the lakeFS analogues ofhow Git specifies revisions.Search a stored object for a stringwithlakefs.Repository("repo").ref("main").object("path/to/data").reader(mode="r")asf:forlinf:if"quick"inl:print(l)Upload and commit some datawithlakefs.Repository("golden").branch("main").object("path/to/new").writer(mode="wb")asf:f.write(b"my data")# Returns a Referencelakefs.Repository("golden").branch("main").commit("added my data using lakeFS high-level SDK")# Prints "my data"withlakefs.Repository("golden").branch("main").object("path/to/new").reader(mode="r")asf:forlinf:print(l)Unlike references, branches are readable.  This example couldn't work if we used a ref.TestsTo run the tests usingpytest, first clone the lakeFS git repositorygitclonehttps://github.com/treeverse/lakeFS.gitcdlakefs/clients/python-wrapperUnit TestsInside thetestsfolder, executepytest uteststo run the unit tests.Integration TestsSeetesting documentationfor more informationDocumentationlakeFS Python SDKAuthorservices@treeverse.io
Package: lakefs-playground-utils
lakeFS Playground UtilitiesUsing in a notebook:>>>!pipinstalllakefs-playground-utils# Syntax used in Google Colab, might be different for Jupyter, Databricks, etc.>>>>>>importplayground>>>conn=playground.get_or_create('myemail@example.com')# Creates a lakeFS playground environment, or returns an existing one>>>playground.mount(conn)# Sets up a `lakefs://` protocol handler for pandas, pre-configured to read+write from our playground environmentOnce set up, we can use pandas to read and write from a lakeFS repository on our playground installation:>>>importpandasaspd>>>pd.read_parquet('lakefs://repo/branch/path/to/part-00000.snappy.parquet')LicenseApache 2.0SeeLICENSE
Package: lake-loader
Datalake LoaderCode underlake-loaderconsumes and transforms data from various online platforms and save them into azure datalake
storage.Runtime StagesThis code has 4 runtime stages:local_local,local_remote,remote_dev, andremote_prod.Local_LocalThis runtime stage uses localhost spark; it consumes data from local kafka and writes the consumed data directly to
console. This runtime setting doesn't rely on any azure computing services. To run this stage, first follow
theREADME.mdfile underprojects/local-setupto set up local development environment.TelegramTo run telegram, first copylake-loader/sample_env_files/local_local.env.sampletolake-loader/.envand modify the
file accordingly. Then, underlake-loaderrunsource .envto export all environmental variables.Next run the following:poetry run main telegramLocal_RemoteThis runtime stage uses localhost spark that connects to remote kafka and remote adls storage. It consumes data from
azure eventhub kafka and writes to azure datalake storage. To run this stage, first obtain azure credentials for
eventhub and adls gen 2.TelegramTo run telegram, first copylake-loader/sample_env_files/local_remote.env.sampletolake-loader/.envand modify the
file accordingly to fill out missing credentials. Then, underlake-loaderrunsource .envto export all
environmental variables.Next run the following:poetry run main telegramRemote_DevThis runtime stage runslake-loaderon databricks. First, fill out variables
fromlake-loader/sample_env_files/remote_dev.env.sampleand then copy the variables to databrick's computing cluster.
SeeSpark configuration. Next,
runpoetry buildunderlake-loaderto build a wheel. The wheel is underlake-loader/distfolder and has the
namelake_loader-x.y-py3-none-any.whl. Next, create and run a
databricksjobby uploading the wheel. See the following image to fill out the relevant fields. Note that if a wheel is updated, the old wheel needs to be removed from the computing cluster's libraries..SchemaSpark uses json schema when transforming raw data. The schema generation process is currently outside thelake-loaderrepo. Using telegram as an example, we first capture a hundred of raw telegram messages. We then use the telegram parser to transform the raw data into gold data. Next, we use spark to read the batch of transformed gold data to infer their schema. The schema is then written to file and dropped off tolake-loader/schema/. When the telegram parser is updated, the schema may also need to be updated (e.g.schema/telegram_v1.jsonneeds to updated toschema/telegram_v2.json.