Saravanan666/pypi-org huggingface dataset:
Package: lsystem-generator
Lsystem generator python libCurrent version:1.0This package enable to generate Lsystem representation by providing:Axioms (e.g. : "F")Rules of generation (e.g. F -> F+F--F+F)Generation (e.g. 2 for the second generation)Rules of display (using theturtle analogy)Installationpip install lsystem-generator==1.0Usagefrom lsystem.lsys_generator import Lsystem

if __name__=="__main__":
    lsys = Lsystem("F",("F", "F-Y-F"), ("Y", "Y+F+Y"))

    lsys.generate(2)
    image = lsys.render(("+",80), ("-",-80))
    image.show()

    lsys.generate(5)
    image = lsys.render(("+",60), ("-",-60))
    image.show()note fore the user: after declaring a Lsystem, multiple generationgenerate()can be created and different representation can be obtainedrender()help(Lsystem)gives a detailed documentation on how to create Lsystems, generate and render image representationsPerformance limitsThe programm is performing at generate lsystem in the first 10-15 generation, depending on the lenght of the rule for generation and the number of axioms and rules.
At generation n+1 the lenght of the generated sequence  will be:l_1 = number of axioms in sequence_n * lenght of the rule for generation for each axiom + characters that are not axioms in the sequence_n  

    = sum(number of axiom i in sequence_n * lenght of the rule i for this axiom) + (lenght of the sequence - sum(number of axiom i in sequence_n))

    = sum((l / l_rule_i * occ_a_i) * l_rule_i) + (l - sum(l / l_rule_i * occ_a_i) )with:l: lenght of the sequence at generation nl+1: lenght of the sequence at generation nl_rule_i: lenght of the rule i for generationocc_a_i: number of occurences of the axiom i in the rule i for generationi: index of the pair (axiom, rule) defined in the LsystemThe RAM available will depend on the system and the python installation you are running the lib with, the maximum string length that can be generated and thus the number of generation that can be produced will vary.
If higher generation needs to be produced, a different implementation would be required.DevelopmentAfter downloading the sources runpip install -e .We recommand using a virtulanv to install pip dependenciesRunning unit test (in development mode)To run the tests execute from the root folder:pytest --testdoxif you encounter import difficulites, make sure the root directory, lsystem and tests dir are in the $PYTHONPATH. Runsource .envto add themLicenseShield:This work is licensed under aCreative Commons Attribution-ShareAlike 4.0 International License.
Package: lsystems
A Python module for L-systemsExample use:>>> from lsystem import LSystem>>> algae = LSystem(axiom='a', rules={'a':'ab', 'b':'a'})
>>> print algae[5]
abaababaabaabAnother example is given as a scriptexample-plant.py.
Running the scriptpython example-plant.pyresults in the following picture: ![plant image](imgs/plant6.png)
Package: lt8900-spi
Python LT8900 via SPIThis Python module enables a Python to talk to an LT8900 radio attached to an serial peripheral interface (SPI).APISynopsislt8900_spi.Radio(spi_bus, spi_dev, config = None) -> instance
lt8900_spi.Radio.put_register(reg, value) -> value
lt8900_spi.Radio.put_register_bits(reg, bits_dict) -> value
lt8900_spi.Radio.get_register(reg) -> value
lt8900_spi.Radio.get_register_bits(reg, value = None) -> dictionary
lt8900_spi.Radio.configure(config) -> None
lt8900_spi.Radio.initialize() -> boolean
lt8900_spi.Radio.set_channel(channel) -> dictionary
lt8900_spi.Radio.set_syncword(syncword) -> None
lt8900_spi.Radio.fill_fifo(message, include_length = True) -> list
lt8900_spi.Radio.transmit(message, channel = None) -> boolean
lt8900_spi.Radio.multi_transmit(message, channels, retries = 3, delay = 0.1) -> boolean
lt8900_spi.Radio.start_listening(channel) -> boolean
lt8900_spi.Radio.stop_listening() -> boolean
lt8900_spi.Radio.receive(channel = None, wait = False, length = None, wait_time = 0.1) -> listinstance.get_register_bitsLow-level primitive to get a named register with bitfields expanded to names.instance.put_register_bitsLow-level primitive to set a named register by bitfield value.instance.set_syncwordHigh-level interface to syncword mechanism.  The syncword can be 1, 2, 3, or 4 16-bit words long and should be provided as an array.Example:instance.set_syncword([1, 2, 3, 4])instance.transmitTransmit a message.  If a channel is specified transmit on that channel -- otherwise the current channel is queried and then used.instance.multi_transmitTransmit a message across multiple channels multiple times.  This is a common pattern so this function is provided for convience.Example#! /usr/bin/env python3

