Saravanan666/pypi-org huggingface dataset:
Package: last-shout
Quick DescriptionA command line tool to tweet a user’s top artist statistics from Last.fm to Twitter and Mastodon.InstallationPyPiInstall it yourself:$pipinstall--userlast-shoutGitHubInstalling the latest version from Github:$gitclonehttps://github.com/bpepple/last-shout.git$cdlast-shout$python3setup.pyinstallGetting startedIn order to use Last-Shout, you need at a minimum to get authentication keys forTwitterandLast.fm.To get the necessary authenticaton keys forTwitter, refer to the documentationhere.To get the necessary authentication keys forLast.fm, refer to theirdocumentation.Helpusage: main.py [-h] [-u USER] [--last-access-key LAST_ACCESS_KEY]
               [--set-lastfm] [-n NUMBER] [-p PERIOD] [-t]
               [--consumer-key CONSUMER_KEY]
               [--consumer-secret CONSUMER_SECRET] [--access-key ACCESS_KEY]
               [--access-secret ACCESS_SECRET] [--set-twitter]
               [--create-mastodon-app] [--create-mastodon-user] [--toot]
               [--version]

A program to post last.fm statistics to Twitter and/or Mastodon.

optional arguments:
  -h, --help            show this help message and exit
  -u USER, --user USER  Last.fm username (default: None)
  --last-access-key LAST_ACCESS_KEY
                        Last.fm access key (default: None)
  --set-lastfm          Set Last.fm credentials (default: False)
  -n NUMBER, --number NUMBER
                        Number of last.fm top artists (default: 10)
  -p PERIOD, --period PERIOD
                        The time period over which to retrieve top artists.
                        Options are: overall | 7day | 1month | 3month | 6month
                        | 12month (default: 7day)
  -t, --tweet           Post Last.fm stats to Twitter (default: False)
  --consumer-key CONSUMER_KEY
                        Twitter consumer key (default: None)
  --consumer-secret CONSUMER_SECRET
                        Twitter consumer secret (default: None)
  --access-key ACCESS_KEY
                        Twitter access token key (default: None)
  --access-secret ACCESS_SECRET
                        Twitter access secret (default: None)
  --set-twitter         Set Twitter credentials (default: False)
  --create-mastodon-app
                        Create mastodon application (default: False)
  --create-mastodon-user
                        Create Mastodon user token (default: False)
  --toot                Post Last.fm stats to Mastodon (default: False)
  --version             Show the version number and exit
