Saravanan666/pypi-org huggingface dataset:
Package: lopc
lopc (Lines of Python Code)usage: lopc [-h] [-e EXCLUDE_DIR] [--no-defaults] [-v] TARGET [TARGET ...]

Count lines of Python code

positional arguments:
  TARGET                File or directory to scan (can be given multiple times)

optional arguments:
  -h, --help            show this help message and exit
  -e EXCLUDE_DIR, --exclude-dir EXCLUDE_DIR
                        Add directory (and its subdirectories) to the
                        exclusion list. Can be given multiple times. Unix
                        shell-style wildcards (?*) are allowed. Default =
                        'venv', '.*' and '__pycache__'
  --no-defaults         Don't exclude any directories by default (use
                        --exclude-dir as needed)
  -v, --verbose         More output (can be given multiple times, default =
                        not verbose)Install(venv) $ pip install lopcRun(venv) $ lopc /home/markku/devel/lopc
/home/markku/devel/lopc Files: 4 Lines: 142

(venv) $ lopc /home/markku/devel/lopc -v
File: /home/markku/devel/lopc/setup.py (16 lines)
File: /home/markku/devel/lopc/lopc/__init__.py (0 lines)
File: /home/markku/devel/lopc/lopc/__main__.py (5 lines)
File: /home/markku/devel/lopc/lopc/lopc.py (121 lines)
/home/markku/devel/lopc Files: 4 Lines: 142