import time

import gpiozero
import lt8900_spi

# Need to keep this attached to drive the line high -- if the object disappears then
# the GPIO port gets reconfigured as an input port
# Note broadcom pin numbers are used
reset_gpio = gpiozero.LED(24)
reset_gpio.on()
def reset_module_via_gpio():    
	reset_gpio.off()
	time.sleep(0.1)
	reset_gpio.on()
	time.sleep(0.1)

radio = lt8900_spi.Radio(0, 0, {
	'reset_command': reset_module_via_gpio
})

if not radio.initialize():
	raise ValueError('Initialize failed')

radio.set_syncword([0x258B, 0x147A])

radio.multi_transmit([0xB0, 0x51, 0xF0, 0x00, 0x00, 0x01, 212], [9, 40, 71], delay = 0.5)
Package: ltable
pure python table, operations find, filter, sort, group, top, tail…theTable = SSTable()
theTable.addIndex( "c_1", 'idx1' );
vCol = [ "c_1", "c_2" ]
theTable.addIndex( vCol, 'idx2' );
theTable.addRow( dict( c_1 = 1, c_2 = 2 ) )
theTable.addRow( dict( c_1 = 1, c_2 = 2 ) )
theTable.addRow( dict( c_1 = 2, c_2 = 3 ) )

#search by index
rs = theTable.findRow( "idx2", ( 1, 2 ) )
pprint( rs.top( 1 ).to_list() )
grs = rs.group( ("c_1") )2014/06/03Fix bug: Coouldn’t find anything after removeRow
Package: ltbams
LTB AMSPython Software for Power System Dispatch Modeling and Co-Simulation with Dynanic, serving as the market simulator for theCURENT Largescale Testbed.LatestStableDocumentationBadgesDownloadsTry on BinderCode QualityBuild StatusStructurePython VersionWhy AMSWith the built-in interface with dynamic simulation engine, ANDES, AMS enables Dynamics Interfaced Stability Constrained Production Cost and Market Operation Modeling.AMS produces credible dispatch results and competitive performance.
The following results show the comparison of DCOPF between AMS and other tools.Cost [$]AMSMATPOWERpandapowerPEGASE 1354-Bus1,173,590.631,173,590.631,173,590.63PEGASE 2869-Bus2,338,915.612,338,915.612,338,915.61GOC 4020-Bus793,634.11793,634.11793,634.11EPIGRIDS 5658-Bus1,195,466.121,195,466.121,195,466.12EPIGRIDS 7336-Bus1,855,870.941,855,870.941,855,870.94AMS is currently under active development.
Use the following resources to get involved.Start from thedocumentationfor installation and tutorial.Check out examples in theexamples folderRead the model verification results in theexamples/verification folderAsk a question in theGitHub DiscussionsReport bugs or issues by submitting aGitHub issueSubmit contributions usingpull requestsRead release notes highlightedhereTry in Jupyter Notebook onBinderInstallationAMS is released asltbamson PyPI and conda-forge.
Install from PyPI using pip:pipinstallltbamsInstall from conda-forge using conda:condainstallconda-forge::ltbamsInstall from GitHub source:pipinstallgit+https://github.com/CURENT/ams.gitSponsors and ContributorsAMS is the dispatch simulation engine for the CURENT Largescale Testbed (LTB).
More information about CURENT LTB can be found at theLTB Repository.This work was supported in part by the Engineering Research Center Program of the National Science Foundation and the Department of Energy
under NSF Award Number EEC-1041877 and the CURENT Industry Partnership Program.This work was supported in part by the Advanced Grid Research and Development Program in the Office of Electricity at the U.S. Department of Energy.SeeGitHub contributorsfor the contributor list.LicenseAMS is licensed under theGPL v3 License.Related ProjectsPopular Open Source Libraries for Power System AnalysisG-PST Tools Portal: An open tools portal with a classification approachOpen Source Software (OSS) for Electricity Market Research, Teaching, and TrainingSome commercial solvers provide academic licenses, such as COPT, GUROBI, CPLEX, and MOSEK.
Package: ltchinese
ltchinese - A library of utilities for the Chinese language (pinyin, zhuyin,
encodings, phonetics, etc.) fromhttp://lost-theory.org.ocrat - represents the data from the Ocrat Mirror Project (stroke orderGIFs, etc.) athttp://lost-theory.org/ocratconversion - conversion functions between Chinese encodings / representationsannotate - annotate and romanize Chinese characters / words with pinyin,zhuyin, etc.phonetics - represents the data from the Mandarin Phonetics table (validMandarin syllables, male / female pronunciation clips)
Package: ltchiptool
ltchiptoolUniversal, easy-to-use GUI flashing/dumping tool for BK7231, RTL8710B and RTL8720C. Also contains some CLI utilities for binary firmware manipulation.What is this?This repository is a collection of tools, used in theLibreTiny project, that perform some chip-specific tasks, like packaging binary images or uploading firmware to the chip.Since v2.0.0, it contains a common, chip-independent CLI and API for interacting with supported chips in download mode (reading/writing flash).Since v3.0.0, it contains a beginner-friendly GUI for flashing firmware or dumping flash contents.Usage/documentationAvailable hereLicenseMIT License