Package: lastSoul
Python (not yet)full scale client for IONIS's students (EPITECH/EPITA/etc)----------------------------------------Features :- Connection to netsoul server and authentification using config file- Configuration generator script- Multithreaded queuing system for processing in and out operations without blocking calls.- Advanced handling with registration system of function called when regexp match with input- Severals UI:* Raw command mode : allow to type commands directly to the server while being authed* PyQt Interface : with multi-tab, and userlist support* ncurses Interface : with user tracking
Package: last-train-to-nowhere
Entry toPyWeek #15Team: Wasabi/ParathaMembers: mauve, arnavYou are an outlaw on the run - and you need to get the hell out of town.There’s only one problem: the train has already left. Ok, two problems: it is
also packed with law men.Only one thing to do: load your six-shooter, saddle up, and chase that train
down!DependenciesIf you haven’t already please install the following dependencies:Python 2.7                  (required)
Pyglet 1.1.4 or v1.2alpha1  (required)
AVBin                       (recommended) for playing musicRunning the gameOpen a terminal window, “cd” into the game directory and run:python run_game.pyHow to playThe following input keys are used for this game:LEFT        move left
RIGHT       move right
UP          jump
DOWN        crouch
X           shoot from a distance or punch at close rangeThe aim of the game is to progress forward in the train, and collecting all the
gold bars on the train. The gold bars will be picked up as you touch them.But many lawmen are present, guarding the train and the gold. How can you get
past them?Note: Press the ‘X’ key to skip the intro sequence.LicenseLast Train to Nowhere is licensed under the terms of the GNU General Public
License v3.0.
Package: last-watched-series
last_watched_seriesA simple command-line application for memorizing the last watched series.Installation1. Using Pip$pipinstalllast_watched_series2. Manual$gitclonehttps://github.com/Qyutou/last_watched_series.git$cdlast_watched_series$pythonsetup.pyinstallUsageNext command will show all possible commands:$last_watched_series
Package: laszip
laszip-pythonUnofficial bindings betweenPythonandLASzipmade
usingpybind11.The main purpose is for integration withinlaspy.BuildingBuilding can be done using cmake or pip.First,laszipandpybind11needs to be installed. You can install it viavcpkgorcondaor other means.To help cmake find Laszip you may have to use-DCMAKE_TOOLCHAIN_FILE=/some/path/vcpg.cmakeif you used vcpkg to install laszip, or-DCMAKE_PREFIX_PARTH(or-DCMAKE_INCLUDE_PATH=...and-DCMAKE_LIBRARY_PATH=...in rare cases).As setup.py calls cmake the same options make need to be given:set-gxSKBUILD_CMAKE_ARGS-DCMAKE_PREFIX_PATH=...
pipinstall.
Package: latae
LataeA pure Python library for parsing and reading robots.txt files🛠 NoteLatae is currently in heavy development, expect bugs! More features are planned.💻 UsageVia a file on your local system...importlataeasltwithopen("robots.txt","r")asf:rb_file=f.readlines()# Get disallowed paths in the form of a Dictlt.get_disallowed(rb_file)# Get the XML sitemaplt.get_sitemap(rb_file)...Or via therequestsmoduleimportrequestsimportlataeasltrb_file=requests.get("https://duckduckgo.com/robots.txt").text# Get disallowed paths in the form of a Dictlt.get_disallowed(rb_file.splitlines())# Get the XML sitemaplt.get_sitemap(rb_file.splitlines())
Package: latam
latamUn paquete para trabajar facilmente con metadatos de paises en latinoamerica.¿Qué trae?📃 Citeishon@misc{latam,
  author = {tacosdedatos},
  title = {Un paquete para trabajar facilmente con metadatos de países de Latinoamérica.},
  year = {2020},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {\url{https://github.com/tacosdedatos/latam}}
}Este proyecto fue generado conpython-package-template.
Package: latbin
This python package is used for binning onto lattices in multiple
dimensions.Why Use LatticesFor “regular” 2D histogramming you implicitly use a Z2 lattice! But the
errors involved with quantizing to a Z2 lattices is larger than A2.insert plot here showing proper comparison of Z2 and A2 give name of
file which creates Z2-A2 comparisonBasic ExampleThis example shows how to take a normal data set and histogram the data
onto an A2 (aka honeycomb) lattice using latbin.importlatbinimportnumpyasnp# create some fake data with shape (npts,ndim)npts,ndim=60000,2data=np.random.normal(size=(npts,ndim))*4.0# create an A2 lattice (honeycomb binning)a2=latbin.ALattice(2)# histogram the data onto A2 Latticeh=a2.histogram(data)# get the lattice points in the data spacecenters=h.centers()# show the resultimportmatplotlib.pylabaspltplt.title("Honeycomb binning (A2 Lattice)")plt.scatter(centers[:,0],centers[:,1],c=h.values(),s=70)plt.show()InstallationIn the terminal you can install this in the usual way.pythonsetup.pyinstall
Package: latch-sdk-telefonica
LATCH PYTHON SDK#### PREREQUISITES ####Python.Read API documentation (https://latch.telefonica.com/www/developers/doc_api).To get the "Application ID" and "Secret", (fundamental values for integrating Latch in any application), it’s necessary to register a developer account in Latch's website:https://latch.telefonica.com. On the upper right side, click on "Developer area"USING THE SDK IN PYTHONInstall "latch-sdk-telefonica"pip install latch-sdk-telefonicaImport "latch" module.import latchCreate a Latch object with the "Application ID" and "Secret" previously obtained.api = latch.Latch("APP_ID_HERE", "SECRET_KEY_HERE")Optional settings:latch.Latch.set_proxy("PROXY_HOST_HERE", port)Call to Latch Server. Pairing will return an account id that you should store for future api callsresponse = api.pair("PAIRING_CODE_HERE")
	response = api.status("ACCOUNT_ID_HERE")
	response = api.unpair("ACCOUNT_ID_HERE")After every API call, get Latch response data and errors and handle them.responseData = response.get_data()
	responseError = response.get_error()USING PYTHON SDK FOR WEB3 SERVICESFor using the Python SDK within an Web3 service, you must complain with the following:It is necessary to have a developer subscription that allows you to create web3 apps.You need metamask extension for Google ChromeDownload metamaskYou need a wallet to operate on Polygon. You can easily create one through Metamask.Creation of a WEB3 Latch appOnce you have your developer Latch account created, you must logging in the website.Steps to add  new web3 app in latch-websiteWe add a new method to pair the web3 applications, now we have two new parameters.
The two additional parameters are:WEB3WALLET: The Ethereum-based address wallet for the user that wants to pair the service.WEB3SIGNATURE: A proof-of-ownership signature of a constant, in order to verify that the user owns the private key of the wallet. You can usehttps://etherscan.io/verifiedSignatures#to sign the following message:MESSAGE TO SIGN : "Latch-Web3"Call to Latch Server for pairing as usual, but with the newly methods:api=latch.Latch(APP_ID,SECRET_KEY)# PAIRresponse=api.pair(pairing_code,WEB3WALLET,WEB3SIGNATURE)You have an example of use in the fileexample for web3 app
Package: latdraw
latdrawDraw Accelerator lattices in PythonDocumentation:https://st-walker.github.io/latdrawGitHub:https://github.com/st-walker/latdrawPyPI:https://pypi.org/project/latdraw/Free software: MITFeaturesTODOCreditsThis package was created withCookiecutterand thewaynerv/cookiecutter-pypackageproject template.
Package: late-bound-arguments
Late-Bound ArgumentsThis package tries to emulate the behaviour of syntax proposed inPEP 671via a decorator.UsageMention the names of the arguments which are to be late-bound in the arguments of thedelaydecorator, and their default values as strings in the function signature.Mutable default arguments:fromlate_bound_argumentsimportdelay@delay("my_list")deffoo(my_list="[]"):my_list.append(1)returnmy_listprint(foo())# [1]print(foo())# [1]print(foo([1,2,3]))# [1, 2, 3, 1]Referencing previous arguments:fromlate_bound_argumentsimportdelay@delay("my_list","n")deffoo(my_list="[1, 2]",n:int="len(my_list)"):returnmy_list,nprint(foo())# ([1, 2], 2)print(foo([1,2,3]))# ([1, 2, 3], 3)Additionally, the function signature is not overwritten, sohelp(foo)will provide the original signature retaining the default values.ReasoningMutable defaults are often tricky to work with, and may not do what one might naively expect.For example, consider the following function:deffoo(my_list=[]):my_list.append(1)returnmy_listprint(foo())print(foo())One might expect that this prints[1]twice, but it doesn't. Instead, it prints[1]and[1, 1].
A new list object isnotcreated every timefoois called without providing thebargument: the list is only created once - when the function is defined - and the same list object is used for every call. As a result, if it is mutated in any call, the change is reflected in subsequent calls.A common workaround for this is usingNoneas a placeholder for the default value, and replacing it inside the function body.deffoo(my_list=None):ifmy_listisNone:my_list=[]...In caseNoneis a valid value for the argument, a sentinel object is created beforehand and used as the default instead._SENTINEL=object()deffoo(my_list=_SENTINEL):ifmy_listis_SENTINEL:my_list=[]...However, this solution, apart from being unnecessarily verbose, has an additional drawback:help(foo)in a REPL will fail to inform of the default values, and one would have to go through the source code to find the true signature.
Package: latechclfl2020besnier
LaTeCH-CLfL-2020Repository associated withHistory to Myths: Social Network Analysis for Comparison of Stories over Timepaper.Citation@inproceedings{besnier-2020-history,
    title = "History to Myths: Social Network Analysis for Comparison of Stories over Time",
    author = "Besnier, Cl{\'e}ment",
    booktitle = "Proceedings of the The 4th Joint SIGHUM Workshop on Computational Linguistics for Cultural Heritage, Social Sciences, Humanities and Literature",
    month = dec,
    year = "2020",
    address = "Online",
    publisher = "International Committee on Computational Linguistics",
    url = "https://www.aclweb.org/anthology/2020.latechclfl-1.1",
    pages = "1--9",
    abstract = {We discuss on how related stories can be compared by their characters. We investigate character graphs, or social networks, in order to measure evolution of character importance over time. To illustrate this, we chose the Siegfried-Sigurd myth that may come from a Merovingian king named Sigiberthus. The Nibelungenlied, the V{\"o}lsunga saga and the History of the Franks are the three resources used.},
}DataTexts:Decem libros historium(DLH) by Gregory of ToursNibelungenlied(NIB)Völsunga saga(VOL)DLHis the historical reference.NIBandVÖLare fiction works.InstallationTested on Windows 10 and Ubuntu 16.04.
Tested with Python 3.7 and 3.8.Install with pip$pipinstalllatechclfl2020besnieror download source$gitclonehttps://github.com/clemsciences/LaTeCH-CLfl-2020-besnier.git
$cdLaTeCH-CLfl-2020-besnier
$virtualenv-p/usr/bin/python3venv
$sourcevenv/bin/activate
$pipinstall-rrequirements.txtReproducing resultsDownload resources
Run$ python -m -m latechclfl2020.models.initiate latechclfl2020/models/initiate.pyGenerating graphs.
Run$ python -m latechclfl2020.models.scripts latechclfl2020/models/scripts.pyGenerating character feature table in paper.
Run$ python -m latechclfl2020.models.reconstruction latechclfl2020/models/reconstruction.pyGenerating Brynhildr ego-graphs.
Run$ python -m latechclfl2020.models.paper.graph_visualisation latechclfl2020/models/paper/graph_visualisation.pyCorpus observation.
Run$ python -m latechclfl2020.models.paper.corpus_observation latechclfl2020/models/paper/corpus_observation.py
Package: latent
LatentLego - flexible latent spaces for single cellsLatentLego is a python library for building autoencoders for single-cell genomics. It is build on top ofTensorFlowandKerasand provides modular components to build common single-cell autoencoder architectures. All individual comonents are valid KerasLayerorModelobjects and therefore support model construction using the standard Keras (functional/sequential) API. There is also a model zoo of preconstructed models that understand builtin Keras methods like.fit()or.predict()and.compile()with custom loss functions.InstallationYou can install LatentLego fromPyPIusingpippipinstalllatentor install the development version from GitHubpipinstallgit+https://github.com/quadbiolab/latent-legoOverviewLatentLego is designed to be a flexible kit for defining autoencoders by providing common building blocks that can be freely assembled. Here's an overview:latent.models- Here you can find Keras-compatible implementations of common single-cell autoencoder architectures, such as theZINBAutoencoder(Erslan 2019) or theNegativeBinomialVAE(Lopez 2018). I also implemented some more experimental architectures like theTopologicalAutoencoder(Moor 2019).latent.modules- Here live the lower level building blocks of autoencoders, namelyencoderanddecodermodels that can be freely assembled to produce autoencoder models. E.g., using aVariationalEncoderwith aPoissonDecoderproduces aPoissonVAE, a variational autoencoder with a poisson reconstruction loss.latent.layers- These are the most basic building blocks ofencoderanddecodermodels. In addition to theDenseBlock/DenseStacklayers that are the core component of encoders and decoders, I implemeneted some other useful utility layers.latent.losses,latent.activations,latent.callbacks- Keras-style components that are useful for single-cell data, like aNegativeBinomialloss or aKLDivergenceSchedulercallback function. All of these should work nicely within the TensorFlow/Keras framework.
Package: latent-calendar
Latent CalendarAnalyze and model data on a weekly calendarInstallationInstall from PyPI:pipinstalllatent-calendarOr install directly from GitHub for the latest functionality.FeaturesIntegrated automatically intopandaswithcalattribute on DataFrames and SeriesCompatible withscikit-learnpipelines and transformersTransform and visualize data on a weekly calendarModel weekly calendar data with a mixture of calendarsCreate lower dimensional representations of calendar dataDocumentationFind more examples and documentationhere.
Package: latent-geometry
Latent GeometryMaster's thesis python package allowing for the exploration of latent spaces of generative models through Riemannian geometry.By employing a pull-back metric from the observation space one can reveal nuanced geometrical structures in hidden spaces. The framework is agnostic to the automatic differetiation backend e.g. PyTorch, TensorFlow. It works even with custom, hand-made differentiable mappings.Installationpip install latent-geometryUsageGeodesicsimportnumpyasnpimporttorch.nnasnn# just for the sake of exampleyour_neural_net:nn.Module=YourPyTorchNet(latent_dim=8)# create Mappingfromlatent_geometry.mappingimportMapping,TorchModelMappingmapping:Mapping=TorchModelMapping(model=your_neural_net,in_shape=(8,),# dimensionality of the domain w/o batch sizeout_shape=(3,32,32),# dimensionality of the co-domain w/o batch sizebatch_size=batch_size,call_fn=your_neural_net.forward,# optional)# define your favourite metric for the observation spacefromlatent_geometry.metricimportEuclideaMetricambient_metric=EuclideanMetric()# create the manifold spanned by your latent space with the pulled-back ambient metricfromlatent_geometry.manifoldimportLatentManifoldlatent_manifold=LatentManifold(mapping=latent_mapping,ambient_metric=ambient_metric,)# calculate the geodesic starting from z_0 with velocity v_0fromlatent_geometry.pathimportManifoldPathz_0=np.zeros(8)v_0=np.ones_like(z_0)geodesic:ManifoldPath=latent_manifold.geodesic(z=z_0,velocity_vec=v_0)# geodesic(0) == z_0# calculate the the shortest path between z_a and z_bz_a=np.zeros(8)z_b=np.zeros(8)+3shortest_path:ManifoldPath=shortest_path.geodesic(z_a=z_a,z_b=z_b)# shortest_path(0.0), shortest_path(1.0) == z_a, z_bIf your mapping is not based on PyTorch you need to implement one of two possible interfaces# you can implement first and second derivative of output wrt. to inputfromlatent_geometry.mappingimportDerivativeMappingclassYourMappingWrapper(DerivativeMapping):def__init__(self,your_mapping:Callable)->None:...defjacobian(self,zs:np.ndarray)->np.ndarray:...defsecond_derivative(self,zs:np.ndarray)->np.ndarray:...# or follow the other interface (for speed-up purpuses)fromlatent_geometry.mappingimportMatrixMappingclassYourMappingWrapper(MatrixMapping):def__init__(self,your_mapping:Callable)->None:...defjacobian(self,zs:np.ndarray)->np.ndarray:...defmetric_matrix_derivative(self,zs:np.ndarray,ambient_metric_matrices:np.ndarray)->np.ndarray:...Riemannian optimizeronly for PyTorch right nowimporttorchimporttorch.nnasnnfromlatent_geometry.optimimportTorchMetric,InputGDOptimizeryour_neural_net:nn.Module=YourPyTorchNet()loss_fn=lambdax:x.mean()example_input=torch.zeros(8,requires_grad=True)optimizer=InputDGOptimizer(param=example_input,metric=TorchMetric(mapping=your_neural_net),lr=0.001,gradient_type="geometric"# may also be "standard", "retractive")for_inrange(1_000):optimizer.zero_grad()x=your_neural_net(example_input)loss=loss_fn(x)loss.backward()optimizer.step()
Package: latent-ideology
Latent ideology methodCorrespondence Analysis applied for calculating 'ideology scores' given an adjacency matrix.Method for applying the correspondence analysis method for the purpose of calculating
an 'ideology score' as stated in [1][2].[1] J. Flamino, A. Galezzi, S. Feldman, M. W. Macy, B. Cross, Z. Zhou, M. Sera
no, A. Bovet, H. A. Makse, and B. K. Szymanski,
'Shifting polarization and twitter news influencers between two us presidential elections',
arXiv preprint arXiv:2111.02505 (2021).[2] Max Falkenberg, Alessandro Galeazzi, Maddalena Torricelli, Niccolo Di Marco, Francesca Larosa, Madalina Sas, Amin Mekacher,
Warren Pearce, Fabiana Zollo, Walter Quattrociocchi, Andrea Baronchelli,
'Growing polarisation around climate change on social media',https://doi.org/10.48550/arXiv.2112.12137(2021).#How to useIt's simple, justpip install latent-ideologyThere are a couple of things you can do here. You can:Make an adjacency matrix given a 'connection dataframe' between targets and sources. (see more in the examples folder in#Github)Given an adjacency matrix, calculate scores in 1 (or more) dimensions.Given a 'connection dataframe', you can simple apply the function 'apply_method' and this will generate 2 dataframes: one for the score of the targets and one for the scores of the sources.Altenatively, you can apply a simplified method by using the function 'apply_simplified_method'. Here, the source's scores are calculating by transposing the adjacency matrix and making reduction of dimensionality following the proccedures of [2].. instead of considering the score of the sources as the mean of the scores of the targets that had interacted with the source.Made with love byFede Moss
Package: latentis
LatentisA Python package for analyzing and transforming neural latent spaces.Installationpipinstallgit+ssh://git@github.com/flegyas/latentis.gitQuickstartDevelopment installationSetup the development environment:gitclonegit@github.com:flegyas/latentis.gitcdlatentis
condaenvcreate-fenv.yaml
condaactivatelatentis
pre-commitinstallRun the tests:pre-commitrun--all-files
pytest-vUpdate the dependenciesRe-install the project in edit mode:pipinstall-e.[dev]