Saravanan666/pypi-org huggingface dataset:
Package: sequence-stk
OverviewSequence is a library that lets you build analysis tools that can be controlled by configuration files.
This is useful when you want to define the logic for generating some sort of output, like data or an image, in a configuration file.
This type of configuration file is called asequenceand it defines a sequence of operations that do something.Under the hood, sequences are run by a virtual stack machine.
A sequence is a list ofoperations, where an operation is either another sequence or amethod.
A method is a Python function that uses the@sequence.methoddecorator and methods provide basic functionality building blocks.
Methods and sequences pass data to each other on the virtual machine's stack, via pushing, popping, and swapping data.Asequence toolkit (STK)is a Python package that provides a suite of methods.
Thestandard toolkit(built-in) is a suite of turing-complete methods that provide the backbone for scripting logic in sequences (e.g., if blocks, while loops, string formatting, data resources, etc.).
Additional functionality can be added by installing additional toolkits.About Stack MachinesIf it isn't clear how operations pass data using the stack, a good way to get familiar with the concept is by playing around with an RPN calculator likethis. Try calculating the hypotenuse of a triangle with side length of 3 and 4 using the Pythagorean Theorem (the answer is3, Enter, X, Enter, 4, Enter, X, +, SQRT). Every button-press is equivalent to an operation in sequence.The design of sequence took inspiration from these old RPN-style calculators as well as theFORTHprogramming language.Installing sequenceSequence can be install usingpip. The basic install supports JSON.$pipinstallsequence-stkIt's often useful to be able to write comments and use multi-line strings in sequences.
JSON5 and HSON are extensions of JSON that support these features.
Additional configuration languages can be installed via thejson5, and/ordhsonextras.$pipinstall"sequence[json5,hson]"If you are developing an STK, thedevanddocsextras install the requirements for running tests and building documentation.$pipinstall"sequence[dev,docs]"
Package: sequence-tagging
Part of Speech TaggingA Part of Speech tagger using the Average Perceptron.Based on the tagger fromhereThis uses the following features:The Suffix (last 3 characters) of the current word (unnormalized).The Prefix (first character) of the current word (unnormalized).The current word.The previous Part of Speech tag and the current word.The Previous Part of Speech tag.The Part of Speech tag from the word before last.Both of the previous Part of Speech tags.The previous word.The previous word suffix.The word from 2 steps back.The next word.The next word suffix.The word after next.A BiasIncludes the following Pretrained models.POS Tagger, Trained on the CoNLL 2000 Chunking dataChunker, Trained on the CoNLL 2000 Chunking dataSlot filler, Trained on ATIS data
Package: sequencetools
Bioinformatic tools for manipulation, filtering, and statisticsbased on seqtoolsIn honor of John A. CrowCurrent ToolsUSAGE: sequencetools <TOOL> [options]Current Tools:basic_fasta_stats
format_fasta
chunk_fasta
chunk_fastq
fastx_converter
filter_fasta_by_length
get_fasta_by_id
get_fastq_by_id
subset_fastqPlease runsequencetools <TOOL> –helpfor individual usage
Package: sequential-executor
sequential-executorAconcurrent.futures.Executorimplementation that performs sequential execution.While this micro-library may seem a little oxymoronic (Executors are, after all,
meant to execute calls asynchronously), it does have a fairly well-defined use case.Use caseA Python package that performs multiple operations via callback(s) defined by implementors
using that package. The package allows the implementor to define the concurrent execution environment
by passing in aconcurrent.futures.Executorobject.This allows the implementor to tailor the execution environment based upon the work that their callback will be performing. For example, if they are making web calls (e.g. - IO bound) they could pass in aThreadPoolExecutor, but if they are doing numpy analysis of large datasets (e.g. - CPU bound), they could pass in aProcessPoolExecutor. But what if the implementor must enforce sequential execution, such as for ordered message processing?TheSequentialExecutorprovided by this package allows for the implementor using the hypothetical Python package to give that package anExecutor, but forces the execution environment into seqential ordering.Installationpipinstallsequential-executorSequentialExecutor Exampleimportconcurrent.futuresimporturllib.requestimportsequential_executorURLS=['http://www.foxnews.com/','http://www.cnn.com/','http://europe.wsj.com/','http://www.bbc.co.uk/','http://some-made-up-domain.com/']# Retrieve a single page and report the URL and contentsdefload_url(url,timeout):print('loading%r'%url)withurllib.request.urlopen(url,timeout=timeout)asconn:returnconn.read()# We can use in a with statement just like other Executorswithsequential_executor.SequentialExecutor()asexecutor:# Start the load operations and mark each future with its URLfuture_to_url={executor.submit(load_url,url,60):urlforurlinURLS}forfutureinconcurrent.futures.as_completed(future_to_url):url=future_to_url[future]try:data=future.result()exceptExceptionasexc:print('%rgenerated an exception:%s'%(url,exc))else:print('%rpage is%dbytes'%(url,len(data)))NOTE - Although this looks like it is submitting multiple jobs and then waiting
on each job to complete, theconcurrent.futures.Futureobjects returned by theSequentialExecutorwill be fully complete upon the return from thesubmitcall!
Package: sequential-ft-transformer
sequential_ft_transformerFT Transformer applied to sequential tabular dataInstallation$pipinstallsequential_ft_transformerUsageTODOContributingInterested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.Licensesequential_ft_transformerwas created by Christian Orr. It is licensed under the terms of the MIT license.Creditssequential_ft_transformerwas created withcookiecutterand thepy-pkgs-cookiecuttertemplate.
Package: sequentiality
SequentialityIntroductionhttps://pypi.org/project/sequentiality/0.0.1/Sequentiality is a Python package designed for extracting key features from a list of integers. It specializes in identifying various forms of Longest Consecutive Subsequences (LCS) within an integer list. This functionality is crucial for data analysis, statistical assessments, and algorithmic processing in numerous fields.Table of ContentsIntroductionInstallationUsageFeaturesDependenciesDocumentationExamplesContributorsLicenseInstallation & ImportingpipinstallsequentialityfromSequentialityimportSequentialityFeatures & UsageSequentiality provides methods for the following feature extraction capabilities:find_LongestConseqSubseq: Finds the Longest Consecutive Subsequence of integers in the list.find_LongestConseqSubseq_1gap: Identifies the LCS with one gap allowed.find_LongestConseqSubseq_2gap: Extracts the LCS allowing two gaps (only once between them).find_LongestConseqSubseq_from_end: Determines the LCS counted from the end of the list.find_LongestConseqSubseq_from_end_with_1_gap: LCS from the end with one gap allowed (only once).find_LongestConseqSubseq_from_end_with_2_gap: LCS from the end with two gaps allowed (specific conditions apply).Additional utility methods:find_sequential_elements_with_difference_of_2: Finds pairs in the sequence with a difference of 2.find_sequential_elements_with_difference_of_3: Finds pairs in the sequence with a difference of 3.seq=Sequentiality()sample=[1,2,3,4,5,7,8,10,11,12,13,16]print(seq.find_LongestConseqSubseq(sample))print(seq.find_LongestConseqSubseq_1gap(sample))print(seq.find_LongestConseqSubseq_2gap(sample))print(seq.find_LongestConseqSubseq_from_end(sample))print(seq.find_LongestConseqSubseq_from_end_with_1_gap(sample))print(seq.find_LongestConseqSubseq_from_end_with_2_gap(sample))Documentationhttps://github.com/karaposu/sequentialityLicenseMIT LicenseCopyright (c) 2024 Enes KuzucuPermission 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: sequential-rename
Rename-Sequential-FilesA small rename function I created to handle documents that have the same file name during automated copy jobs. This function will allow the files to be copied by just appending a (#) to the end of the file name similar to how file systems do so. You need to pass the new directory, current file name, and the files extension and the function will return the new name with (#) if no file with the same name already exists.For example:from sequential_rename.sequential_rename import seq_rename

new_doc_name = seq_rename(r'C:\Users\[USERNAME]\Documents', 'test', '.csv')
Package: sequenticon
Sequenticon is a Python library to generateidenticonsfor DNA sequences, providing a simple visual way to instantly know that two sequences are different (different identicons) or very probably the same (same identicon), without needing to know the full sequence. For instance the sequenceATGGTGCAgets converted to the following icon:InfosPIP installation:pipinstallsequenticonGithub Pagehttps://github.com/Edinburgh-Genome-Foundry/sequenticonLicense:MIT, Copyright Edinburgh Genome FoundryMore biology softwareSequenticon is part of theEGF Codonssynthetic biology software suite for DNA design, manufacturing and validation.
Package: sequentium
SequentiumSequentium is a user-friendly package that implements various well-known sequences,
providing a seamless and intuitive experience for the user.For an exhaustive list of all sequences implemented in Sequentium,
please clickhere.If you would like to contribute to the project, take a look to the sectionHow to contributein the wiki.Quick startTo install Sequentium, use the following command:pipinstallsequentiumSuppose you want to work with the Fibonacci sequence. First, import it into your script:fromsequenceimportFibonacciSequencefibonacci=FibonacciSequence()Now, FibonacciSequence is a class representing the Fibonacci sequence. It behaves similarly to a list.
You can iterate through it:forxinfibonacci:print(x)>>0,1,1,2,3,5,8,13,21,...Or you can access a specific term directly:fibonacci[8]>>21Slicing is also supported:fibonacci[2:8]>>[1,2,3,5,13]Additionally, you can check if a number appears in theFibonacci sequence:7infibonacci>>False21infibonacci>>TrueCommand Line Interface (CLI)Sequentium provides a Command Line Interface (CLI) for convenient usage from your terminal.usage: Sequentium [-h] [-v] [--list {integer,generalised} [{integer,generalised} ...]] [-a AT] [-l] [--start START] [--stop STOP] [--step STEP] [-c CONTAINS] [sequence]

Sequentium is a user-friendly package that implements various well-known sequences, providing a seamless and intuitive experience for the user

positional arguments:
  sequence              Specify the name or identifier of the sequence to operate on.

options:
  -h, --help            show this help message and exit
  -v, --version         Display the version information.
  --list {integer,generalised} [{integer,generalised} ...]
                        List of implemented sequences.

sequence options:
  -a AT, --at AT        Retrieve the term at the specified index in the sequence.
  -l, --length          Display the length of the sequence.
  --start START         Define the starting point of the sequence.
  --stop STOP           End point of the sequence (excluded).
  --step STEP           Step size for iterating through the sequence.
  -c CONTAINS, --contains CONTAINS
                        Check if the sequence contains a specific value.

For help with a specific command, see: `sequence help <command>`Here are some examples illustrating the usage of the Sequentium CLI:specify the index to get a specific element ofFibonacciSequencesequence FibonacciSequence --at 8
>> 21define a range ofFibonacciSequenceusing start and stop parameterssequence FibonacciSequence --start 2 --stop 8
>> [1, 2, 3, 5, 8, 13]check if a particular number belongs to theFibonacciSequencesequence FibonacciSequence --contains 7
>> False
sequence FibonacciNumbers --contains 21
>> True
Package: sequestrum
SequestrumDescriptionA modern, lightweight dotfile manager for the masses. This README.md may look daunting, but trust me on this, it's easy as pie.
Promise. Now you may be wondering, why use this over Stow or Dotbot. Simple.Well for starters, the name is better. Do you need any
other reasons? Fine, fine.. some real reasons.This is specifically made for dotfile management and provides features like modularity,
dotfile repository setup, and more!Install GuideArch:yay -S sequestrum-gitPip:pip install --user sequestrumWikiFor help on writing a config and setting up Sequestrum, visit theWikiContributingIf you'd like to contribute, whether that'd be improving the comments or README (which could always use work), or adding functionality,
just fork this, add to it, then send a merge request. I'll try and get around to looking at it as soon as possible.
Be sure to readCONTRIBUTING.mdfirst though.LicenseCopyright (c) 2018-2018 Ivy Zhang. Released under the MIT License.
Package: sequgen
sequgenPurposeProgrammatically generate synthetic sequence data such as time series, strings, DNA, etc.
Sequence data generation is fully controlled by the user.
sequgen does not build models from real-world sequence data.Badgesfair-software.nl recommendations(1/5) code repository(2/5) license(3/5) community registry(4/5) citation(5/5) checklistoverallOther best practicesDocumentationSupported Python versionsCode qualityCode coverage of unit testsGitHub ActionsCitation metadata consistencyUnit testsInstallpip3 install sequgenUsage exampleThis usage example involves generating time series data. We generate a time series with
three channels: 1. a normal distribution, 2. Gaussian noise, and 3. the combination (sum)
of the first two channels. The normal distribution is positioned between 8 and 12 on an
abstract time axis of 100 intervals starting at 0 and ending at 20. The standard deviation
of the distribution is a value between 1 and 2 and its peak has a height between 4 and 5.
For the Gaussian noise we use the default values (standard deviation 1 and average value 0).
The third channel is defined as the sum of the other two channels. After creating the
three channels, graphs with their values are plotted:frommatplotlibimportpyplotaspltimportnumpyfromsequgen.deterministic.normal_peakimportnormal_peakfromsequgen.stochastic.gaussianimportgaussianfromsequgen.parameter_spaceimportParameterSpacefromsequgen.dimensionimportDimensiontime_axis=numpy.linspace(start=0,stop=20,num=101)parameter_space_0=ParameterSpace([Dimension("location",8,12),Dimension("stddev",1,2),Dimension("height",4,5),])channel_1=normal_peak(time_axis,**parameter_space_0.sample())channel_2=gaussian(time_axis)channel_3=channel_1+channel_2channels={"channel 1: normal peak":channel_1,"channel 2: gaussian noise":channel_2,"channel 3: combined":channel_3}i=0fortitle,channelinchannels.items():plt.subplot(len(channels),1,i+1)plt.plot(time_axis,channel)plt.title(title,y=0.75,x=0.01,loc="left")i+=1plt.show()And these are the results:You can find more usage examples in the notebooks repository on GitHub:https://github.com/sequgen/notebooks.ContributingFor developer documentation, go to thedeveloper's README.If you want to contribute to the development ofsequgen, have a look
at thecontribution guidelines.CreditsThis package was created withCookiecutterand theNLeSC/python-template.
Package: sequmap
sequmapEncode and embed sequences as kmer vectors (both NT and AA) and generate projections using UMAPSetuppip install sequmapUsageEmbed and project sequences usingfrom sequmap import sequmap, NT_DICT
proj = sequmap(seqs, ndim, k = 5, lookup_dic = NT_DICT, n_neighbors = 30, min_dist = 0.001)whereseqsis an array of strings,ndimis the number of projected dimensions andkis the kmer size. By default, sequences are embedded by counting all unique kmers and the distance between sequences is estimated using the SquaredEuclidean distance between dimensionality-reduced kmer vector.Additionally, a simplerseqpcamethod is included which just performs PCA in the kmer domain, used as follows:from sequmap import seqpca, NT_DICT
proj = seqpca(seqs, ndim, k = 5, lookup_dic = NT_DICT)The following lookup dictionaries are included for sequence encoding:AA_DICT = Dict(
    'A' => 1, 'C' => 2, 'D' => 3, 'E' => 4, 'F' => 5, 
    'G' => 6, 'H' => 7, 'I' => 8, 'K' => 9, 'L' => 10, 
    'M' => 11, 'N' => 12, 'P' => 13, 'Q' => 14, 'R' => 15, 
    'S' => 16, 'T' => 17, 'V' => 18, 'W' => 19, 'Y' => 20, 
    '*' => 21, 'X' => 22
    )

NT_DICT = Dict('A' => 1, 'C' => 2, 'G' => 3, 'T' => 4)
Package: sequoia-client-sdk-async
Sequoia Client SDK AsyncPython asyncio based SDK for interacting with Piksel Palette services, providing a high level interface to ease the
development of different pieces on top of this ecosystem.Among other characteristics it provides the following:Asyncrequests based onasyncioengine providing a high throughput.Lazy loadingto avoid use and discover not needed elements.Authenticationflow integrated and transparent.Discoveryfor Sequoia services, API resources and methods.Paginationautomatically handled using continue-based pagination. It's completely transparent to client users.Schemavalidation, including serialization from Sequoia API types into Python's native types and the opposite.Syntactic sugarto allow its usage be pythonic.RequirementsPython3.6+Installation$pipinstallsequoia-client-sdk-asyncUsageThe client understand three kind of elements:Service: Sequoia service against to the request will be performed.Resource: An specific resource of previous service.Method: Operation that will be performed (create,retrieve,update,delete,list).The syntax to interact with the client is the following for an specificresource(create,retrieve,update,delete):awaitclient.service.resource.method(params={},headers={})And the next one for interacting withcollections(list):asyncforiteminclient.service.resource.method(params={},headers={}):...# Do somethingExamplesHere is a list of some client usage examples.Iterate over a list of metadata offers filtered by availabilityStartAtimportsequoiaasyncwithsequoia.Client(client_id="foo",client_secret="bar",registry_url="https://foo.bar")asclient:asyncforofferinclient.metadata.offers.list(params={"withAvailabilityStartAt":"2000-01-01T00:00:00.000Z"}):...# Do fancy things with this offerCreate a metadata offerimportsequoiaasyncwithsequoia.Client(client_id="foo",client_secret="bar",registry_url="https://foo.bar")asclient:awaitclient.metadata.offers.create(json={"foo":"bar"})Retrieve a metadata offerimportsequoiaasyncwithsequoia.Client(client_id="foo",client_secret="bar",registry_url="https://foo.bar")asclient:offer=awaitclient.metadata.offers.retrieve(pk="foo")Update a metadata offerimportsequoiaasyncwithsequoia.Client(client_id="foo",client_secret="bar",registry_url="https://foo.bar")asclient:awaitclient.metadata.offers.update(pk="foo",json={"foo":"bar"})Delete a metadata offerimportsequoiaasyncwithsequoia.Client(client_id="foo",client_secret="bar",registry_url="https://foo.bar")asclient:awaitclient.metadata.offers.delete(pk="foo")
Package: seqviz
seqvizseqviz(sequence visualization) is a Python package to visualize sequence tagging results. It can be either be used
to print to console or in Jupyter Notebooks.UsageYou can load tagged sentences from many common formats:iob1fromseqvizimportTaggedSequencedata=[('Alex','I-PER'),('is','O'),('going','O'),('to','O'),('Los','I-LOC'),('Angeles','I-LOC'),('in','O'),('California','I-LOC')]tagged=TaggedSequence.from_bio(data,fmt="iob1")print(tagged)# [Alex](PER) is going to [Los Angeles](LOC) in [California](LOC)iob2fromseqvizimportTaggedSequencedata=[("Today","O"),("Alice","B-PER"),("Bob","B-PER"),("and","O"),("I","B-PER"),("ate","O"),("lasagna","O"),]tagged=TaggedSequence.from_bio(data,fmt="iob2")print(tagged)# Today [Alice](PER) [Bob](PER) and [I](PER) ate lasagnaBIOESfromseqvizimportTaggedSequencedata=[("Alex","S-PER"),("is","O"),("going","O"),("with","O"),("Marty","B-PER"),("A","I-PER"),("Rick","E-PER"),("to","O"),("Los","B-LOC"),("Angeles","E-LOC")]tagged=TaggedSequence.from_bio(data,fmt="bioes")print(tagged)# "[Alex](PER) is going with [Marty A Rick](PER) to [Los Angeles](LOC)"Output formatsUse it in terminal viastr(seq):[Alex](PER) is going to [Los Angeles](LOC) in [California](LOC)Or as HTML viaseq.to_html():Jupyter Notebook integrationYou can also useTaggedSequencein an Jupyter notebook:Integration with other NLP frameworksseqvizcan be used to visualize sequences from many different popular NLP frameworks.Hugging Face TransformersfromtransformersimportAutoModelForTokenClassification,AutoTokenizerimporttorchfromseqvizimportTaggedSequence,tokenize_for_bertmodel=AutoModelForTokenClassification.from_pretrained("dbmdz/bert-large-cased-finetuned-conll03-english")tokenizer=AutoTokenizer.from_pretrained("bert-base-cased")label_list=["O",# Outside of a named entity"B-MISC",# Beginning of a miscellaneous entity right after another miscellaneous entity"I-MISC",# Miscellaneous entity"B-PER",# Beginning of a person's name right after another person's name"I-PER",# Person's name"B-ORG",# Beginning of an organisation right after another organisation"I-ORG",# Organisation"B-LOC",# Beginning of a location right after another location"I-LOC"# Location]text="Hugging Face Inc. is a company based in New York City. Its headquarters are in DUMBO, therefore very "\"close to the Manhattan Bridge."inputs,groups=tokenize_for_bert(text,tokenizer)outputs=model(inputs)[0]predictions_tensor=torch.argmax(outputs,dim=2)[0]predictions=[label_list[prediction]forpredictioninpredictions_tensor]seq=TaggedSequence.from_transformers_bio(text,groups,predictions)