(venv) $ lopc /home/markku/devel/lopc -vv
Directory: /home/markku/devel/lopc
File: /home/markku/devel/lopc/setup.py (16 lines)
Directory: /home/markku/devel/lopc/lopc
File: /home/markku/devel/lopc/lopc/__init__.py (0 lines)
File: /home/markku/devel/lopc/lopc/__main__.py (5 lines)
File: /home/markku/devel/lopc/lopc/lopc.py (121 lines)
Directory: /home/markku/devel/lopc/lopc.egg-info
/home/markku/devel/lopc Files: 4 Lines: 142
Package: lop-codeingame-cli
LOPInGame CliInstallationpipinstalllop-codeingame-cliUsagelopauthC'est la fonction permettant de vous connecter, Il vous sera demandé votre email et votre mot de passe.Usage:lopauth[OPTIONS]Options:--mailTEXTVotreadressemail[required]--passwordTEXTVotremotdepasse[required]--helpShowthismessageandexit.lopgeneratePermet la génération d'un template pour créer un exercise, pour le moment seul le language python est supporté.
Avant de l'utiliser, assurer vous de vous connecter et de créer l'exercise sur le site webUsage:lopgenerate[OPTIONS]Options:--exerciseTEXTL'id de l'exercice[required]--helpShowthismessageandexit.Exemplelopgenerate--exercise1478922558lopdownloadPermet aux étudiants de télécharger le template d'un exercise pour le résoudreUsage:lopdownload[OPTIONS]Options:--exercise-idTEXTIddel'exercise[required]--helpShowthismessageandexit.Exemplelopdownload--exercise-id1478922558lopsubmitUne fois l'exercise résolu ou le template modifié, vous pouvez soumettre votre code avec cette commandeUsage:lopsubmit[OPTIONS]Options:--pathTEXTLecheminverslerépertoiredel'exercice[default:.]--kind[solve|template]Letypedesoumission(solveoutemplate)[default:solve]--helpShowthismessageandexit.Exemplelopsubmit--path.--kindsolve
Package: loqet
# loqetLoqet is a local python secret manager. The Loqet package comes with two primary tools:loqandloqet.loqis a standalone file encryption tool. Encrypt, decrypt, read, edit, search, and diffloqencrypted files.loqetis a context-managed secret store. Create aloqet contextfor each of your projects, and store your project secrets, encrypted at rest. Use theloqetcommand line tool to interact with your encrypted secret store, and use theloqetpython API to read your encrypted secrets at runtime.—## How to install`shell pip install loqet `—## Usage[Quick Start Guide](docs/quick_start.md)[loq command line interface](docs/loq_cli.md)[loqet command line interface](docs/loqet_cli.md)[loqet python API](docs/loqet_api.md)[loq/loqet configs](docs/configs.md)—## Loq or Loqet, which should I use?loqis great for encrypting single files that stand alone and don’t need programmatic access. Lock up some passwords, bank account info, or crypto seed phrases to look at later when you need them. Alternatively, if you (securely) give a friend a loq key, you can send each other secret messages. I’ll leave that up to you to figure out.loqetis great for projects with secrets in their configs, or when you have groups of many secrets. It’s also great for secret management in a project shared between multiple contributors, since you can securely share the keyfile, and commit encrypted secrets to a shared version control system.
Package: loquat
LoquatA simple web framework based on Tornado.IntroduceLoquat is a web framework based on Tornado.InstallationpipinstallloquatSimple usesfromloquat.serverimportServerfromloquat.webimportApplicationfromhandlerimportBaseHandlerclassIndexHandler(BaseHandler):definitialize(self,database):self.database=databasedefget(self):self.write("hello world!")classTestApplication(Application):def__init__(self,handlers=None,middlewares=None,transforms=None):super().__init__(handlers,middlewares,transforms)defmain():handlers=[(r"/",IndexHandler,dict(database="this is database"))]application=TestApplication(handlers=handlers)server=Server(application)server.start()if__name__=="__main__":main()
Package: lor
ALPHA BUILD: A framework for rapidly developing pipelines with Luigi[documentation]Features:Convention-over-configuration approach to Luigi projectsStandard workspace creation (lor new)Configuration loadingA workspace-centric command-line (new,explain,ls,run, etc.)Utility tasks (e.g.EnsureExistsOnLocalFilesystemTask)Other utilities for managing long-running subprocesses, building a CLI, etc.InstallationTo install use pip:$ pip install lorOr clone the repo:$ git clonehttps://github.com/adamkewley/lor.git$ python setup.py installUsageOnce installed,lorcan be used from the command-line:$ lor new fooThis creates alorworkspace atfoo/. Alorworkspace is a standard python3 pip project which depends onloras a dependency (this can be removed if you don’t need it). Thelorcommand-line command can detect if the
terminal is in alorworkspace and provides convenience commands for working in a standard workspace.Tasks written forlorare just standard Luigi tasks. Thelorlibrary provides various utility methods that a
typical projectmightfind useful (all opt-in). For example,lorprovides apropsmodule that you can use to
load configuration properties at runtime:# foo/tasks/barimportlor.propsimportluigiclassBarTask(luigi.Task):output_path=luigi.Parameter()defrun(self):withopen(str(self.output_path),"w")asf:config_prop=lor.props.get("CONFIG_PROP")f.write(config_prop)defoutput(self):returnluigi.LocalTarget(self.output_path)The above is a standard Luigi task that useslorto load a configuration property calledCONFIG_PROPfrom the
workspace (held atetc/properties.ymlin the workspace). The task is a standard Luigi task, so it can be ran from
Luigi directly:$ luigi –module foo.tasks.bar BarTask –output-path some/pathThelor runcommand can also be used to run the task:$ lor run –module foo.tasks.bar BarTask –output-path some/pathThelor runcommand runsluigiby proxy, so it effectively has the same interface. However,lor runalso
adds useful functionality, such as the ability to override a variable’s value at runtime:$ lor run –properties CONFIG_PROP=overridden –module foo.tasks.bar BarTask –output-path some/pathThe task will then write “overridden” to the output file instead of whatever was loaded from the workspace’s configuration
file. This is becauselor runbootstraps the workspace global with the override before running Luigi.TODO: This documentation is work in progress
Package: lora-adapters
LowRank AdaptersThis libary implements a series ofLow Rank Adaptersto apply to torch models in a simple manner without having to redefine your model.Official RepositoryYou can choose to only store the updated layers as shown belowimporttimmimporttorchfromlora_adaptersimportLoraConv2d,apply_adapter,mark_only_lora_as_trainable,lora_state_dictmodel=timm.create_model('resnet50',pretrained=True)model=apply_adapter(model,LoraConv2d,rank=16)model=mark_only_lora_as_trainable(model,bias='lora_only')...CustomTrainingLoop...updates=lora_state_dict(model,bias='lora_only')torch.save(updates,'updates.ckpt')importtimmimporttorchfromlora_adaptersimportLoraConv2d,apply_adapter,mark_lora_as_trainable,lora_state_dictmodel=timm.create_model('resnet50',pretrained=True)updates=torch.load('updates.ckpt')model.load_state_dict(updates,strict=False)Or you can reverse the lora adaptations and save the full state dictionaryimporttimmimporttorchfromlora_adaptersimportLoraConv2d,apply_adapter,mark_only_lora_as_trainable,undo_loramodel=timm.create_model('resnet50',pretrained=True)model=apply_adapter(model,LoraConv2d,rank=16)model=mark_only_lora_as_trainable(model,bias='lora_only')...CustomTrainingLoop...model=undo_lora(model)torch.save(model.state_dict(),'model.ckpt')WarningsThe functions that adapt the model change them in place, so the below code won't work as expected,modelandlora_modelwill be the sameimporttimmfromlora_adaptersimportLoraConv2d,apply_adaptermodel=timm.create_model('resnet50',pretrained=True)lora_model=apply_adapter(model,LoraConv2d,rank=16)
Package: loragateway
loragatewayfeatureslogging incoming messages into sqlite dbpublishing incoming messages to brokersending lora messages which come into channel 'LoRaSendQueue'usagepi@hq:~$loragw--help
usage:loragw[-h][-aADDRESS][-pPORT][-iID][-dDATABASE]optionalarguments:-h,--helpshowthishelpmessageandexit-aADDRESS,--addressADDRESSMQTTserveraddress-pPORT,--portPORTMQTTserverport-iID,--idIDMQTTclientid-dDATABASE,--databaseDATABASEPathtosqlitedatabase
Package: loraline
Loraline configures LoRaWAN transceivers to hostsInstallation$ pip install -r requirements.txt

