Saravanan666/pypi-org huggingface dataset:
Package: linearbunny
ruoyu_insightprojectBackgroundBiotechnology has improved many aspects of our lives, from healthcare, sustainable energy & materials to food and beverage. The global biotechnology market size was valued at USD 449.06 billion in 2019.Although there are tremendous opportunities in this industry, it is also a highly risky and volatile sector. For example, several blockbuster drugs were estimated to have sales at over USD 1000 million in 2004, but the actual sales were zero. In general, it is very challenging to perform forecasting in this industry due to its complexity.Linear Bunnyis a WebApp (http://analytics0101.tech) that forecasts the success of biotech startups with recommendation of corporate strategies and identification of similar competitors. It provides customized solutions backed by advanced data science techniques that adds values to investors, managers, and entrepreneurs. Compared with conventional approach that focuses primarily on financial strategy, Linear Bunny also considers many other cruicial factors, such as market needs/trend, relationships, management and science & technology.
Package: linear-cli-ai
linear-cli-aiAn AI based CLI for the linear app
Use the power of AI to interface with your issue tracking system in natural language right from your terminalInstallationInstallation of linear-cli-ai and its dependencies requirepythonandpip. To ensure smooth installation,
it's recommended to use:python: 3.8.10 or greaterpip: 9.0.2 or greaterThe safest way to install globally is to use$ python -m pip install linear-cli-aior for your user:$ python -m pip install --user linear-cli-aiIf you have the linear-cli-ai package installed and want to upgrade to the
latest version, you can run:$ python -m pip install --upgrade linear-cli-aiConfigurationBefore using linear-cli-ai, you need to configure a few keys.
You can do this in several ways:Configuration commandEnvironment variablesConfig fileThe quickest way to get started is to run thelinear configurecommand:$ linear configure
  Provide the following details : 
   Linear API Token : MY_LINEAR_TOKEN
   OpenAI API Key : MY_OPENAI_KEY
   Select the model you will use : gpt4 or gpt-3.5-turbo-0613To use environment variables, do the following:$ export LINEAR_TOKEN=<linear_token>
   $ export GPT_MODEL=<gpt_model>
   $ export OPENAI_API_KEY=<openai_api_key>To use a config file, create an INI formatted file like this:[linear]
  token = <linear_token>
  
  [gpt]
  token = <openai_api_key>
  model = <gpt_model>and place it in~/.linear-cli-ai.ini(or in%UserProfile%\.linear-cli-ai.inion Windows).Sample Usagelinear-cli-ai is available in the commandline with the commandlinearTo view help documentation type :$ linear helpTo use ai to perform actions on linear:$ linear aiTo create an issue via options on linear :$ linear create-issueSample ai prompt for creating an issue on linearCreate an issue with description 'Rewrite the print service with queue system'
and title as 'Print Service v2.0' and team as 'engineering' and assign it to 'Rohan'
and add labels 'bug' and 'high priority' and add it to project 'Print Service'
Package: linear-combination-py
linear-combination------------------A small library implementing linear combinations of "stuff".Such a linear combination is stored as a map, mapping "stuff" to its coefficient.That is {"a" 5, "b" 17} stands for the linear combination 5 * "a" + 17 * "b"::import linear_combination.linear_combination as lclc1 = lc.LinearCombination( {"x":7,"y":8} )lc2 = lc.LinearCombination( {"x":2.1, "z":3} )print( lc1 + lc2 )# => "+9.10 x +8 y +3 z"The main application is to `Hopf Algebras <https://en.wikipedia.org/wiki/Hopf_algebra>`_.The package comes with two sample implementations of Hopf algebrase;the concatenation Hop algebra and, its dual, the shuffle algebras (Reutenauer - Free Lie algebras).Much of its code is borrowed from `free-lie-algebra-py <https://github.com/bottler/free-lie-algebra-py>`_, by Jeremy Reizenstein::import linear_combination.linear_combination as lcimport linear_combination.words as wordsprint( lc.LinearCombination.lift( words.ShuffleWord( (1,2 ) ) ) * lc.LinearCombination.lift( words.ShuffleWord( (3,4 ) ) ) )# => +1 1234 +1 1324 +1 1342 +1 3124 +1 3142 +1 3412Installation------------Install with::pip install linear-combination-pyor::pip install git+git://github.com/diehlj/linear-combination-pyCopyright © 2018 Joscha DiehlDistributed under the `Eclipse Public License <https://opensource.org/licenses/eclipse-1.0.php>`_.
Package: linear-crf-torch
Linear CRFDescriptionThis repository hosts my Pytorch implementation of the Linear Conditional Random Field model, which is available via PyPi. There are a number of similar packages, however at this point I can say this one is faster (or equivalent), as I benchmarked the alternatives.Origin storyAbout a year ago I needed this for a project I was working on, and stumbled upon the de factoofficialimplementation (at least by star count), which you can checkhere. Now although the code was already quite good I decided to optimize it for my needs, and ended up with significant gains. I decided to open a PR in order to share, but quickly realized two thjings. The first was that I had commited way too much, and should have consulted with the author first. The second was that some changes actually went against the wants of the author, as they didn't meet his readability standard. Anyway, long story short I got demotivated, then forgot about it, and thePR of shameis still open >_<"However the story does not stop here ! As I needed to use a CRF for another project recently, I decided to clean up my code, and ended up optimizing it even further. As I like how it looks, but learned my lesson, I decided to release it, andvoila!InstallationWith Python 3.6 or higher:pip install linear-crf-torchThe model is not compatible with Pytorch versions older then 1.3, as I use features added from that version. The required changes are minimal, si I don't plan to include them.UsageThe example below shows the basic usage:importtorchfromlinear_crfimportLinearCRFseq_length=3batch_size=4num_tags=5model=LinearCRF(num_tags)emissions=torch.randn(seq_length,batch_size,num_tags)labels=torch.randint(num_tags,(seq_length,batch_size))# Compute the average negative log-likelihoodloss=model(emissions,labels)print(f"loss:{loss:.4f}")# Viterbi decodingtags=model.decode(emissions)fori,xinenumerate(tags):print(f"tags for sequence{i}:{x}")A couple caveats:I followed the Pytorch convention of setting the batch dimension after the sequence one, but you can setbatch_first=Truein the constructor if you wish to pass data the other way around.Unlike similar packages, no input validation is performed - I think the documentation should be enough to avoid any bugs.Using theimpossible_starts,impossible_transitionsandimpossible_endsparameters in the constructor, you can make it impossible for certain tags to appear at the start or end of the sequences, and make transitions from one tag to another impossible.In the forward pass, the loss is normalized by the number of non-masked elements. It doesn't make sense to normalize in an other way, neither does directly using the sum.Gradients are disabled during decoding.Masking is only supported from the right, meaning if you mask the left part of a sentence (e.g.[0, 0, 1, 1]) the computations will be incorrect.LicenseMITBenchmarksOverhere.ContributingAll help is welcome, as long as you open an issue beforehand to talk about it :)ReferenceConditional Random Fields: Probabilistic Modelsfor Segmenting and Labeling Sequence Databy John Lafferty, Andrew McCallum and Fernando C.N. Pereira
Package: linear-equations
linear_equationsThis is a simple Mathematical Module which is simple to use.  The module provides classes through which linear equations in 2 variables can be solved, and visualized.Classes and Functions providedclass Symbolsymbols to use in Linear Equationsexample: Symbol("x") -> x, Symbol("y") -> yclass LinearEquation1Dobjects of type ax + b = 0each such object has one unique solutionclass LinearEquation2Dobjects of type ax + by + c = 0when standalone, each such object has infinitely many solutionswhen solved with another such object, the final result may be infinitely many solutions, no solution or a unique solutionfunction solve1D(eqn)solves one LinearEquation1Dused to retrieve the solution to a 1D equation as a floatfunction solve2D(eqn1, eqn2)solves two LinearEquation2Dused to retrieve solution to two 2D equations as a tuple of floatsfunction consistency(eqn1, eqn2)checks and returns if the given LinearEquation2D objects are consistent or notfunction satisfies(eqn, x, y)returns True if the given pair of numbers satisfy a particular LinearEquation2D and False in all other casesEach function contains help text that can be accessed through help() in python to know more about it.Update (0.0.5)You can now graph and visualize 2-dimensional equations!Added function graph(eqn1, eqn2) which graphs the given LinearEquation2D objects on a 2D mathematical plot along with their solution (if any)Update (0.0.6)Minor bug fixes:Fixed issues with plotting linear equationsImproved legend on graphsAdded function graph_many(eqn1, eqn2, ..., eqnn, show_legend=True) which graphs more than two LinearEquation2D objects on the same plot along with each of their solutions (if any)Updates (0.0.7)Minor bug fixesReach out to meIf you face issues, contact me through my e-mail:knightt1821@gmail.com
Package: linearfold-unofficial
python-linearfoldUnofficial CPython binding to LinearFoldInstallationUsepipto install the module.pipinstalllinearfold-unofficialYou may build from the source code for unsupported Python versions or platforms.git clone --recursive https://github.com/ChangLabSNU/python-linearfold
cd python-linearfold
pip install .UsageThe module currently only has one function calledfold(seq), and
it doesn't have any customizable options other than the defaults.
The seq parameter should be an RNA sequence inuppercaseletters,
and anyTshould be converted toUbefore passing it to the function.>>>importlinearfold>>>seq='UGUCGGGUAGCUUAUCAGACUGAUGUUGACUGUUGAAUCUCAUGGCAACACCAGUCGAUGGGCUGUCUGACA'>>>linearfold.fold(seq)('((((((((((((((((.(((((.(((((.(((.(((...))))))))))).)))))))))))))))))))))',-34.6)The function returns a tuple with two elements. The first element
is the predicted MFE structure, and the second element is the free
energy of the structure in kcal/mol.AuthorHyeshik Chang <hyeshik@snu.ac.kr>LicenseThis Python binding is licensed underthe MIT-style license.
However, the compiled binary includes code from the LinearFold
package, which is licensed for non-commercial use.
Package: linear-garage-door
Linear Garage DoorDocumentation:https://IceBotYT.github.io/linear-garage-doorSource Code:https://github.com/IceBotYT/linear-garage-doorPyPI:https://pypi.org/project/linear-garage-door/Control Linear Garage Doors with PythonInstallationpipinstalllinear-garage-doorDevelopmentClone this repositoryRequirements:PoetryPython 3.7+Create a virtual environment and install the dependenciespoetryinstallActivate the virtual environmentpoetryshellTestingpytestDocumentationThe documentation is automatically generated from the content of thedocs directoryand from the docstrings
of the public signatures of the source code. The documentation is updated and published as aGithub project pageautomatically as part each release.ReleasingTrigger theDraft release workflow(pressRun workflow). This will update the changelog & version and create a GitHub release which is inDraftstate.Find the draft release from theGitHub releasesand publish it. When
a release is published, it'll triggerreleaseworkflow which creates PyPI
release and deploys updated documentation.Pre-commitPre-commit hooks run all the auto-formatters (e.g.black,isort), linters (e.g.mypy,flake8), and other quality
checks to make sure the changeset is in good shape before a commit/push happens.You can install the hooks with (runs for each commit):pre-commitinstallOr if you want them to run only for each push:pre-commitinstall-tpre-pushOr if you want e.g. want to run all checks manually for all files:pre-commitrun--all-filesThis project was generated using thewolt-python-package-cookiecuttertemplate.
Package: lineargebra
lineargebraMy simple implementation of Vectors & Matrix to python, with maths nerd stuff.Installationpip3 install lineargebraUsage ExampleVector (Vector2D and 3D works pretty much the same)fromlineargebraimportVectorex_vector=Vector((1,2,3,4))ex_vector2=Vector((4,3,2,1))ex_vector+ex_vector2# output : Vector(5; 5; 5; 5)ex_vector-ex_vector2# output : Vector(-3; -1; 1; 3)ex_vector*2# output : Vector(2; 4; 6; 8)ex_vector*ex_vector2# output : 20ex_vector.inverted()# output : Vector(4; 3; 2; 1)ex_vector.inverted()==ex_vector2# output : True# and others...
Package: linear-imputation
Linear Data ImputationThis allows you to fill-in missing values from your data. It uses a distribution estimated from the mean and covariance of your data.Installationpip install linear-imputationHow to useYou might have some data which is missing some values:>>> import pandas as pd
>>> import numpy as np
>>> from linear_imputation import impute, Imputer
>>> 
>>> input_data = pd.DataFrame({'age': [10,20,30], 'pets':[100,200,None]})
>>> input_data                                                                                        
   age   pets
0   10  100.0
1   20  200.0
2   30    NaNTo fill-in the missing values of your data, you only have to call theimputefunction:>>> impute(input_data) 
    age   pets
0  10.0  100.0
1  20.0  200.0
2  30.0  187.5The filled-in values are considered the most likely, given the distribution of your data.Sometimes it is useful to build a model from some training data to later apply this model to some other data.
Building a model is easy:>>> model = Imputer(input_data)You can then use it to fill-in missing values of other data you have:>>> marty = {'name': "Marty", 'age': None, 'pets': 150} 
>>> model.impute(marty) 
{'name': 'Marty', 'age': 20.0, 'pets': 150}The data to be completed can also be a pandas.DataFrame>>> df = pd.DataFrame([marty, {'name': 'Tom', 'age': 35}]) 
>>> model.impute(df) 
    name   age    pets
0  Marty  20.0  150.00
1    Tom  35.0  206.25You can also use a numpy.ndarray>>> matrix = np.array([[10,100], [20, 200], [30, None]]) 
>>> impute(matrix)
array([[10, 100],
       [20, 200],
       [30, 187.5]])
Package: linearinit
linearinitCreates an Fully connect network from nn.linear layers with a given activation. The layer is initialized based on the activation function chosen.Install it from PyPIpipinstalllinearinitUsagefromlinearinit.baseimportFullyConnectedLayersfromlinearinit.baseimportLinearWithInitfcn=FullyConnectedLayers(layer_sizes=[1,2,3],activation=nn.LeakyReLU(),bias=True)
Package: linearizator
Linearizator is compatible withPython 2andPython 3.What can I do with Linearizator?Solve equation of line using 2 pointsUse solved equation to linearize valuesInstallationYou can install or upgrade linearizator with:$ pip install linearizator--upgradeOr you can install from source with:$ git clonehttps://github.com/RDCH106/linearizator.git--recursive$ cd linearizator$ python setup.py installQuick example---------------------------------fromlinearizatorimportlinearizator# Initialize linearizator objectlin=linearizator.linearizator(x1=6.4,y1=20,x2=16.8,y2=85,unknown="y")# Linearizelin.linearize()# Show equation of lineprint(lin.pretty_equation())# Calculate the value of a pointprint(lin.calculate(6.4))# Generate inverse linearizationlin.inverse()# Show equation of lineprint(lin.pretty_equation())# Calculate the value of a pointprint(lin.calculate(20))
Package: linearly-varying-binomial-distribution
linearly varying_binomial distribution calculationspip install linearly-varying-binomial-distributionThis is a wrapper module for the previous repo:C PROGRAMDescription of the mathImagine the cardpool of a ptw game looks like:One can flip a card. there is a probability (here say 0.02) to have a prize at the beginning.If one does not have the prize for 50 attempts in a row, the constant (here say 0.02) will be added to the existing probability (so that the chance of having the prize is increasing) until one finally has the prize, at which point the chance will reset to the original one.For example, one tried 52 times and there have been no successes. At this point their chance for success for the 53rd time will be 0.08. If the 53-rd try is a success, then the chance for the 54-th try will be reset to 0.02, otherwise the chance becomes 0.10. Also the maximum number of tries allowed here is calculated 99, where the chance is 1.If he tries 60 times, we can calculate the chance of getting the prize with the following code:fromlvbdistimportLVBdistributionx=LVBdistribution(0.02,# the starting probability0.02,# the constant to add50# numbr of failures before triggering the addition)x.have_success_within_n_attempts(60)# 0.911490How about the probability they just get the prize at the 60th turnx.have_first_success_at_n(60)# 0.024964We can calculate the average number of attempts they need to make to have the prize:x.have_first_success_at_n_E()# 34.59455We can also calculate the average successes in 60 attempts:x.have_m_successes_within_n_attempts_E(60)# 1.443428Function names are self-descriptive. Note that functions ending with_Eare expectated values. There always exist a function without the_Esuffix.Refer tothe lazily generated docfor all functions.BuildingRequirements: setuptools, and any modern C compiler shall workClone the repository:gitclone--recurse-submoduleshttps://github.com/cleoold/linearly_varying_binomial_distribution_calcs_PythonYou can install the package by runningmakeinstallDeveloping(Optional) set up a virtual envpython3-mvenv.# pyvenv .sourcebin/activatebuild the package in-place in thelvbdistfolder by runningmakedebuggingAnd then build the distributable:bin/pip3installwheel
makerelease
Package: linearpartition-unofficial
python-linearpartitionUnofficial CPython binding to LinearPartitionInstallationUsepipto install the module.pipinstalllinearpartition-unofficialYou may build from the source code for unsupported Python versions or platforms.git clone --recursive https://github.com/ChangLabSNU/python-linearpartition
cd python-linearpartition
pip install .UsageThe module currently only has one function calledpartition(seq).
The seq parameter should be an RNA sequence inuppercaseletters,
and anyTshould be converted toUbefore passing it to the function.>>>importlinearpartitionaslp>>>seq='UGUCGGGGUUGGCUGUCUGACA'>>>bpmtx,fe=lp.partition(seq)>>>fe-7.216465644007023>>>importpandasaspd>>>pd.DataFrame(bpmtx).sort_values('prob',ascending=False).head()ijprob193180.999201182190.998801171200.997717215160.996692224170.996508Functionslinearpartition.partition()Thelinearpartition.partitionfunction is a Python C extension function that
callsLinearPartitionto
perform a linear partitioning operation and get the base pairing probability
matrix.linearpartition.partition(seq,mode='eterna',beamsize=100,dangles=2)Parametersseq(required): A string containing the RNA sequence to be analyzed.
The sequence must be in uppercase and only contain A, C, G, and U.
This parameter is required.mode(optional): The name of free energy parameters to use. Use'vienna'for Vienna RNA parameters, or'eterna'for EternaFold
parameters.beamsize(optional): An integer representing the beam size for the
operation. Larger value requires more computational time and memory.
The default value is 100.dangles(optional): An integer representing the number of dangles for
the partitioning operation. The default value is 2.Return ValueThis function returns a tuple containing the result of the partitioning
operation and the free energy of the ensemble structure in kcal/mol.AuthorHyeshik Chang <hyeshik@snu.ac.kr>LicenseThis Python binding is licensed underthe MIT-style license.
However, the compiled binary includes code from the LinearPartition
package, which is licensed for non-commercial use.
Package: linearregressiondina
package_namepackage_nameis a Python library for ..........InstallationUse the package managerpipto installpackage_name.pipinstallpackage_nameUsageimportpackage_name# returns 'words'package_name.module_name('word')# returns 'geese'package_name.module_name('goose')# returns 'phenomenon'package_name.module_name('phenomena')LicenseMIT
Package: linearregressiondinaftc
package_namepackage_nameis a Python library for ..........InstallationUse the package managerpipto installpackage_name.pipinstallpackage_nameUsageimportpackage_name# returns 'words'package_name.module_name('word')# returns 'geese'package_name.module_name('goose')# returns 'phenomenon'package_name.module_name('phenomena')LicenseMIT
Package: linear-regression-tp
rocketlinear_regression_tpis a Python library for ..........InstallationUse the package managerpipto installlinear_regression_tp.pipinstalllinear_regression_tpUsageimportlinear_regression_tp# returns 'words'linear_regression_tp.module_name('word')# returns 'geese'linear_regression_tp.module_name('goose')# returns 'phenomenon'linear_regression_tp.module_name('phenomena')LicenseMIT
Package: linear_segment
Linear Segmentationlinear_segmentation using Bayesian Change Point Segmentation or Circular Binary segmentation.InstallIf you dont already have numpy and scipy installed, it is best to downloadAnaconda, a python distribution that has them included.https://continuum.io/downloadsDependencies can be installed by:pip install -r requirements.txtPyPI install, presuming you have all its requirements installed:pip install linear_segmentUsagefromlinear_segmentimportsegmentimportnumpyasnp# Create datanp.random.seed(10)x=np.random.random(300000)x[10000:20000]=x[10000:20000]+0.1x[25000:27000]=x[25000:27000]-1labels=np.repeat('a',len(x))# Calculate segmentssegments=segment(x,labels,method="online_both")segmentssegments=segment(x,labels,method="cbs")segments
Package: linear-segmentation
linear_segmentationAutomatic sparse sampling of 1-D array into linear segments minimizing errorInstall from clonepip install .Install from PYPIpip install linear_segmentationExamplepython -m linear_segmentation.examples.linear_segmentation_with_slider.pyUsagefrom linear_segmentation import linear_segmentation
from linear_segmentation import refinement  # optional
import scipy.interpolation as spint

...
x, y = linear_segmentation(data, tol=0.001)  # normalized abs error tolerance
x_refined, y_refined = refinement(data, x)  # optional refinement using least squares
data_interp = spint.interp1d(x_refined, y_refined)  # or x, y
...
new_y = data_interp(new_x)