Copyright (c) 2022 Kuba Szczodrzyński

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: ltck
Lingorithm Text ClassificationThis package is the core function for any NLP operation or pacakge used by lingorithm.InstallationUse the package managerpipto install ltck.pipinstallltckUsageDataInput data is a list of tuplesdata=[("Help me please","commonQ.assist"),("Is this a bot?","commonQ.bot"),("Is there a bot chatting to me?","commonQ.bot")]importltcktc=ltck('en',data)tc.train(epochs=20,batch_size=8,model_name="commonQ_v1")classified=tc.classify("Help me please")print(classified)# [('commonQ.assist', 0.9737932),#  ('commonQ.not_giving', 0.012769885),#  ('commonQ.name', 0.0071987235),#  ('commonQ.how', 0.002869619),#  ('commonQ.query', 0.0023981368),#  ('commonQ.bot', 0.000478917),#  ('faq.bad_service', 0.0003706195),#  ('faq.aadhaar_missing', 5.4887507e-05),#  ('faq.apply_register', 3.3203887e-05),#  ('commonQ.just_details', 1.60179e-05),#  ('faq.biz_new', 9.965993e-06),#  ('faq.application_process', 3.101246e-06),#  ('faq.borrow_limit', 1.6019511e-06),#  ('faq.borrow_use', 1.4953373e-06),#  ('commonQ.wait', 2.9794015e-07),#  ('faq.biz_simpler', 2.6959242e-07),#  ('contact.contact', 9.587218e-08),#  ('faq.biz_category_missing', 5.7328425e-08),#  ('faq.approval_time', 5.5687766e-09),#  ('faq.banking_option_missing', 1.6084242e-09),#  ('faq.address_proof', 1.3430994e-09)]ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMIT
Package: ltcn
This package introduces the Long-Term Cognitive Network (LTCN) model for structured pattern classification problems. This recurrent neural network incorporates a quasi-nonlinear reasoning rule that allows controlling the amount of non-linearity in the reasoning mechanism. Furthermore, this neural classifier uses a recurrence-aware decision model that evades the issues posed by the unique fixed point while introducing a deterministic learning algorithm to compute the tunable parameters. The experiments in the original paper show that this classifier obtains competitive results when compared to state-of-the-art white and black-box models.
Package: lt-code
LT-code=======This is an implementation of a Luby Transform code in Python, consisting of two executables, one for each encoding and decoding files. These are thin wrappers around a core stream/file API.See _D.J.C, MacKay, 'Information theory, inference, and learning algorithms. Cambridge University Press, 2003_ for reference on the algorithms.## EncodingThe encoding algorithm follows the given spec, so no innovations there. A few optimizations are made however. First, the CDF of the degree distribution, M(d), is precomputed for all degrees d = 1, ..., K. This CDF is represented as an array mapping index d => M(d), so sampling from the degree distribution mu(d) becomes a linear search through the CDF array looking for the bucket our random number on \[0, 1) landed in. This random number is generated as specified using the linear congruential generator.Second, the integer representation of all blocks is held in RAM for maximum speed in block sample generation. This is a limitation on the size of the file practically encoded on most computers, but this decision does not reach far into other parts of the design, and it can be easily addressed if necessary for better memory scalability.```pythonfrom sys import stdoutfrom lt import encode# Stream a fountain of 1024B blocks to stdoutblock_size = 1024with open(filename, 'rb') as f:for block in encode.encoder(f, block_size):stdout.buffer.write(block)```## DecodingThe decoder reads the header, then the body, of each incoming block and conducts all possible steps in the belief propagation algorithm on a representation of the source node/check node graph that become possible given the new check node. This is done using an online algorithm, which computes the appropriate messages incrementally and passes them eagerly as the value of source nodes is resolved. Thus, the decoder will finish decoding once it has read only as many blocks is necessary in the stream to decode the file, and it seems to scale well as the file size, and block size increase.```pythonfrom sys import stdinfrom lt import decode# Block to fully decode transmission incoming on stdindata = decode.decode(stdin.buffer)# Feed the decoder as blocks come indecoder = decode.LtDecoder()for block in decode.read_blocks(some_stream):decoder.consume_block(block)if decoder.is_done():break# Write bytes payload to streamdecoder.stream_dump(some_out_stream)# Get entire transmission as bytesdata = decoder.bytes_dump()```## Commandline UsageTo run the encoder, invoke the following from the shell$ ./bin/encoder <file> <blocksize> <seed> [c] [delta]To run the decoder, run the following$ ./bin/decoder
Package: ltcrabbit
Client Interface for LTCRabbit.com API======================================Requirements============* Python 2.6 or above* `requests`_ library* `docopt`_ library* `prettytable`_ library# Usage### Worker Listltcrabbit-cli worker list --apikey=<your_api_key>### User Infoltcrabbit-cli user --apikey=<your_api_key>### Pool Infoltcrabbit-cli pool --apikey=<your_api_key>### Earningsltcrabbit-cli earnings --apikey=<your_api_key>### BTC Exchange Ratesltcrabbit-cli btc_exchange_rates --apikey=<your_api_key>### LTC Exchange Ratesltcrabbit-cli ltc_exchange_rates --apikey=<your_api_key>
Package: ltd-mason
LSST the Docs: MasonMasonis the build tool for LSST software documentation.
It’s flexible and can run as part of aTravis CI buildto upload built documentation to Amazon S3 in coordination withLTD Keeper.
Mason can also build documentation for complex multi-repository software projects like the LSST Science Pipelines.Mason a part of theLSST the Docs(LTD) service for continuous documentation delivery.
You can learn more about LTD in ourSQR-006technote.InstallationMason is compatible with Python 2.7 and 3.4+.
You can get the latest release from PyPI:pip install ltd-masonDocsRead the docs at https://ltd-mason.lsst.ioThis documentation describes how to use LTD Mason in Travis-based (single repo) and Jenkins-based (multi repo) documentation builds.Copyright 2016-2017 Association of Universities for Research in Astronomy, Inc.License: MIT.
Package: ltd-rust
This is a rust implementation of the downsampling alogrithm Large-Triangle-Dynamic. The algorithm was described in the thesis "Downsampling Time Series for Visual Representation
" written by Sveinn Steinarsson. You can find his thesis athttps://skemman.is/handle/1946/15343f.The code is losely taken fromhttps://github.com/janjakubnanista/downsample.This was a fun projet for me were I was able to implement the algorithm in rust and also publish it as a python package.Usagefrom ltd_rust import downsample
import random
length = 1000