$ pip install setup.pyDevelopmentThis project includes a number of helpers in theMakefileto streamline common development tasks.Environment SetupThe following demonstrates setting up and working with a development environment:### create a virtualenv for development

$ make virtualenv

$ source env/bin/activate


### run loraline cli application

$ loraline --help


### run pytest / coverage

$ make testReleasing to PyPiBefore releasing to PyPi, you must configure your login credentials:~/.pypirc:[pypi]
username = YOUR_USERNAME
password = YOUR_PASSWORDThen use the included helper function via theMakefile:$ make dist

$ make dist-uploadDeploymentsDockerIncluded is a basicDockerfilefor building and distributingLoraline,
and can be built with the includedmakehelper:$ make docker

$ docker run -it loraline --help
Package: loramon
LoRa packet sniffer for RNode hardwareIntroThis utility allows you to sniff LoRa networks with anRNode, and dump captured packets to the console or files.usage:loramon[-h][-C][-Wdirectory][--freqHz][--bwHz][--txpdBm][--sffactor][--crrate][port]LoRapacketsnifferforRNodehardware.

positionalarguments:portSerialportwhereRNodeisattached

optionalarguments:-h,--helpshowthishelpmessageandexit-C,--consolePrintcapturedpacketstotheconsole-WdirectoryWritecapturedpacketstoadirectory--freqHzFrequencyinHz--bwHzBandwidthinHze--txpdBmTXpowerindBm--sffactorSpreadingfactor--crrateCodingrateInstallationIf you already have Python3 and pip installed, you can easily install LoRaMon through pip:pip3installloramonIf you want to install directly from this repository, first install the dependencies:sudoaptinstallpython3python3-pip
sudopip3installpyserialAnd then clone the repository and make LoRaMon executable:gitclonehttps://github.com/markqvist/LoRaMon.gitcdLoRaMon
chmoda+xloramon
./loramon--helpUsage ExamplesDump to consoleListens on a specified frequency and displays captured packets in the console.loramon/dev/ttyUSB0--freq868000000--bw125000--sf7--cr5-CDump to console and diskLike above, but also writes all captured packets individually to a specified directory.loramon/dev/ttyUSB0--freq868000000--bw125000--sf7--cr5-C-WcapturedirSniff implicit header mode packetsIf you want to sniff LoRa packets with implicit header mode, use the --implicit option along with the length in bytes of the expected packet. This mode needs an RNode with a firmware version of at least 1.17.loramon/dev/ttyUSB0--freq868000000--bw125000--sf7--cr5-C-Wcapturedir--implicit12
Package: loranode
python-loranode===============Python 3 bindings for interfacing with LoRa nodes such as the RN2483, mDot, iM880A-L, and others. Currently, only the RN2483 modem is supported.Installation------------`pip install loranode`Examples--------Joining a network through Activation by Personalization (ABP) and transmitting a message:```pythonfrom loranode import RN2483Controllerlc = RN2483Controller("/dev/ttyUSB0")if lc.join_abp("<your nwkskey>", "<your appskey>", "<your devaddr>"):lc.send("0001020304")  # Expects hex input```Send peer to peer message:```pythonfrom loranode import RN2483Controllerlc = RN2483Controller("/dev/ttyUSB0")lc.send_p2p("0001020304")```
Package: lora-pytorch
lora-pytorchInstallpipinstall"lora-pytorch @ git+ssh://git@github.com/fkodom/lora-pytorch.git"# Install all dev dependencies (tests etc.)pipinstall"lora-pytorch[all] @ git+ssh://git@github.com/fkodom/lora-pytorch.git"# Setup pre-commit hookspre-commitinstallTestTests run automatically through GitHub Actions.Fast tests run on each push.Slow tests (decorated with@pytest.mark.slow) run on each PR.You can also run tests manually withpytest:pytestlora-pytorch# For all tests, including slow ones:pytest--slowlora-pytorchRelease[Optional] Requires either PyPI or Docker GHA workflows to be enabled.Just tag a new release in this repo, and GHA will automatically publish Python wheels and/or Docker images.
Package: lora-rn2483
Python library and tools for using RN2483 LoRaWAN TransceiverCompatible devicesBuild StatusRaspberry Pi 3B+RN2483 to Raspberry Pi GPIO connectionPinRN2483toPinRaspberry Pi 3B+[7]UART_RX->[14]UART_TX0[6]UART_TX->[15]UART_RX0How to use itWhen importing library as module, import pyserial and initialize a connection using your assigned serial interface (e.g /dev/ttyUSB0 - in ubuntu).Installpyserial:pip3installpyserialInstallrn2483:gitclonehttps://github.com/alexantoniades/python-RN2483.gitcdpython-RN2483
python3setup.pyinstallImport and initialize modulesimportserialimportrn2483#define serial port and baudrate for rn2583 transceiverPORT="/dev/ttyUSB0"BAUDRATE=57600# Initialize serial connectionuart=serial.Serial(PORT,BAUDRATE)# Initialize transceiverdevice=rn2483(connection=uart,debug=True)# Check if device is initializedprint(device.connection.is_open)# Check hardware euiprint(device.hardware_eui())Configure LoRaWAN - Authentication By Personalizationdevice.config_abp(nwskey=NetworkSessionKey,appskey=ApplicationSessionKey,devaddr=DeviceAddress)Configure LoRaWAN - Over The Air Authenticationdevice.config_otaa(appkey=ApplicationKey,appeui=ApplicationEUI)Send datadevice.send("Hello World")Close connectiondevice.close_connection()
Package: loras
LoRASLocalized Randomized Affine Shadowsampling (LoRAS) oversampling techniqueInstallationThe latest version is available on PyPi and installable with the command:pip install lorasUsageThere is just one methodfit_resample(maj_class_points, min_class_points, k, num_shadow_points, list_sigma_f, num_generated_points, num_aff_comb, random_state=42)There are two mandatory inputs:maj_class_points: Majority class parent data points which is a non-empty list containing numpy arrays acting as pointsmin_class_points: Minority class parent data points which is a non-empty list containing numpy arrays acting as pointsThere are also optional parameters:k: Number of nearest neighbours to be considered per parent data point (default value:8 if len(min_class_points)<100 else 30)num_shadow_points: Number of generated shadowsamples per parent data point (default value:ceil(2*num_aff_comb / k))list_sigma_f: List of standard deviations for normal distributions for adding noise to each feature (default value:[0.005, ... , 0.005])num_generated_points: Number of shadow points to be chosen for a random affine combination (default value:ceil((len(maj_class_points) + len(min_class_points)) / len(min_class_points)))num_aff_comb: Number of generated LoRAS points for each nearest neighbours group (default value:min_class_points.shape[1])Output:min_class_points::oversampled_set: Concatenation of original data points and oversampled ones
Package: loratransmit
LoRaTransmitSimple commandline raw LoRa packet transmitter forRNodehardware.It's meant to be complementary to the packet snifferLoRaMonand uses the latestPython Modulethat comes with theRNode Firmware.Install$ pip install loratransmitUsageprovide payload as command line argument or via pipeusage: loratransmit [-h] [--freq Hz] [--bw Hz] [--txp dBm] [--sf factor]
                       [--cr rate]
                       [port] [payload]

