text:
package org.n52.iceland.event.events;

import org.n52.iceland.request.operator.RequestOperator;
import org.n52.shetland.ogc.ows.service.OwsServiceRequest;

/**
 * Event should be fired when a new {@link OwsServiceRequest} arrives in
 * the implemented {@link RequestOperator}
 *
 * @author Christian Autermann
 *
 * @since 1.0.0
 */
public class RequestEvent extends AbstractFlowEvent {

    private final OwsServiceRequest request;

    public RequestEvent(OwsServiceRequest request) {
        super(Thread.currentThread().getId());
        this.request = request;
    }

    public OwsServiceRequest getRequest() {
        return request;
    }

    @Override
    public String toString() {
        return String.format("RequestEvent[request=%s]", getRequest());
    }
}


text:
def extractShikkakuTranslations(item):
	"""
	# Shikkaku Translations

	"""
	vol, chp, frag, postfix = extractVolChapterFragmentPostfix(item['title'])
	if not (chp or vol) or 'preview' in item['title'].lower():
		return None
	if 'kuro no maou' in item['title'].lower():
		return buildReleaseMessageWithType(item, 'Kuro no Maou', vol, chp, frag=frag, postfix=postfix)
	if 'KENS' in item['tags']:
		return buildReleaseMessageWithType(item, 'Kamigoroshi no Eiyuu to Nanatsu no Seiyaku', vol, chp, frag=frag, postfix=postfix)
	return False

redpajama_set_name: RedPajamaGithub


text:
// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

using IdentityServer4.EntityFramework.DbContexts;
using IdentityServer4.EntityFramework.Mappers;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using System.Linq;
using IdentityServer4.EntityFramework.Storage;
using Serilog;

namespace IdentityServerTestApp
{
    public class SeedData
    {
        public static void EnsureSeedData(string connectionString)
        {
            var services = new ServiceCollection();
            services.AddOperationalDbContext(options =>
            {
                options.ConfigureDbContext = db => db.UseSqlite(connectionString, sql => sql.MigrationsAssembly(typeof(SeedData).Assembly.FullName));
            });
            services.AddConfigurationDbContext(options =>
            {
                options.ConfigureDbContext = db => db.UseSqlite(connectionString, sql => sql.MigrationsAssembly(typeof(SeedData).Assembly.FullName));
            });

            var serviceProvider = services.BuildServiceProvider();

            using (var scope = serviceProvider.GetRequiredService<IServiceScopeFactory>().CreateScope())
            {
                scope.ServiceProvider.GetService<PersistedGrantDbContext>().Database.Migrate();

                var context = scope.ServiceProvider.GetService<ConfigurationDbContext>();
                context.Database.Migrate();
                EnsureSeedData(context);
            }
        }

        private static void EnsureSeedData(ConfigurationDbContext context)
        {
            if (!context.Clients.Any())
            {
                Log.Debug("Clients being populated");
                foreach (var client in Config.Clients.ToList())
                {
                    context.Clients.Add(client.ToEntity());
                }
                context.SaveChanges();
            }
            else
            {
                Log.Debug("Clients already populated");
            }

            if (!context.IdentityResources.Any())
            {
                Log.Debug("IdentityResources being populated");
                foreach (var resource in Config.IdentityResources.ToList())
                {
                    context.IdentityResources.Add(resource.ToEntity());
                }
                context.SaveChanges();
            }
            else
            {
                Log.Debug("IdentityResources already populated");
            }

            if (!context.ApiResources.Any())
            {
                Log.Debug("ApiScopes being populated");
                foreach (var resource in Config.ApiScopes.ToList())
                {
                    context.ApiScopes.Add(resource.ToEntity());
                }
                context.SaveChanges();
            }
            else
            {
                Log.Debug("ApiScopes already populated");
            }
        }
    }
}


text:
"""
Exceptions used by the entire library.

@group Base exceptions:
    PyPe32Exception, PyPe32Warning

@group Warnings:
    PEWarning

@group Exceptions:
    PEException,NotValidPathException,WrongOffsetValueException,DirectoryEntriesLengthException,
    TypeNotSupportedException,ArrayTypeException,DataLengthException,ReadDataOffsetException,
    WriteDataOffsetException,InstanceErrorException,DataMismatchException,SectionHeadersException,
    DirectoryEntryException,InvalidParameterException
"""

__revision__ = "$Id$"

__all__ = [
           "PyPe32Exception",
            "PyPe32Warning",
            "PEWarning",
            "PEException",
            "NotValidPathException",
            "WrongOffsetValueException",
            "DirectoryEntriesLengthException",
            "TypeNotSupportedException",
            "ArrayTypeException",
            "DataLengthException",
            "ReadDataOffsetException",
            "WriteDataOffsetException",
            "InstanceErrorException",
            "DataMismatchException",
            "SectionHeadersException",
            "DirectoryEntryException",
            "InvalidParameterException",
           ]

class PyPe32Exception(Exception):
    """Base exception class."""
    pass

class PyPe32Warning(Exception):
    """Base warning class."""
    pass

class PEWarning(PyPe32Warning):
    """Raised when a suspicious value is found into the PE instance."""
    pass

class PEException(PyPe32Exception):
    """Raised when an invalid field on the PE instance was found."""
    pass

class NotValidPathException(PyPe32Exception):
    """Raised when a path wasn't found or it is an invalid path."""
    pass

class WrongOffsetValueException(PyPe32Exception):
    """
    Used primary by the L{ReadData} and L{WriteData} object in read/write operations when an invalid
    offset value was used.
    """
    pass

class DirectoryEntriesLengthException(PyPe32Exception):
    """Raised when the the number of entries in a L{DataDirectory} object is different from L{consts.IMAGE_NUMBEROF_DIRECTORY_ENTRIES}."""
    pass

class TypeNotSupportedException(PyPe32Exception):
    """This exception must be used when an invalid data type is used within the library."""
    pass

class ArrayTypeException(PyPe32Exception):
    """Raised when creating an unsupported type of array."""
    pass

class DataLengthException(PyPe32Exception):
    """Raised when data lengths does not match."""
    pass

class ReadDataOffsetException(PyPe32Exception):
    """This exception must be raised when reading from an invalid offset."""
    pass

class WriteDataOffsetException(PyPe32Exception):
    """This exception must be raised when writing to an invalid offset."""
    pass

class InstanceErrorException(PyPe32Exception):
    """This exception is raised when an instance parameter was not specified."""
    pass

class DataMismatchException(PyPe32Exception):
    """Raised when two different types of data does not match."""
    pass

class SectionHeadersException(PyPe32Exception):
    """Raised when an error related to a L{pype32.SectionHeader} or L{pype32.SectionHeaders} is found."""
    pass

class DirectoryEntryException(PyPe32Exception):
    """This exception must be raised when an error with the L{Directory} is found."""
    pass

class InvalidParameterException(PyPe32Exception):
    """Raised when an invalid parameter is received."""
    pass


text:
FLOATapp
========

Balloon Android game

Welcome to the our app!

To run this app in Eclipse:
- open Eclipse
- click File -> Import, click into Android folder, click Existing Android Code into Workspace
- click Browse -> <appfilepath>
- check the box next to the correct project, click Finish
- connect an Android device with API 9 or higher compatibility
- make sure your Android device allows outside sources
- back in Eclipse, in the Package Explorer tab, right click app folder, click Run As -> Android Application
- Select your Android device to run the app on
- Have fun! :D