x = [i for i in range(length)]
y = [random.randint(0,1000) for i in range(length)]

x_down, y_down = downsample(x,y,100)
Package: ltempy
ltempyltempy is a set of tools for Lorentz TEM data analysis, simulation, and presentation.FeaturesSingle Image Transport of Intensity Equation (SITIE) reconstructionsimulations - calculations of phase, B, A, imagebasic image processing - high_pass, low_pass, clippinga matplotlib.pyplot wrapper tailored to presenting induction maps and Lorentz dataan implementation of the CIELAB colorspacemodule-wide unit scaling (i.e., working in nm rather than m)Installationpython-mpipinstallltempyDocumentationDocumentation is available athttps://mcmorranlab.github.io/ltempy/.TestsTests are split into two subdirectories:testsThese are typical unit tests, that assert that functions return the right shape, beam parameters return the right values, etc. Run withpytest.devtestsThese are tests of the actual functionality, that require a trained eye to evaluate. Run as normal.pyscripts.The rationale fordevtestsis that this package is math-heavy, so it's highly possible for the code to run fine, but be wrong. The easiest way to test for this is to check base cases where the developer knows what to look for.
Package: lte-nr-frequency
LTE_NR_FrequencyConvert between EARFCN and LTE frequency, NR-ARFCN and NR frequency.Installpip install lte-nr-frequencyUsageget_lte_freq():Args:LTE EARFCN.Returns:Dictionary of band name, LTE downlink frequency, LTE uplink frequency, duplex type.get_lte_earfcn()Args:LTE downlink frequency.Returns:List of dictionaries of band name, LTE uplink frequency, LTE downlink earfcn, LTE uplink earfcn and duplex type.get_nr_dl_freq()Args:NR downlink arfcn.Returns:List of dictionaries of band name, NR downlink frequency, duplex type, band type.get_nr_dl_arfcn()Args:NR downlink frequency.Returns:NR downlink arfcn.
Package: ltep-athena-api
LTEP Athena APIThe official LTEP Athena API: Welcome to the World's most flexible and extensible Data Science PlatformExplore the docsView Demo·Report Bug·Request FeatureTable of ContentsAbout The ProjectBuilt WithGetting StartedPrerequisitesInstallationUsageRoadmapContributingLicenseContactAcknowledgmentsAbout The ProjectThis is the official LTEP Athena API to connect to your LTEP Athena platform and publish individual code & algorithms.
Create Custom Data Manipulation Algorithms, Custom Analysis, Real-time Streams, and utilize any Technology from Apache Flink to your own Package/Library.(back to top)Built With(back to top)Getting StartedHow to install beta-Version: pip install ltep-athena-apiPrerequisitesPython >=3.7Installationpip install ltep-athena-api(back to top)UsageThe Beta Documentation is available onhttps://ltep-athena-api.readthedocs.io/en/latest/For more examples, please refer to theDocumentation(back to top)ROADMAPRoadmapAdd ChangelogSee theopen issuesfor a full list of proposed features (and known issues).(back to top)ContributingContributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions you make aregreatly appreciated.If you have a suggestion that would make this better, please fork the repo and create a pull request. You can also simply open an issue with the tag "enhancement".
Don't forget to give the project a star! Thanks again!Fork the ProjectCreate your Feature Branch (git checkout -b feature/AmazingFeature)Commit your Changes (git commit -m 'Add some AmazingFeature')Push to the Branch (git push origin feature/AmazingFeature)Open a Pull Request(back to top)LicenseDistributed under the MIT License. SeeLICENSEfor more information.(back to top)ContactEfstratios Pahis -@ltep-Project Link:https://github.com/efstratios97/ltep_athena_api(back to top)AcknowledgmentsLTEP Technologies UG (haftungsbeschränkt)www.ltep-technologies.com(back to top)
Package: ltf
ltf libraryThis library is supposed to be a public library of all Token Engineering toolsInstallationpipinstallltfList of all packagesimportltfhelp(ltf)A few examplesfromltf.bondingcurvesimportSigmoid# you can run basic version with default datasbc=Sigmoid()sbc.fig_builder().show()output:Note: You may need to use your own datasbc = Sigmoid(
    csv_path='INITIAL_VALUES.csv',
    current_supply=16000000,
    zoom=1
    )Note2: The format of the csv file should be as follows-lsmksteps0l1s1m1k1steps1l2s2m2k2steps2l3s3m3k3steps3l4s4m4k4stepsExample:-lsmksteps020.8172.10E+075730010001255.00E+04510002255.00E+055010003695.00E+062.00E+031000