LoRa packet transmitter for RNode hardware.

positional arguments:
  port         Serial port where RNode is attached
  payload      The payload to be transmitted

options:
  -h, --help   show this help message and exit
  --freq Hz    Frequency in Hz
  --bw Hz      Bandwidth in Hz
  --txp dBm    TX power in dBm
  --sf factor  Spreading factor
  --cr rate    Coding rateExamplePayload passed as argument$ loratransmit --freq 917500000 /dev/ttyACM0 "Hello World"Payload passed through pipe$ echo "Hello World" | loratransmit --freq 917500000 /dev/ttyACM0
Package: lorax
I am the Lorax.  I speak for the trees.
–Dr. Seusslorax implements a queued web service for calculating phylogenetic trees for
gene families.  Lorax usesHMMERto do multiple sequence alignments,FastTreeorRAxMLto calculate trees,RQto queue calculations, andFlaskto serve up results.Latest ReleaseGitHubLicenseDocumentationTravis BuildCoveragePythonicityCode GradeDependenciesIssuesKanban
Package: lorcania-cli
lorcania-cli is an unofficial CLI to work withLorcania, a website to collect yourLorcanacards.
Lorcania provides a valuable service for the community and this utility is not ment to replace it, but rather to allow (currently: me) to obtain a local backup for my collection.It currently only allows to:Get your collection of Lorcana cards.Installationpip install lorcania-cliUsageTo get your collection at the command line$lorcania-clicollectionshow"<e-mail address used for Lorcania>"Password:"<Lorcania password>"┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃collection┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│rarity_collectionfoilopregular│
│card_set_idnumbernametitle│
│11MickeyMouseBraveLittleTailor│
...
└───────────────────────────────────────────────────────────────────────────────────────────────┘You can also use environment variables or an .env file to store your credentials:LORCANIA_EMAIL="<e-mail address used for Lorcania>"LORCANIA_PASSWORD="<Lorcania password>"Then, you can directly uselorcania-cli
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ collection                                                                                    ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ rarity_collection                                                           foil  op  regular │
│ card_set_id number name                        title                                          │
│ 1           1      Mickey Mouse                Brave Little Tailor                            │
...
└───────────────────────────────────────────────────────────────────────────────────────────────┘Please always remember, that your credentials are secrets and should not be stored in version control.To get your collection as an excel file (here:my-collection.xlsx), use$ lorcania-cli collection show --out-file my-collection.xlsxTestTo test lorcania-cli, usepytest.
In order to don't waste Lorcania resources, a vcr.py suite is included for an account with the following collection:Mickey Mouse Detective(Promo): 1xAriel - On Human Legs(The First Chapter): 2x (regular)Cinderella - Gentle and Kind(The First Chapter): 1x (regular), 2x (foil)If you want to extend lorcania-cli and need to run tests against real Lorcania, I recommend tocreate a lorcania account for this purposeadd the above cardsadd any other cards as required for your use casedelete the vcr.py cassettes attests/cassettesmake the credentials to your lorcania test account available in.env.tests(which is ignored via .gitignore)rerunpytest
Package: lord-aubrey-of-the-rings
Lord Of The Rings SDKDescription: An SDK that makes it easy for developers to consume information about the Lord of The Rings trilogy.SDK builds on an existingLord of The Rings APITech StackBuilt using Python 3.10.5 (see.python-versionfile). External libraries are kept as minimal as possible
(seerequirements.infile)Installationpip install lord-aubrey-of-the-ringsRunRegister and loginhereto get youraccess token.Import the classLordOfTheRingsand call the available methods, passing params where necessary. Example:fromlord_of_the_rings.endpointsimportLordOfTheRingsclient=LordOfTheRings(access_token='your_access_token')client.get_books()client.get_movies('5cd95395de30eff6ebccde5b')client.get_characters('5cd99d4bde30eff6ebccfe2e','quote')There are also the options ofPagination:client.get_characters(limit=2)client.get_characters(page=3)client.get_characters(offset=11)Sorting:client.get_books(sort='name:asc')client.get_quotes(sort='dialog:desc')and Filtering:client.get_characters(name='Gandalf')client.get_characters(race='Hobbit,Human')Consult theAPI docsfor more informationExposed methods:METHOD:PARAMETER(S)get_books:identifier(optional),'chapter'(optional,requiresidentifier)get_movies:identifier(optional),'quote'(optional,requiresidentifier)get_characters:identifier(optional),'quote'(optional,requiresidentifier)get_quotes:identifier(optional)get_chapters:identifier(optional)Install (to run SDK locally)Clone github repo and run the following code. It creates a fresh virtual environment (called .venv) and
installs requirementsmake setupInstall pip requirements / Sync requirements.in with requirements.txtmake pip_syncRun testsmake runtest
Package: lor-deckcodes
Python ImplementationInstallpython >=3.5 required
pip >= 19.0.0pip install lor-deckcodesUsageEver expanding rich API with method to display cards convenientlyfromlor_deckcodesimportLoRDeck,CardCodeAndCount# Decodingdeck=LoRDeck.from_deckcode('CEBAIAIFB4WDANQIAEAQGDAUDAQSIJZUAIAQCBIFAEAQCBAA')# list all cards with card format 3:01SI001list(deck)card=deck.cards[0]# instance of CardCodeAndCountcard.faction# SI/FR...card.card_id# 111card.set# 01# Encoding# These are equivalentdeck=LoRDeck(['3:01SI015','3:01SI044'])deck=LoRDeck([CardCodeAndCount.from_card_string('3:01SI015'),CardCodeAndCount('01SI015',3)])# returns encoded stringdeck.encode()
Package: lordkelvin
lord kelvinEVM interfaceQuickstart:to just build the docker image, type:make dbuildto run tests, type:make -C toolsor to use a specific ganache port:PORT=1234 make -C toolsto run tests, then get a shell, type:make -C tools shor to use a specific ganache port:PORT=1234 make -C tools shUsing different networksOnlyganacheandkovanare supportedTo add a network:add a newenv.{NEWORK}.shfile to toolsadd a new alias intools/aliasesInside dockeryour life is easy, just type the name of the network!Examples:ganachekovanOutside dockerto use ganache (the default), type:source env.shto use kovan, type:source env.kovan.sh