Saravanan666/pypi-org huggingface dataset:
Package: lobster-tools
Getting startedInstall$pipinstalllobster-toolsHow to usedata=Data(ticker="AMZN",date_range="2012-06-21",load="both")lobster=Lobster(data=data)/nfs/home/nicolasp/anaconda3/envs/lob/lib/python3.11/site-packages/lobster_tools/preprocessing.py:320: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise in a future error of pandas. Value '[]' has dtype incompatible with int8, please explicitly cast to a compatible dtype first.
  df.loc[df.event.eq(Event.ORIGINAL_TRADING_HALT.value), "event"] = df.loc[lobster.messages.head()timeeventorder_idsizepricedirectiondatetime2012-06-21 09:30:00.01745961734200.017460501223.82-12012-06-21 09:30:00.18960767034200.18960811188511321223.8112012-06-21 09:30:00.18960767034200.1896081391137620223.96-12012-06-21 09:30:00.18960767034200.189608111534792100223.7512012-06-21 09:30:00.18960767034200.1896081136537313224.00-1lobster.book.head()ask_price_1ask_size_1bid_price_1bid_size_1ask_price_2ask_size_2bid_price_2bid_size_2ask_price_3ask_size_3bid_price_3bid_size_3ask_price_4ask_size_4bid_price_4bid_size_4ask_price_5ask_size_5bid_price_5bid_size_5datetime2012-06-21 09:30:00.017459617223.95100.0223.18100.0223.99100.0223.07200.0224.00220.0223.04100.0224.25100.0223.0010.0224.40547.0222.62100.02012-06-21 09:30:00.189607670223.95100.0223.8121.0223.99100.0223.18100.0224.00220.0223.07200.0224.25100.0223.04100.0224.40547.0223.0010.02012-06-21 09:30:00.189607670223.95100.0223.8121.0223.9620.0223.18100.0223.99100.0223.07200.0224.00220.0223.04100.0224.25100.0223.0010.02012-06-21 09:30:00.189607670223.95100.0223.8121.0223.9620.0223.75100.0223.99100.0223.18100.0224.00220.0223.07200.0224.25100.0223.04100.02012-06-21 09:30:00.189607670223.95100.0223.8121.0223.9620.0223.75100.0223.99100.0223.18100.0224.00233.0223.07200.0224.25100.0223.04100.0(lobster.messages.query(f"event =={Event.HIDDEN_EXECUTION.value}").query(f"direction == -1").head())timeeventorder_idsizepricedirectiondatetime2012-06-21 09:30:00.01745961734200.017460501223.82-12012-06-21 09:30:00.37277967234200.37278050100223.84-12012-06-21 09:30:00.37567120534200.37567150100223.84-12012-06-21 09:30:00.38397136634200.38397150100223.86-12012-06-21 09:30:00.38581571034200.38581650100223.86-1
Package: loc
Welcome tolocDocumentationlocis a library that simplify the software localization.Usage:>>>fromlocimportLocDict>>>data=[{"en-US":"Yes","zh-CN":"是"},{"en-US":"No","zh-CN":"否"},]>>>ld=LocDict(data=data)>>>ld.trans_to("Yes",dst_loc="zh-CN")是Installlocis released on PyPI, so all you need is:$pipinstalllocTo upgrade to latest version:$pipinstall--upgradeloc
Package: loca
Local locations for PythonIt's mi vida loca.Loca is a highly opinionated redesign ofappdirs.  It relies onpathlib,dataclassesand@propertyto replace most of the parameters in
the original library to create a more intuitive API.UsagefromlocaimportLocaloca=Loca()assertloca==loca.user.data==loca.data.userassertloca.state()==loca.user.state()assertloca.config==loca.user.configassertloca.cache()==loca.cache.user()shared=loca.sharedassertshared==loca.shared.data==loca.data.sharedfoobar_shared_config=shared.config()/'foobar'ContributingPatches must pass the checks run bytoxand should be sent to~cnx/misc@lists.sr.htusinggit send-email,
with the following configurations:git config sendemail.to '~cnx/misc@lists.sr.ht'
git config format.subjectPrefix 'PATCH python-loca'CopyingLoca is free software: you can redistribute it and/or modify it
under the terms of the GNULesser General Public Licenseas
published by the Free Software Foundation, either version 3 of the License,
or (at your option) any later version.
Package: locache
locache- a local cache for PythonA single-file utility library for caching the results of deterministic and pure function calls to disk, exposed via the@persistdecorator.These caches are persistent across runs of the program. If changes to the function's source code are detected, the cache is reset. This can also be manually performed with theresetfunction.Installationlocacheis simple enough that you could have written it yourself. To use it in your project, either:copy thelocache.pyfile into your projectinstall it withpip install locacheUsagelocacheprovides 3 importable functions:the@persistdecoratorresetverbose@persistWrap a pure function with@persistto cache its results to disk. The only stipulation is that the function's arguments and return value must be pickle-able.fromlocacheimportpersist@persistdefmy_func(x,num=3):print("Hi from foo!")returnx*nummy_func(1)# prints "Hi from foo!", returns 3my_func(2,num=2)# prints "Hi from foo!", returns 4my_func(1)# returns 3reset(func: Callable)Reset the cache for a given function.fromlocacheimportresetreset(my_func)my_func(1)# prints "Hi from foo!", returns 3verbose(yes: bool = True)Turn on verbose logging.fromlocacheimportverbosereset(my_func)verbose(yes=True)my_func(1)# prints "cache miss for squared(1)"# prints "Hi from foo!"# returns 3my_func(1)# prints "cache hit for squared(1)"# returns 3
Package: local
localTo browse local files.Installationpip install -U localUsageusage: local [options]

optional arguments:
  -h, --help       show this help message and exit
  -v, --version    show version number and exit.

to browse local files:
  keys             keyword to search
  -p , --path      root path
  -n, --no-prompt  do not interactively prompt for choicePython ScriptTo browse local files.fromlocalimportLocalloc=Local("../path").search("key","words")loc.display()# to display resultsloc.open("category-index")# to open specified file/folderCommand LineTo browse local files.$ local "key" "word" --path "/"
### matched results ###Issues:If you encounter any problems, please file anissuealong with a detailed
description.
Package: localagi
Local AGI (Artificial General Intelligence)Welcome to the Local AGI package! This is a fun project that simulates an Artificial General
Intelligence (AGI) running locally on your machine.What is AGI?AGI is a type of artificial intelligence that has the ability to understand, learn, adapt, and
implement knowledge in a wide range of tasks, much like a human being. It's the holy grail of AI
research, aiming to create a machine with the ability to perform any intellectual task that a human
being can do.Running localagiImport the package throughpip install localagi, and run it directly from the terminal by typinglocalagi:pip install localagi

    localagiEnjoy your journey with Local AGI!Running through the terminal is the intended way to use Local AGI, but you can also use the Python
API as such:importlocalagilocalagi.load()question="What is the meaning of life?"response=localagi.prompt(question)
Package: localai
🔥 PⒶutoBot 🔥Private AutoGPT Robot- Your private task assistant with GPT!🔥Chatto your offlineLLMs on CPU Only.100% private, no data leaves your execution environment at any point.🔥Ask questionsto your documents without an internet connection. Engine developed based onPrivateGPT.🔥Automate taskseasily withPAutoBot plugins. Easy for everyone.🔥Easy coding structurewithNext.jsandPython. Easy to understand and modify.🔥Built withLangChain,GPT4All,Chroma,SentenceTransformers,PrivateGPT.The supported extensions are:.csv: CSV,.docx: Word Document,.doc: Word Document,.enex: EverNote,.eml: Email,.epub: EPub,.html: HTML File,.md: Markdown,.msg: Outlook Message,.odt: Open Document Text,.pdf: Portable Document Format (PDF),.pptx: PowerPoint Document,.ppt: PowerPoint Document,.txt: Text file (UTF-8),I. Installation and Usage1. InstallationPython 3.8 or higher.InstallPAutoBot:pipinstallpautobot2. UsageRun the app:python-mpautobot.appor just:pautobotGo tohttp://localhost:5678/to see the user interface. You can choose one of the two modes:Chat OnlyDocuments Q&AUpload some documents to the app (see the supported extensions above). You can trydocs/python3.11.3_lite.zipfor a quick start. This zip file contains 45 files from thePython 3.11.3 documentation.Force ingesting documents withIngest Databutton.You can also run PAutoBot publicly to your network or change the port with parameters. Example:pautobot--host0.0.0.0--port8080II. Development1. Clone the source codegitclonehttps://github.com/nrl-ai/pautobotcdpautobot2. Run your backendPython 3.8 or higher.To install Pautobot from source, frompautobotsource code directory, run:pipinstall-e.Run the app:python-mpautobot.appGo tohttp://localhost:5678/to see the user interface.2. Run your frontendInstall the dependencies:cdfrontend
npminstallRun the app:npmrundevGo tohttp://localhost:3000/to see the user interface. Use this address to develop the frontend.
Package: localalias
Don’t kill your fingers by typing out long commands! Local aliases can help you achieve a whole
new level of lazy!DemonstrationNOTE: This demonstration uses thehelper function,la, in place of the standardlocalaliascommand.Descriptionlocalalias isa light-weight shell wrapper that allows you to create per-directoy command
aliases.With bash/zsh, once an alias is set, it cannot be reused. If you want to define a new command using
an alias, you have to choose a new alias name. This forces you to define many aliases, some of them
with very obscure names that you will never remember. localalias solves this problem by
providing an additional level of abstraction to your shell’s default alias design scheme.Local aliases allow you to abstract away from whatever project you are working on, by giving you
the ability to setup generic aliases for what are, in actuality, very specific tasks. In my own
setup, for example, I aliasrto the command that launches the project I am working on. When in
the top-level directory of the localalias project directory, runningris equivalent topython localalias.  If I change directories, however, to work on a different project, runningrwill run a different command—one corresponding to the new project.  I use multiple patterns
like this to simplify my own workflow:truns the tests,bbuilds the project,vopens
up files invim.[1][1]I normally use multiple variations of this last one:vopens up the most active files
(the ones I am most likely to want to edit),vtopens up test files,vdopens up doc
files, etc..DocumentationFor more information, please refer to this project’s officialdocumentation.There you will also find instructions forinstallationand tips for generalusage.
Package: localaplace
Install$ pip install localaplaceThis is an implement of Local Laplace Filter algorithm [1]  [Paper]. Just see the effect below.Image modalOriginalEnhancedRGB (800 × 533)RGBA (600 × 460)CT (3072 × 3072)This is a boring code when I attempt to finish my computer vision homework, but no available python package is found on PyPiUsageDemo is as follows, the only function islocal_laplace_filter(Please see my detailed comment of the function to see the meaning of arguments):importosimportcv2importlocalaplaceasllpimage=cv2.imread('./images/flower.png',cv2.IMREAD_UNCHANGED)result=llp.local_laplace_filter(image,0.2,0.5,0.8,100,num_workers=-1,verbose=1,return_layers=False)# save result to diskifnotos.path.exists('results'):os.makedirs('results')cv2.imwrite('./results/flower_enchanced.png',result)If you are interested in the Laplace Pyramid, setreturn_layersasTrueto get layers:result,layers=llp.local_laplace_filter(image,0.2,0.5,0.8,100,num_workers=-1,verbose=1,return_layers=True)# save inner layers to diskfori,layer_imageinenumerate(layers):cv2.imwrite(f'./results/layer_{i+1}.png',layer_image)Reference[1] Paris, Sylvain, Samuel W. Hasinoff, and Jan Kautz. "Local Laplacian filters: edge-aware image processing with a Laplacian pyramid." Communications of the ACM 58.3 (2015): 81-91
Package: localbitcoins-sdk
localbitcoins-sdkA simple library for working with LocalBitcoins APII created this library to make it easier to use theLocalBitcoins API.
The library is very simple.
It has just one objectClient, with one custom methodsend_request.How to use it?Install itpipinstalllocalbitcoins-sdkUse it# Import the Clientfromlb_sdkimportClient# Create a Client object with the hmac key and the hmac secret from localbitcoins.client=Client('your-hmac-key-here','your-hmac-secret-here')# Send a request and get a response data.data=client.send_request('/api/myself/')# By default the client uses the get request method, but you can send a post request.data=client.send_request('/api/logout/','post')# Or you can send a request with any parameters.params={'trade_type':'LOCAL_SELL','currency':'RUB','countrycode':'RU',}data=client.send_request('/api/ads/',params=params)
Package: local-candles
Local candlesUsage example:fromlocal_candlesimportload_candlesdefmain():df=load_candles(source="binance_usdm_futures_ohlc",start_ts="2021-01-01",stop_ts="2021-02-01",interval="1d",symbol="BTCUSDT",)print(df)if__name__=="__main__":main()
Package: localcat
LocalCatLocalCatis designed to make the LLM strategy easy to implement. It provides a simple API and an intuitive interface for loading, fine-tuning, and deploying large deep learning models. With LocalCat, you can easily fine-tune pre-trained models on your own data and leverage their power for your specific tasks.TasksTranslationLocalCat offers user-friendly tools for translation tasks, allowing the translator to be deployed as an endpoint or for batch processing of dataframes. Additionally, it provides fine-tuning capabilities for local deployment.LocalCat's intuitive interface and efficient processing make it a valuable asset for any translation project. With its advanced features and customizable options, users can easily tailor their translations to meet specific requirements and ensure accuracy. Whether you're working on a small document or a large dataset, LocalCat has the tools you need to streamline the translation process and achieve high-quality results.ChatRetrieval Augmented Generation (RAG)Localcat specializes in open-source LLMs and RAG for local deployment. Localcat offers a wide range of solutions for local deployment, including custom configurations and expert support for seamless integration. With a focus on user-friendly interfaces and scalable performance, Localcat is the ideal choice for organizations looking to optimize their LLMs and RAG processes.Installpipinstalllocalcat
Package: local_chamber
local-chamberWorkalike alias of secrets managerhttps://github.com/segmentio/chambersubstituting local directory for AWS SSM ParameterStoreFree software: MIT licenseDocumentation:https://local-chamber.readthedocs.io.CreditsThis package was created with Cookiecutter andrstms/cookiecutter-python-cli, a fork of theaudreyr/cookiecutter-pypackageproject template.audreyr/cookiecutteraudreyr/cookiecutter-pypackagerstms/cookiecutter-python-cli
Package: localchat
localchatLocalchat is a python library that helps setup server side and client side scripts of a Local Area Network Group Chat in no time.
This library makes it very easy to share messages to all the devices connected on the same LAN.InstallationUse the package managerpipto install localchatpipinstalllocalchatRequirementsPython 3 - Downloadheresocket library (pre-installed with python package)threading library (pre-installed with python package)Usageimportlocalchatlocalchat.help()Calling help will list out all the details of the library.localchat :: python library for quickly writing server and client side programs for a Chat Group on LAN
    Follow the below instructions to use this library

    Localchat library is pre-initialized with the following values of the GLOBAL variables
    PORT (port number) = 9999,                    FORMAT (encoding format) = 'utf-8'
    DISCONNECT_MSG (client disconnects on typing this message) = '!CONNECT'     
    HEADER (buffer size to send the size of the message) = 64
    
    1. initialize(port,format,header,disconnect_msg)    -   to change any of the pre-initialized global variables
                                                            (should be same for server and client)
                                                            
    2. start_server()   -   binds the server with its (IP, PORT) and gets ready to accept multiple clients requests,
                            receive messages and broadcast the messages to all the client available
    
    3. start_client(server_ip)   -   connects the client with the server ipv4 address provided and gets ready to send
                                     and receive messages concurrently
    
    4. send_message(client, message)   -    server can send the message to the client OR
                                            client can send message to the connected server       
    
    5. receive_msg(client)  -   server can receive message from the client OR
                                client can receive message from the connected server
    
    6. broadcast(message)   -   server broadcasts the message to all the available clients(ALL_CLIENTS)
    
Will be adding new features soon ...Sample Server Side Codeimportlocalchatlocalchat.initialize(port=9090,format='utf-8',disconnect_msg='disconnect')localchat.start_server()Sample Client Side Codeimportlocalchatlocalchat.initialize(port=9090,format='utf-8',disconnect_msg='disconnect')server_ip='111.111.11.11'# for example# ipv4 address of the server system (see below to find ipv4 address)localchat.start_client(server_ip)How to find IPv4 address of any systemrun ipconfig command in command-promt and copy the IPv4 address under theWireless LAN adapter Wi-Fisection$ipconfigNoteThe following arguments of the server and the client SHOULD BE SAME during.initializeTheportnumberThe message encodingformatThedisconnect_msgTheheader(variable to send the size of the message)ContributionsYou are welcome to contribute via pull requests onGitHubVersionStable Version - 1.1.0LicenseMIT
Package: localci
local-ciMakes local CI with Python, npm, and Java easy. Integrated with custom docker registry.DependenciesFor buildingarm/v8images:sudo apt-get install qemu binfmt-support qemu-user-staticInstallationpip install localciUsageUsage:localci pythonfor building a Docker image of a Python application.localci pypifor publishing a package to the pypi repository.localci npmfor building a Docker image of an Angular applicationlocalci mvnfor building a Docker image of a Java/Maven application
Package: localcider
version 0.1.21 - May 2023IntroductionlocalCIDERis a Python package developed by the lab ofRohit Pappu at Washington University in St. Louisfor calculating and plotting parameters associated with intrinsically disordered proteins (IDPs) and disodered regions (IDRs).localCIDERis the Python backend forCIDER, (Classification ofIntrinsicallyDisorderedEnsembleRegions) - a webserver for the calculation of many of those same properties. Essentially, localCIDER lets you run CIDER’s calculations locally, allowing you to create custom analysis pipelines which do not rely on the webserver. It also allows you to take advantage of your own local computing hardware, rather than competing with everyone else for a common set of hardware provided by the Pappu lab.This project was motivated by the need to rapidly and easily calculate the κ (kappa) parameter, as defined in the 2013 Das & Pappu PNAS paper [1], as well as provide a tool to easily plot a sequence on the diagram-of-states;The original method for calculating κ involved an incredibly computationally expensive Monte Carlo step (used to determine the maximally segregated sequence), whereas localCIDER makes use of a newly developed algorithm that computes κ in O(1) time. More generally, localCIDER provides a wide range of sequence analysis routines for understanding, classifying, and designing disordered proteins. Beyond charge-based parameters, a wide range of additional parameters can also be calculated.localCIDERrepresents an ideal tool for the construction of a high-throughput sequence analysis pipelines, and we believe provides a direct route to explore the sequence-to-ensemble relationship of IDPs.For more information pleasesee the full documentation.InstallationTo install runpip install localciderWe strongly recommend using acondaenvironment (or avirtualenv) to install localcider. Note that localcider requiresnumpy,scipy, andmatplotlibto run.Usage, bugs, and questionsPlease see thesee the full documentationfor usage guidelines. Please address all questions and bug reports toAlexand he’ll do his best to get back to you!AboutlocalCIDERwas written by Alex Holehouse and James Ahad in thePappu Lab. Please cite localCIDER (and CIDER) as:A.S. Holehouse, R.K. Das, J.N. Ahad, M.O.G. Richardson, R.V. Pappu (2017) CIDER: Resources to analyze sequence-ensemble relationships of intrinsically disordered proteins. Biophysical Journal, 112: 16-21Also, make sure to cite the various studies used if you use analyses that make use of other datasets (e.g. PPII propensity, charge patterning, proline patterning, hydrophobicity etc.).References[1]Conformations of intrinsically disordered proteins are influenced by linear sequence distributions of oppositely charged residuesR.K. Das & R.V. Pappu (2013) PNAS110, 33, pp13392–13397.
Package: local-ci-hooks
Local CI HooksThis script adds Git hooks to your repository to run the tests automatically
while pushing commits to your remotes. The idea is to avoid pushing broken
code to your remotes, automatising the process of verification.Installationpipinstalllocal_ci_hooksUsageRun the script in a repository:local_ci_hooks--installThis will install the pre-push hook for you. Also, it will create a file
named.local_ci.shwith a dummy test. You can set your test commands
in this file.To uninstall the hook:local_ci_hooks--uninstallExample scriptsFor modifying the CI, please, take into consideration the following.local_ci.shexample files.NodeJS:#!/bin/bashnpminstall||exit1npmruntest||exit1exit0Python:#!/bin/bashpipinstall--prefix./build.||exit1exportPATH="./build/bin:$PATH"exportLD_LIBARY_PATH="./build/lib:$LD_LIBRARY_PATH"pytest.||exit1pipuninstall<yourproject>exit0Version: 0.1.1
Package: localcloud
localcloud- CLI tool allowing to imitate cloud components locally for testing their integration.UsageClone code repositories into working directory and runlocalcloud, which will read
Terraform configuration from all of the repositories and will locally create their
imitations (using docker containers and mocks). Now you should have all of the resources
working locally and you should be able to run integration tests on them, e.g.make run_integration_tests.RoadmapAdd Lmabda supportAdd SQS supportAdd EventBridge supportAdd generic resource mock, which allows to define interface wrappings.Developmentmake venv- will create virtual env with dev dependencies.make check- will run Flake8, MyPy and PyTest checks.Related projectsThis tool was inspired by:https://localstack.io
Package: local-cname
This is a little helper script to emulate a local CNAME DNS by writing to/etc/hosts.
DNS changes (e.g. to rollout new services) can be tested by overwriting DNS names in the local/etc/hostsfile.
The hosts file only supports IP addresses thus making it cumbersome to emulate a DNSCNAMEwithout a local DNS server/proxy.
Thelocal-cnameis a very small script to automatically lookup DNS names and write IP addresses to the hosts file.
It is self-contained and restores your local/etc/hostsfile on exit (press CTRL+C).Installation:$ sudo pip install -U local-cnameUsage:$ sudo local-cname FROM_DNS_NAME TO_DNS_NAME
  # press CTRL+C to cancel and restore your old /etc/hostsExample:$ sudo local-cname google.com duckduckgo.com
$ ping google.com