Package: ltfatpy
Theltfatpypackage is a partial Python port of theLarge Time/Frequency Analysis Toolbox (LTFAT), a MATLAB®/Octave toolbox for working with
time-frequency analysis and synthesis.It is intended both as an educational and a computational tool.The package provides a large number of linear transforms including Gabor
transforms along with routines for constructing windows (filter prototypes)
and routines for manipulating coefficients.The original LTFAT Toolbox for MATLAB®/Octave is developed atCAHR, Technical
University of Denmark,ARI, Austrian Academy
of Sciences andI2M, Aix-Marseille Université.The Python port is developed atLabEx Archimède, as aLIF(nowLIS)
and I2M project, Aix-Marseille Université.This package, as well as the original LTFAT toolbox, is Free software, released
under the GNU General Public License (GPLv3).The latest version ofltfatpycan be downloaded from the followingPyPI page.Thedocumentationis availablehere.The development is done in thisGitLab project, which provides
the git repository managing thesource codeand where issues can be
reported.History0.1.0 (2014-04-30)Creation1.0.0 (2015-12-15)Based on ltfat commit 0f9c83d96b (version 2.1.0)AuthorsDenis Arrivault <contact.dev/A/lis-lab.fr>
Florent Jaillet <contact.dev/A/lis-lab.fr>